• 【java进阶02：抽象类和接口】类与类之间的关系 抽象类与接口的区别

    目录

    抽象类

    接口

    抽象类

    1. 什么是抽象类

       

      1. /*
      2.         类————>对象 ：实例化     对象————>类 ：抽象
      4.     抽象类:
      5.         1、什么是抽象类？
      6.             类和类之间具有共同特征，将这些共同特征提取出来，形成的就是抽象类
      7.             类本身是不存在的，所以抽象类无法创建对象(无法实例化)
      9.         2、抽象类属于什么类型？
      10.             抽象类也属于引用数据类型。
      12.         3、抽象类怎么定义？
      13.             语法：
      14.                 [修饰符列表] abstract class 类名{
      15.                     类体;
      16.                 }
      18.         4、抽象类是无法实例化的，无法创建对象的，所以抽象类是用来被子类继承的。
      20.         5、final 和 abstract 不能联合使用
      21.            理解：abstract抽象类是用来被继承的，final修饰的类不允许被继承，所以两个关键字不能修饰同一个类
      23.         6、抽象类的子类可以是抽象类
      24.             抽象类可以不停的抽象下去。
      26.         7、抽象类虽然无法实例化，但是抽象类有构造方法，这个构造方法是供子类使用的
      28.         8、抽象类关联到一个概念：抽象方法。什么是抽象方法呢？
      29.            抽象方法表示：没有实现的方法，没有方法体的方法。例如：
      30.                public abstract void doSome();
      31.            抽象方法的特点：
      32.                1、没有方法体，以分号(;)结尾。
      33.                2、前面修饰符列表中有abstract关键字。
      35.         9、抽象类中不一定有抽象方法。非抽象类中 不得出现 抽象方法
      36.  */
      37. public class AbstractText01 {
      38.     public static void main(String[] args) {
      39.         //编译报错：Error: Account是抽象的; 无法实例化
      40.         //Account a = new Account();
      41.     }
      42. }
      43.  
      44. //银行账户类
      45.  
      46.         /*   final abstract class Account{} 
      47.            	 Error: 非法的修饰符组合: abstract和final。
      48.              理解：abstract抽象类是用来被继承的，final修饰的类不允许被继承，所以两个关键字不能修饰			   同一个类			*/
      49.  
      50. abstract class Account{
      51.     int i;
      52.     String s;
      53.     public Account(){
      54.  
      55.     }
      56.  
      57.     public Account(int i, String s) {
      58.         this.i = i;
      59.         this.s = s;
      60.     }
      61.  
      62.     //非抽象方法
      63.     public void doSome(){
      64.  
      65.     }
      66.     //抽象方法
      67.     public abstract void withdraw();
      68. }
      69.  
      70. //子类继承抽象类，子类可以实例化对象
      71.  
      72.         //抽象类的子类也可以是抽象类
      73.         //abstract class CreditAccount extends Account{}
      74.  
      75. //class CreditAccount extends Account{
      76. //
      77. //}

    2. 非抽象类继承抽象类，该抽象类中有抽象方法，非抽象子类中一定要对该抽象方法进行实现，否则报错

      1. /*
      2.     抽象类：
      3.         1、抽象类中不一定有抽象方法，非抽象类中不得出现抽象方法。
      5.         2、重要结论：
      6.             一个非抽象类继承抽象类，如果该抽象类中有抽象方法，在子类中必须将该抽象方法“实现”了。
      7.             这是java语法上强制规定的，必须的，否则会报错。
      8.             因为子类继承父类，将该抽象方法继承过来了，而非抽象类中不得出现抽象方法。
      9.             抽象方法在非抽象子类中的覆盖/重写，也叫做“实现”。(对抽象的实现)
      10.  */
      11. public class AbstractText02 {
      12.     public static void main(String[] args) {
      13.         //这里可以使用多态。
      14.         //父类型引用指向子类型对象。
      15.         Animal a = new Bird(); //向上转型(子--->父)。 自动类型转换。
      16.  
      17.         /*
      18.         这就是面向抽象编程。
      19.         调用时都是a.xxx,a的类型是Animal，Animal是抽象的。
      20.         面向抽象编程，不要面向具体编程。可以降低程序的耦合度，提高程序的扩展力。
      21.         这种编程思想符合OCP原则。
      23.         分析：
      24.             编译时：move()方法是Animal的
      25.             运行时：move()方法是Bird的
      26.          */
      27.  
      28.         a.move();
      29.     }
      30. }
      31.  
      32. //动物类(抽象类)
      33. abstract class Animal{
      34.     //抽象方法
      35.     public abstract void move();
      36.  
      37. }
      38.         /*  分析：
      39.                 Animal是父类，并且是一个抽象类
      40.                 Animal这个抽象类中有一个抽象方法move
      42.                 Bird是子类，非抽象类
      43.                 class Bird extends Animal{}
      44.                 Bird继承Animal类后，会将抽象方法也继承过来，但是因为他是非抽象类，非抽象类中不得出现抽象方法
      45.                     所以编译报错：
      46.                         Error: Bird不是抽象的, 并且未覆盖Animal中的抽象方法move()        */
      47.  
      48. //鸟类(非抽象类)
      49. class Bird extends Animal{
      50.     //解决方法:
      51.     //需要将从父类中继承过来的抽象方法进行覆盖/重写，或者叫做“实现”：把抽象方法实现。
      52.     //去掉abstract，然后加上大括号{}，去掉分号(;)
      53.     public void move(){
      54.         System.out.println("鸟儿在煽动翅膀");
      55.     }
      56. }
      57.  
      58. //Cat0类是抽象类，抽象类继承抽象类，则从抽象父类中继承过来的抽象方法也可以不用重写/覆盖/实现。
      59. abstract class Cat0 extends Animal{
      60.  
      61. }

    3. 面试判断题：java中凡是没有方法体的方法都是抽象方法。 错误的

      1. 判断：java中凡是没有方法体的方法都是抽象方法。
      2. 错误
      3.  
      4. 原因：
      5. - Object类中就有很多方法都没有方法体，都是以“;”结尾的，但是他们都不是抽象方法，例如：
      6. - public native int hashCode();
      7.   这个方法底层调用了C++的动态链接数据库程序。
      8. - 前面修饰符列表中没有abstract，有一个native，表示JVM本地程序。

    接口

    1. 接口的基础语法

      1. /*
      2.     接口：
      3.         1、接口也是一种“引用数据类型”，编译之后也是一个class字节码文件。
      5.         2、接口是完全抽象的(抽象类是半抽象)，或者也可以说：接口是特殊的抽象类。
      7.         3、接口怎么定义？语法是什么？
      8.             [修饰符列表] interface 接口名{}
      10.         4、接口支持多继承，一个接口可以继承多个接口
      12.         5、接口中只包含两部分内容：常量 、 抽象方法
      14.         6、接口中所有的元素都是public修饰的(都是公开的)
      16.         7、接口中的方法定义时：public abstract 修饰符可以省略
      17.             理解：接口中的方法都是抽象方法，所以可以省略。
      19.         8、接口中的常量的public static final 可以省略
      20.                理解：常量中的元素都是public修饰的，而常量中属性相关的又只有常量，所以定义时可以省略。
      21.                常量名的规范写法：全部字母大写。即使你定义的小写他也是常量。这只是一个规范。
      23.         9、接口中的方法不能有方法体。
      24.             理解：接口中的方法都是抽象方法，所以接口中的方法都不能有方法体。
      25.  */
      26. public class Text01 {
      27.     public static void main(String[] args) {
      28.         System.out.println(MyMath1.D);
      29.         //MyMath1.D = 8.8;
      30.         //Error:无法为最终变量D分配值
      31.         //MyMath1接口中的常量定义时， public static final 是省略了的。
      32.         //在这里D不能修改，反向证明接口中定义常量时public static final 可以省略。
      33.  
      34.     }
      35. }
      36.  
      37. //定义接口
      38. interface A3{
      39.  
      40. }
      41.  
      42. //接口支持继承
      43. interface B3 extends A3{
      44.  
      45. }
      46.  
      47. //一个接口可以继承多个接口。(支持多继承。)
      48. interface C3 extends A3,B3{
      49.  
      50. }
      51.  
      52. //我的数学接口
      53. interface MyMath1{
      54.     //常量
      55.     public static final double PI = 3.1415926;
      56.     //常量中的元素都是public修饰的，而常量中属性相关的又只有常量，所以定义时，public static final 可以省略。
      57.     double D = 9.9;
      58.  
      59.     //抽象方法
      60.     public abstract int sum(int a,int b);
      61.  
      62.     //接口中既然都是抽象方法，那么在编写代码的时候，public abstract 可以省略吗？
      63.     int doSome(int c,int d);
      64.  
      65.     //接口中的方法可以有方法体吗？ 不可以，因为接口中的方法都是抽象方法。
      66.     //Error: 接口抽象方法不能带有主体
      67.     //void doOther(){}
      68.  
      69.     //相减的抽象方法
      70.     int sub(int a,int b);
      71. }
      72.

    2. 基础语法2

      1. 10、一个非抽象的类，实现接口的时候，必须将接口中的方法加以实现
      2. 11、一个类中可以有多个接口
      3. 12、extends 和implements 可以共存，extends在前，implements在后
      4. 13、使用接口写代码的时候，可以使用多态(父类型的引用指向子类型的对象)

      非抽象的类实现接口，要将接口中的所有的方法实现。

      1. /*
      2.     接口的基础语法：
      3.         1、类和类之间的关系叫做继承，类与接口之间叫“实现”（仍然可以将“实现”看作“继承”）
      4.             继承使用 extends关键字 完成
      5.             实现使用 implements关键字 完成。
      6.         2、 ★结论:当一个非抽象的类实现接口时，必须将该接口中的所有抽象方法全部实现(覆盖/重写)
      7.  */
      8. public class Text02 {
      9.     public static void main(String[] args) {
      10.         //new MyMath2();
      11.         //Error: MyMath2是抽象的; 无法实例化
      12.  
      13.         //这里可以使用多态，即父类型的引用指向子类型的对象。
      14.         MyMath2 mm = new MyMath2Impl();
      15.         //调用接口里面的方法(面向接口编程)
      16.         //编译时在接口里找方法，运行时实际运行的是子类中的那个方法。
      17.         System.out.println(mm.sum(10,5));
      18.         System.out.println(mm.sub(10,5));
      19.  
      20.     }
      21. }
      22.  
      23. //特殊的抽象类，完全抽象的，叫做接口
      24. interface MyMath2{
      25.     double PI = 3.1415926;
      26.     int sum(int a,int b);
      27.     int sub(int a,int b);
      28. }
      29.  
      30. //这是一个“非抽象”的类，类的名字是随意的。
      31.             //abstract class MyMath2Impl implements MyMath2{}
      32.             //这样是没问题的，因为他前面加了一个abstract，他也是抽象的。
      33.  
      34.             //class MyMath2Impl implements MyMath2{}
      35.             //Error: MyMath2Impl不是抽象的, 并且未覆盖MyMath2中的抽象方法sub(int,int)
      36.  
      37. //修正
      38. class MyMath2Impl implements MyMath2{
      39.     //重写/覆盖/实现 接口中的方法(通常叫做实现。)
      40.     /*
      41.         int sum(int a,int b){
      42.             return a+b;
      43.           }
      44.     Error: MyMath2Impl中的sum(int,int)无法实现MyMath2中的sum(int,int)
      45.           正在尝试分配更低的访问权限; 以前为public
      48.      */
      49.  
      50.     //在类中重写时，补充上抽象方法的修饰符public(在非抽象类中重写时去掉abstract)，因为有返回值类型，所以加上return
      51.     public int sum(int a,int b){
      52.      return a+b;
      53.     }
      54.     public int sub(int a,int b){
      55.         return a-b;
      56.     }
      57.  
      58.  
      59. }

      一个类可以实现多个接口，以及接口转型

      1. /*
      2.     接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？   可以。
      3.         对于计算机来说，一个机箱上有多个接口，一个接口是接键盘的，一个接口接鼠标，一个接口接电源，一个接显示器....
      5.     ★★：一个类可以同时实现多个接口
      7.     这种机制弥补了java中的一个缺陷：
      8.         java中类和类只支持单继承。实际上单继承是为了简单而出现的，现实世界中存在多继承
      9.         java中的接口弥补了单继承带来的缺陷
      11.     接口A与接口B虽然没关系，但是写代码的时候，可以互相转换。
      12.     编译可以通过，但是运行时可能出现：ClassCastException异常(类型转换异常)
      14.     之前的一个结论
      15.         无论向上转型/向下转型，两个类之间必须有继承关系，没有继承关系在这里会报错。(这句话不适用在接口方面)
      16.         最终实际上还是需要和之前一样，需要加：instanceof运算符进行判断。
      17.         向下转型养成好习惯。转型之前先加if + instanceof进行判断。
      18.         instanceof  运行阶段动态判断
      21.  */
      22. public class Text03 {
      23.     public static void main(String[] args) {
      24.         //使用多态：父类型引用指向子类型对象。
      25.         A4 a = new D4();
      26.         B4 b = new D4();
      27.         C4 c = new D4();
      28.  
      29.         //a.m2();     
      30.         //编译报错。A接口中没有m2()方法。
      31.  
      32.             //这里编译时a本来是A4类型对象，强制转换给B4.
      33.             //运行时始终是D4类型对象。在D4中找m2方法，可以找到。所以编译和运行都没问题。
      34.         //调用其他接口中的方法，需要转型(接口转型)
      35. //        B4 a2 = (B4)a;
      36. //        a2.m2();
      37.         if (a instanceof B4){
      38.             B4 a2 = (B4)a;
      39.             a2.m2();
      40.         }
      41.  
      42.  
      43.         //直接向下转型为D4可以吗？可以
      44.         //如果a是D4类型的，才会进行向下转型。
      45.         if (a instanceof D4){
      46.             D4 d =(D4)a;
      47.             d.m2();
      48.         }
      49.  
      50.         Y y = new Z();
      51.         //经过测试：接口和接口之间在进行强制类型转换时，没有继承关系，也可以强转。
      52.         //但是一定注意：运行时可能会出现ClassCastException异常(类型转换异常)
      53.         //编译时没有问题，运行时才出现。y与Z有关系，与X没有关系。
      54.         if(y instanceof X){
      55.             X x = (X)y;
      56.         }
      57.     }
      58. }
      59. //接口之间的类型转换
      60. interface X{
      61.  
      62. }
      63. interface Y{
      64.  
      65. }
      66. class Z implements Y{
      67.  
      68. }
      69. //-----------------------------------------------------------------------
      70. interface A4{
      71.     void m1();
      72. }
      73.  
      74. interface B4{
      75.     void m2();
      76. }
      77.  
      78. interface C4{
      79.     void m3();
      80. }
      81.  
      82. class D4 implements A4,B4,C4{
      83.     //实现A4中的接口
      84.     public void m1(){
      85.  
      86.     }
      87.     //实现B4中的接口
      88.     public void m2(){
      89.         System.out.println("m2");
      90.     }
      91.     //实现4中的接口
      92.     public void m3(){
      93.  
      94.     }
      95. }
      96.  
      97.

      继承与实现共存时，extends在前，implements在后。

      1. /*
      2.     继承和实现都存在，应该怎么写
      3.         extends 关键字在前   implements关键字在后。
      4.  */
      5. public class Text04 {
      6.     public static void main(String[] args) {
      7.         //创建对象(表面上看Animal类没起作用)
      8.         Flyable f = new Cat2();//多态
      9.         f.fly();
      10.  
      11.         //同一个接口
      12.         Flyable f2 = new Pig();
      13.         //调用同一个fly方法，最后执行的效果不同
      14.         f2.fly();
      15.  
      16.         Flyable f3 = new fish();
      17.         f3.fly();
      18.  
      19.     }
      20. }
      21.  
      22. //动物类：父类
      23. class Animal2{
      24.  
      25. }
      26. //可飞翔的接口(是一对翅膀)
      27. //能插拔的就是接口(没有接口就不能插拔)  如：内存条插到主板上，他们之间有接口，就可以更换内存条。
      28. //接口通常提取的是行为动作。
      29. interface Flyable{
      30.     void fly();
      31. }
      32.  
      33. //动物类子类：猫类
      34. //Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变得可以飞翔
      35. class Cat2 extends Animal2 implements Flyable{
      36.     public void fly(){
      37.         System.out.println("啊飞猫");
      38.     }
      39. }
      40.  
      41. //蛇类，如果你不想让他飞，可以不实现Flyable接口
      42. //没有实现这个接口就表示没有翅膀，没有插翅膀，肯定不能飞
      43. class Snake extends Animal2{
      44.  
      45. }
      46.  
      47. //猪类， 想飞就插上翅膀这个接口
      48. class Pig extends Animal2 implements Flyable{
      49.     public void fly(){
      50.         System.out.println("我是一只会飞的猪，我真了不起！！！");
      51.     }
      52. }
      53.  
      54. //鱼类(默认是存在继承的，继承Object类)
      55. //class fish extends Object implements Flyable{ public void fly(){}}
      56. class fish implements Flyable{//没写extends ,也是有继承的，默认继承Objext。
      57.     public void fly(){
      58.         System.out.println("我是六眼飞鱼(流言蜚语)！！");
      59.     }
      60. }

    3. 接口在开发中的作用

      1.     注意：接口在开发中的作用，类似于多态在开发中的作用
      3.     多态：面向抽象编程，不要面向具体编程。面向抽象编程可以降低程序的耦合度，提高程序的扩展力
      4.     接口是完全抽象的，而我们以后正好要求面向抽象编程。面向抽象编程这句话以后可以修改为：面向接口编程。
      5.     有了接口就有了可插拔，可插拔表示扩展力很强。不是焊死的。
      7.     主板和内存条之间有插槽，这个插槽就是接口，内存条坏了，可以重新买一个换下来，这叫做：高扩展性(低耦合度)
      9.     接口在现实世界中到处都是
      10.         螺栓和螺母之间有接口、灯泡和灯口之间有接口、笔记本电脑和键盘之间有接口(USB接口，这个接口是计算机协会制定的协议/规范)
      11.         接口有什么用？扩展性好，可插拔。接口是一个抽象的概念。
      13.     分析：
      14.         中午去饭馆吃饭，这个过程中有接口吗？
      15.         接口是抽象的。
      16.             菜单就是一个接口。(菜单上有一个抽象的照片：西红柿炒鸡蛋)
      17.             谁面向接口调用？(顾客，面向菜单点菜，调用接口。)
      18.             谁负责实现这个接口？(后台的厨师，负责做好菜。是接口的实现者)
      20.             这个接口有什么用呢？
      21.                 这个饭馆的“菜单”让“顾客”和“厨师”之间解耦合了(顾客和厨师之间的耦合度降低。)
      22.                 顾客不用找后厨，后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通
      24.     总结：(解耦合)
      25.         面向接口编程，可以降低程序的耦合度，提高程序的扩展力。符合OCP开发原则，接口的使用离不开多态机制。
      26.         (接口+多态 才可以达到降低耦合度)
      28.         接口可以解耦合，解开的是谁和谁的耦合？
      29.             任何一个接口都有调用者和实现者。接口可以将调用者和实现者解耦合。
      30.             调用者面向接口调用，实现者面向接口编写实现。
      32.         以后进行大的项目开发，一般都是将项目分离成一个模块一个模块的，模块和模块之间采用接口衔接，来降低耦合度。
      1. /*
      2.         本项目
      3.             菜单接口写出来后，可同时写调用和实现。写调用的只关心菜单，跟厨师无关，写实现的只关心菜单，跟顾客也无关
      4.             都是只关心菜单，从而降低了耦合度，提高开发效率(调用和实现可以交给不同的人同时编写。)
      5.  */
      6. public class Text05 {
      7.     public static void main(String[] args) {
      8.  
      9.         //创建厨师对象
      10.         FoodMenu cook1 = new ChinaCook();
      11.         //创建顾客对象    //java中有个名言：想要什么就new个什么，然后传进去。
      12.         Customer1 customer = new Customer1(cook1);
      13.         customer.order();
      14.  
      15.         //创建西餐厨师对象
      16.         FoodMenu cook2 = new AmericanCook();
      17.         Customer1 customer2 = new Customer1(cook2);
      18.         customer2.order();
      19.     }
      20. }
      21.  
      22.  
      23. //接口：菜单 抽象的
      24. interface FoodMenu {
      25.     //西红柿炒鸡蛋
      26.     void fanQieCJiDan();
      27.     //鱼香肉丝
      28.     void yuXiangRouSi();
      29. }
      30.  
      31. class Customer1{
      32.     //顾客手里有一个菜单
      33.     //Customer has a FoodMenu (这句话什么意思：顾客有一个菜单。)
      34.     //凡是能够使用has a 来描述的，统一以属性的方式存在。
      35.     //实例变量，属性
      36.     //面向抽象编程、面向接口编程。降低程序的耦合度，提高程序的扩展力
      37.     private FoodMenu foodMenu;//要养成封装的好习惯，封装后提供set和get方法
      38.  
      39.     //构造方法
      40.     public Customer1(){
      41.  
      42.     }
      43.     public Customer1(FoodMenu foodMenu){
      44.         this.foodMenu = foodMenu;
      45.     }
      46.     public FoodMenu getFoodMenu(){
      47.         return foodMenu;
      48.     }
      49.     public void setFoodMenu(FoodMenu foodMenu){
      50.         this.foodMenu = foodMenu;
      51.     }
      52.  
      53.     //提供一个点菜的方法
      54.     public void order(){
      55.         //先拿到菜单才能点菜
      56.         //调用get方法拿菜单
      57.         //FoodMenu fm =this.getFoodMenu();
      58.  
      59.         //也可以不调用get方法，因为私有的属性在本类中是可以访问的
      60.         this.foodMenu.fanQieCJiDan();
      61.         //this.表示本对象的，可以省略
      62.         this.foodMenu.yuXiangRouSi();
      63.     }
      64.  
      65.     //如果以下这样写，就表示写死了(焊接了，不能可插拔了)。只能吃中餐的/西餐的
      66.     //中餐厨师
      67. //    ChinaCook cc;
      68. //    AmericanCook ac;
      69.  
      70.  
      71.     /*
      72.         Cat is a Animal 但凡满足 is a 的表示都可以设置为继承。
      73.         Customer has a FoodMenu 但凡是满足has a 的表示都以属性的形式存在。
      74.      */
      75.  
      76.  
      77. }
      78.  
      79. //中餐厨师 实现菜单上的菜
      80. //厨师是接口的实现者
      81. class ChinaCook implements FoodMenu{
      82.     public void fanQieCJiDan(){
      83.         System.out.println("西红柿炒鸡蛋");
      84.     }
      85.     public void yuXiangRouSi(){
      86.         System.out.println("鱼香肉丝");
      87.     }
      88. }
      89.  
      90. //西餐厨师
      91. class AmericanCook implements FoodMenu{
      92.     public void fanQieCJiDan(){
      93.         System.out.println("Scrambled egg with tomato");
      94.     }
      95.     public void yuXiangRouSi(){
      96.         System.out.println("Yu-Shiang Shredded Pork");
      97.     }
      98. }
      99.  
      100.

    4. 类与类之间的关系： is a(继承) 、 has a(关联) 、 like a(实现)

      1. 类和类之间的关系：
      2.     is a(继承) 、 has a(关联) 、 like a(实现)
      3.  
      4.     is a :
      5. Cat is a Animal（猫是一个动物）
      6.     凡是能够满足is a 的表示“继承关系”
      7.     A extends B
      8.  
      9.     has a:
      10. I has a Pen （我有一支笔）
      11.     凡是能够满足has a 的表示“关联关系”
      12.     A{
      13.     B b;
      14. }
      15.  
      16. like a:
      17. Cook like a FoodMenu （厨师像一个菜单一样）
      18.     这里的“像”，不是表面上的像，而是厨师能做出菜单中的菜，厨师把菜单里的菜做了出来。
      19.     凡是能够满足like a 关系的表示“实现关系”
      20.     实现关系通常是：类实现接口
      21.     A implements B

    5. 抽象类与接口有什么区别：

      1. 在这里我们只说一下抽象类和接口在语法上的区别。至于以后用抽象类还使用接口，通过项目去体会/学习
      2.  
      3. 抽象类是半抽象的
      4. 接口是完全抽象的
      5.  
      6. 抽象类中有构造方法
      7. 接口中没有构造方法
      8.  
      9. 接口和接口之间支持多继承
      10. 类和类之间只能单继承
      11.  
      12. 一个类可以同时实现多个接口
      13. 一个抽象类只能继承一个类(单继承)
      14.  
      15. 接口中只允许出现常量和抽象方法。
      16.  
      17. 以后接口使用的比抽象类多，一般抽象类使用的少。
      18. 接口一般都是对“行为”的抽象。抽象类既可以抽象“行为”，又可以抽象“数据”
  • 相关阅读:
    ElasticSearch入门笔记
    07. 算法之一致性哈希算法介绍
    Mac的入坑指南
    Android数据库处理重复插入Insert数据的问题
    .NET Entity FrameWork 总结 ，在项目中用处个人感觉不大。适合初级用用，不涉及到与数据库通信。
    Strimzi Kafka Bridge(桥接)实战之二：生产和发送消息
    Nanoprobes FluoroNanogold 偶联物的特色和应用
    智源论文前沿记录230610
    Spring Batch：处理大数据和批量任务的解决方案
    SpringBoot 如何集成 MyBatisPlus
  • 原文地址：https://blog.csdn.net/m0_69066786/article/details/127910936