1.多态
多态的概念：通俗来说，就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同 的状态。
向上转型
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用。
语法格式：**父类类型 对象名 = new 子类类型（）**这种是【直接赋值法】
Animal animal = new Dog( );
animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。
除了这种方式还有两种：
-
方法传参
-
方法返回
public static Animal func(){
return new dog();
}
public static void main(Sting[] args){
func();
}
重写
重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程
进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。
【方法重写的规则】
- 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
- 被重写的方法返回值类型可以不同，但是必须是具有父子关系的
- 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方 法就不能声明为 protected
- 父类被static、private修饰的方法、构造方法都不能被重写。
- 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心 将方法名字拼写错了
(比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法 构成重写.
【重写和重载的区别】
即：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
例子
有了面的向上转型, 动态绑定, 方法重写之后, 我们就可以使用 多态(Polymorphism) 的形式来设计程序。
class Shape{// 无论是 三角形，还是正方形等等，它们都是图形
// 以此作为共性抽出
public void draw(){
System.out.println("Shape::draw()");
}
}
// 矩形
class Rect extends Shape{
@Override// 当我们在子类中，重写了父类中的方法。那么父类方法中的输出语句就显得毫无意义
// 最后都是输出子类draw方法，如果你想的话，可以删掉父类的 输出语句
public void draw(){
System.out.println("♦");
}
}
// 花
class Flower extends Shape{
@Override
public void draw() {
System.out.println("❀");
}
}
public class Test {
public static void paint(Shape shape){
shape.draw();
}
public static void main(String[] args) {
Rect rect = new Rect();
paint(rect);
paint(new Rect());
System.out.println("=============");
Flower flower = new Flower();
paint(flower);
paint(new Flower());
}
}
从另一个方面来说：通过一个引用来调用不同的draw方法，会呈现出不同的表现形式。表现的形式取决于将来它引用那个对象。这就是动态。而且实现多态的大前提，就是一定要向上转型，且实现 父类和子类的重写方法。
总结：
在这个代码中, 上方的代码（矩形、花、继承）是 类的实现者 编写的, 下方的代码（main所在的类）是 类的调用者 编写的。当类的调用者在编写 Paint 这个方法的时候, 参数类型为 Shape (父类), 此时在该方法内部并不知道, 也不关注当前的 shape。
引用指向的是哪个类型(哪个子类)的实例. 此时 shape 这个引用调用 draw 方法可能会有多种不同的表现。(和 shape 对应的实例相关), 这种行为就称为 多态。
多态 顾名思义, 就是 “一个引用, 能表现出多种不同形态”
2.抽象类
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果
一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
// 抽象类：被abstract修饰的类
public abstract class Shape {
// 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}
抽象类和普通类的区别？
1.抽象类 使用abstract修饰；
2.抽象类不能被实例化；（不能new）
3.此时在抽象类中，可以有抽象方法，或者 非抽象方法
4.什么是抽象方法。一个方法被abstract修饰，没有具体的实现。只要包含抽象方法，这个类必须是抽象类。
5.当一个普通类继承了这个抽象类，必须重写抽象类当中的抽象方法。
6.抽象类存在的最大的意义，就是为了被继承。
7.抽象方法不能被private、final、static，所以，一定要满足方法重写的规则
8.当一个子类没有重写抽象父类的方法，可以把当前子类变为abstract修饰。
9.抽象类当中不一定包含抽象方法。
10.抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。
抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.
普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?
确实如此. 但是使用抽象类相当于多了一重编译器的校验（如果你没有重写抽象方法，编译器会报错，提醒你）
3.接口
在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。
接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。
在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
接口是抽象类的更进一步. 抽象类中还可以包含非抽象方法和字段. 而接口中包含的方法都是抽象方法, 字段只能包含静态常量
语法规则
接口的定义格式与定义类的格式基本相同，将class关键字换成interface 关键字，就定义了一个接口。
提示:
- 创建接口时, 接口的命名一般以大写字母 I 开头.
- 接口的命名一般使用 “形容词” 词性的单词.
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}
接口使用
接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法
public class 类名称 implements 接口名称{...}
注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系
接口特性
- 接口类型是一种引用类型，但是不能直接new接口的对象
public class TestUSB {
public static void main(String[] args) {
USB usb = new USB();
}
}
// Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化
- 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为
public abstract（只能是public abstract，其他修饰符都会报错)
public interface USB {
// Error:(4, 18) java: 此处不允许使用修饰符private
private void openDevice();
void closeDevice();
}
- jdk8中：接口中还可以包含default方法
public interface USB {
default void closeDevice();
}
- 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
public interface USB {
void openDevice();
// 编译失败：因为接口中的方式默认为抽象方法
void closeDevice(){
System.out.println("关闭USB设备");
}
}
- 重写接口中方法时，不能使用默认的访问权限
public interface USB {
void openDevice(); // 默认是public的
void closeDevice(); // 默认是public的
}
public class Mouse implements USB {
@Override
void openDevice() {
System.out.println("打开鼠标");
}
}
// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
public interface USB {
double brand = 3.0; // 默认被：final public static修饰
void openDevice();
void closeDevice();
}
public class TestUSB {
public static void main(String[] args) {
System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
USB.brand = 2.0; // 说明brand具有final属性
}
}
- 接口中不能有静态代码块和构造方法
public interface USB {
// 编译失败
public USB(){
}
{} // 编译失败
void openDevice();
void closeDevice();
}
- 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
- 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
- 当一个类实现接口之后，重写抽象方法的时候，重写方法的前面必
须加上public，因为接口中方法默认都是public的，而且重写方法的访
问权限，必须要大于等于父类当中方法的访问权限。 - 一个类可以通过关键字extends继承一个抽象类或者普通类。但是
只能继承一个类。同时也可以通过implements实现多个接口。接口之
间使用逗号隔开。 - 接口与接口之间，可以使用 extends来 操作它们的关系，此时，extends 在这里意为 拓展，而不是继承，(一个接口 通过 extends 来拓展 另一个接口的功能)
由此得出结论：接口当中的方法（静态，和 默认），只能通过 接口的引用来调用
实现多个接口
在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
另外我们再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
接下来我们创建几个具体的动物 --猫, 是会跑的
class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在用四条腿跑");
}
}
鱼, 是会游的
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "正在用尾巴游泳");
}
}
青蛙, 既能跑, 又能游(两栖动物)
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(this.name + "正在蹬腿游泳");
}
}
还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”
class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在用翅膀飞");
}
@Override
public void run() {
System.out.println(this.name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在漂在水上");
}
}
注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
提示, IDEA 中使用 ctrl + i 快速实现接口
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性
接口间的继承
接口间的继承相当于把多个接口合并在一起.
这样设计有什么好处呢?
时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型, 而只关注某个类是否具备某种能力
在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。
举例上面的青蛙是两栖动物：
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}
通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.
抽象类和接口的区别
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.
如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口.
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类. 万一不小心创建了 Animal 的实例, 编译器会及时提醒我们.
