抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别。 核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。 如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口. public class Animal { public String name; public Animal(String name) { this.name = name; } }

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。 接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字. interface IRun { void run(); } interface ISwim { void swim(); } // 两栖的动物, 既能跑, 也能游 interface IAmphibious extends IRun,ISwim{ } public class Frog extends Animal implements IAmphibious{ ... } 通过接口继承创建一个新的接口IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物。 abstract public class Animal { public String name; public Animal(String name) { this.name = name; } } 另外我们再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”。 interface IFly { void fly(); } interface IRun { void run(); } interface ISwim { void swim(); } 接下来我们创建几个具体的动物： 猫, 是会跑的。 public class Cat extends Animal implements IRun{ public Cat(String name) { super(name); } @Override public void run() { System.out.println(this.name + "正在用四条腿跑"); } } 鱼，是会游泳的 public class Fish extends Animal implements ISwim{ public Fish(String name) { super(name); } @Override public void swim() { System.out.println(this.name + "正在游泳"); } } 青蛙，既能跑，又能游泳（两栖动物） public class Fish extends Animal implements IRun,ISwim{ public Fish(String name) { super(nam

接口用来描述类应该做什么，而不指定它们具体应该如何做。一个类可以实现一个或多个接口。有些情况可能要求符合这些接口，主要有这种要求，就可以使用实现了这个接口的类（即实现类）的对象。 1、接口的概念 在Java程序设计语言中，接口不是类，而是对希望符合这个接口的类的一组需求。 接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。 在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。 2、接口的语法规则 接口的定义格式与定义类的格式基本相同，将class 关键字换成interface关键字，就定义了一个接口。 public interface 接口名称{ // 抽象方法 } 注意事项： 1）创建接口时，接口的命名一般以大写字母I开头 2）接口命名一般使用“形容词”词性的单词。 3、接口的使用 接口不能直接被使用，必须有一个"实现类"来实现该接口，实现接口的所有的抽象方法。 public class 类名 interface 接口名称{ // 可以使用,分隔，实现多个接口 // ... } 注意：子类和父类之间是extends 继承关系，类与接口之间是implements 实现关系。 4、接口的特性 1）接口类型是一种引用类型，但是不能直接new 接口的对象 2）接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错) 3）接口中的方法是不能在接口中实现的，只能由实现接口的类来实现 4）重写接口中方法时，不能使用默认的访问权限 5）接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量 6）接口中不能有静态代码块和构造方法（编译错误） 7）接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class 8）如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

1、抽象类的概念 在面向对象的概念中，所有的对象都是通过类来描绘的，但是放过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。 2、抽象类的语法 在Java 中，一个类如果被abstract 修饰的类成为抽象类，抽象类中被abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。 抽象类的定义格式如下： abstract class 抽象类名{ 属性; // 普通方法 访问权限 返回值类型 方法名称(参数){ return [返回值]; } // 抽象方法,无方法体 访问权限 abstract 返回值类型 抽象方法名称(参数); } 从以上格式可以看出，抽象类的定义比普通类多了抽象方法，类的其他功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。 3、抽象类的特性 1）抽象类不能直接实例化对象 2）抽象方法不能是被 private 修饰的 3）抽象方法不能被final 和 static修饰，因为抽象方法要被子类重写。 4）抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰，如果一个非抽象类继承了抽象类，那么这个子类必须实现抽象类中的全部抽象方法。 abstract class Shape { // 抽象方法 public abstract void draw(); } abstract class A extends Shape { public abstract void testA(); } class B extends A { @Override public void testA() {} @Override public void draw() {} } 5）抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类 6）抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

1、多态的概念 多态是同一个行为具有多个不同表现形式或形态的能力。 多态就是同一个接口，使用不同的实例而执行不同操作，如图所示： 多态性是对象多种表现形式的体现。 同一个事件发生在不同的对象上会产生不同的结果。 2、多态的优点 消除类型之间的耦合关系 可替换性 可扩充性 接口性 灵活性 简化性 3、多态存在的三个必要条件 继承 重写 重写：子类对父类的允许访问的方法的实现过程进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写。 重写的好处：在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。 class Animal { public void eat() { System.out.println("正在吃..."); } } class Dog extends Animal { public void eat() { System.out.println("狗正在吃狗粮..."); } } class Bird extends Animal { public void eat() { System.out.println("鸟正在吃鸟粮..."); } } public class Test1 { public static void fun(Animal animal) { animal.eat(); } public static void main(String[] args) { Dog dog = new Dog(); fun(dog); Bird bird = new Bird(); fun(bird); } } // 运行结果 狗正在吃狗粮... 鸟正在吃鸟粮... 重写（覆盖）的规则： 方法名相同 参数列表相同【顺序、个数、类型】 返回值相同 父类引用指向子类对象 比如：Animal dog = new Dog(); 当使用多态方式调用方法时，首先检查父类中

Java 中不支持多继承，但支持多重继承。 继承特性 1）子类拥有父类非 private 的属性、方法。 2）子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。 3）子类可以用自己的方式实现父类的方法。 4）Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。 5）提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。 super 与 this 关键字 super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类 this关键字：指向自己的引用。 class Animal { void eat() { System.out.println("animal : eat"); } } class Dog extends Animal { void eat() { System.out.println("dog : eat"); } void eatTest() { this.eat(); // this 调用自己的方法 super.eat(); // super 调用父类方法 } } public class Test { public static void main(String[] args) { Animal a = new Animal(); a.eat(); Dog d = new Dog(); d.eatTest(); } } // 运行结果 //animal : eat //dog : eat //animal : eat final 关键字 final关键字声明类

1、继承的概念 继承是 java 面向对象编程技术的一块基石，因为它允许创建分等级层次的类。 继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的实例域和方法，或子类从父类继承方法，使得子类具有父类相同的行为。 生活中的继承 兔子和羊属于食草动物，狮子和老虎属于食肉动物。 食草动物和食肉动物又是属于动物。 所有的继承需要符合的关系：is-a，父类更通用，子类更具体。 虽然食草动物和食肉动物都是属于动物，但是两者的属性和行为上有差别，所以子类会具有父类的一般特性也会具有自身的特性。 2、继承的格式 在 Java 中通过关键字 extends 来声明一个类是从另一个类继承而来的，一般格式如下： class 父类 { } class 子类 extends 父类 { } 3、为什么继承 接下来我们通过实例的说明这个需求。 开发动物类，其中动物分别为狗和猫，要求如下： 狗：属性（姓名，颜色），方法（吃，叫） 猫：属性（姓名，颜色），方法（吃，叫） class Dog{ private String name; private String color; public void eat() { System.out.println(this.name + "正在吃..."); } public void cry() { System.out.println(this.name + "正在叫..."); } } class Cat { private String name; private String color; public void eat() { System.out.println(this.name + "正在吃..."); } public void cry() { System.out.println(this.name + "正在叫..."); } } 从这两段代码可以看出来，代码存在重复了，导致后果就是代码量大且臃肿，而且维护性不高(维护性主要是后

1、封装的概念 在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 要访问该类的代码和数据，必须通过严格的接口控制。 封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。 适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。 2、为什么封装 封装的目的是保护数据的安全和完整性，同时隐藏数据的实现细节，提高代码的可维护性和可扩展性，具体有以下几个方面的好处： 良好的封装能够减少耦合。 类内部的结构可以自由修改。 可以对成员变量进行更精确的控制。 隐藏信息，实现细节。 3、封装的实现步骤 修改属性的可见性来限制属性的访问（用private来修饰），如： public class Test { private String name; private int age; } 这段代码中，将name 和 age 属性设置为私有的，只有在本类中被访问，其他类访问不了，就实现对信息的隐藏。 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如： public class Test { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } } 采用 this 关键字是为了解决实例变量和局部变量之间发生的同名的冲突。

在声明成员变量的时候，就可以给出初始值。 class Date{ public int year = 2021; public int month = 5; public int day = 19; public Date() {} public Date(int year, int month, int day) { this.year = year; this.month = month; this.day = day; } public void printDate(){ System.out.println(this.year + "/" +this.month + "/" + this.day); } } public class Test2 { public static void main(String[] args) { Date d = new Date(2023,9,17); d.printDate(); Date d1 = new Date(); d1.printDate(); } } // 运行结果 // 2023/9/17 // 2021/5/19 注意：代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中。