hello，上文带大家学习了java中类的继承，我们可以创建一个父类，将类中的共性抽取出来，通过子类继承的方式来实现代码的复用。今天带大家学习不同类之间的另外几种关系，即多态抽象类和接口。

多态的概念

多态，从字面意思去形象的理解可以解释为：针对不同的对象执行某一行为时，不同的对象会有不同的状态。

比如猫和狗都是动物，他们都有进食这个行为但是当我们调用狗这个对象时，吃的是狗粮，而调用猫时，则会选择吃猫食。

代码实操演示

class Animal{String name;int age;publicAnimal(String name,int age){this.name=name;this.age=age;}public void eat(){System.out.println("正在吃饭");}}class Cat extends Animal{public Cat(String name, int age) {super(name, age);//调用父类的构造方法}@Overridepublic void eat() {System.out.println(this.name+"正在吃猫食");;}}class Dog extends Animal{public Dog(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println(this.name+"正在吃狗粮");}}public class Test {public static void eat(Animal a){a.eat();//这里放的是父类具体引用的是谁看传的对象}public static void main(String[] args) {Cat cat=new Cat("宝宝",3);Dog dog=new Dog("旺财",3);eat(dog);//传的狗eat(cat);//传的猫，这里其实就是动态绑定}}

这里还是解释一下，我们通过子类方法对父类的重写，后面又在Test类里创建eat()这里传的是Animal类，由于Animal是Dog和Cat的父类，所以后面我们在调用eat(）时可以传Dog和Cat形，即小范围包含于大范围。这就是多态的含义。

类中方法的重写：

重写：又称覆盖，子类可以对父类中的非静态，非private，非final，非构造方法的其他方法进行重新定义，注意：重写的方法返回值不能改变，方法的参数不能改变，方法名也不能改变。即方法的外壳，不变只对里面进行重新编写。我们可以根据子类的需要对父类中的方法进行重新定义。通常重写的方法会有一个标签 @override，上面的程序里有提及。

这里可以对比记忆一下我们学过的重载：

注意：重写是对于子类和父类中研究的，即不同类之间，而重载是在一个类中实现了多个参数不同的同名的方法。

动态绑定：即不能立马确定方法的行为，编译时不能确定，等到运行时才能世道方法到底调用的是哪个方法的类。

父类当中的向下转移和向上转移

就是将子类引用给父类来使用，将小范围赋值给大范围，但本质上仍然为子类对象。

所以运行的结果为宝宝吃猫食。

当然你也可以使用Dog类来进行向下转型，因为Animal也包含Dog。

  1. 直接赋值
  2. 方法的返回值
  3. 方法的参数

直接赋值：

Animal animal=new Cat("宝宝",10);

当做返回值：

向上转型的优点：代码更加灵活。

向上转型的缺点：无法调用子类中的特有方法。

那如果我们就是要调用子类中的特有方法怎么办呢？这就需要使用向下转型了。

向下转型：

我们可以使用关键字instanceof来对向下转型的对象做一层检验，保障了代码的安全性。

if(animal instanceof Cat){ cat=(Cat)animal; cat.mew();

这里只有animal引用了Cat类的对象才执行if语句。

多态的优点

那么多态到底有什么优点呢，这里给大家总结一下，多态可以降低代码的圈复杂度，可以避免使用过多的if-else语句，其次，可拓展能力强需要新增一个类时，直接继承就好，需要注意构造方法么有多态性。

class B {public B() {// do nothingfunc();}public void func() {System.out.println("B.func()");}}class D extends B {private int num = 1;@Overridepublic void func() {System.out.println("D.func() " + num);}}public class Test {public static void main(String[] args) {D d = new D();}}// 执行结果D.func() 0

这里给大家一段有意思的代码，运行结果你猜对了吗，原因是new() D之后，第一步应该是调用父类的构造方法，即func()，但是构造方法在子类中被重写，所以调用的是子类中的func(),此时子类中的成员变量还没有赋值所以num仍然为0，所以运行结果为D.func() 0

抽象类即抽象方法的重写

其实，我们在最上面的代码中发现了一个问题，很多类由于不能将一个事物准确描述出来，针对不同的事物的行为不同，执行的方法也应该不同，比如Animal中的eat()并不能准确描述狗吃的狗粮，猫吃的猫粮，我们在狗类和猫类中还是要重写这个eat()方法，类似与Animal的这些类可以理解为抽象类。

抽象类，修饰限定符为public abstract,抽象类中的抽象方法(修饰符也是public abstract)类似与eat(),是不能有具体的定义的，原因很好理解，即使你写了，每个子类还得重写这个方法，我们只声明这个方法即可。注意：有抽象方法的类一定是抽象类，抽象类不一定含有抽象方法，抽象类也是类可以定义普通的成员变量，方法甚至是构造方法。(非常重要！！！！)

上代码理解一下：

//抽象类public Abstract Animal{public abstract void eat();//抽象方法 public abstract void look();//抽象方法}
  1. 抽象类也不能实例化对象，因为抽像类无法完整描述一个事物，他只能被子类继承，然后子类必须将抽象类当中的抽象方法进行重写，否则编译报错，
  2. 抽象方法不能是 private 的，因为子类还要重写抽象方法的。
  3. 抽象方法不能被final和static修饰，因为抽象方法要被子类重写。

接口的概念：

说到接口，我们第一想到的应该是USB接口插座…,这些当然都算接口，那么让我来说接口的特性的话，我觉得接口首先是一个封装好了的东西，并且它有着自己的功能，如果某个东西有了接口，那么他也应该具有接口的特性。

在java中接口是多个类的公共规范，是一种引用数据类型，接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。 

interface A{ public abstract void method1(); // public abstract 是固定搭配，可以不写public void method2();abstract void method3()}

接口不能直接使用，必须要有一个“实现类“来“实现“该接口，实现接口中的所有抽象方法。 这也比较好理解，毕竟接口只是实现 了某个特定的功能，并不能描述一个具体的对象。我们使用关键字implement将类和接口连接起来。

public class Animal implements IRunning{// ...}

这里给大家举一个电脑的例子：

// USB接口public interface USB {void openDevice();void closeDevice();}
// 鼠标类，实现USB接口public class Mouse implements USB {@Overridepublic void openDevice() {System.out.println("打开鼠标");}@Overridepublic void closeDevice() {System.out.println("关闭鼠标");}public void click(){System.out.println("鼠标点击");}}
// 键盘类，实现USB接口public class KeyBoard implements USB {@Overridepublic void openDevice() {System.out.println("打开键盘");}@Overridepublic void closeDevice() {System.out.println("关闭键盘");}public void inPut(){System.out.println("键盘输入");}}
// 笔记本类：使用USB设备public class Computer {public void powerOn(){System.out.println("打开笔记本电脑");}public void powerOff(){System.out.println("关闭笔记本电脑");}
public void useDevice(USB usb){usb.openDevice();if(usb instanceof Mouse){Mouse mouse = (Mouse)usb;mouse.click();}else if(usb instanceof KeyBoard){KeyBoard keyBoard = (KeyBoard)usb;keyBoard.inPut();}usb.closeDevice();}}
// 测试类：public class TestUSB {public static void main(String[] args) {Computer computer = new Computer();computer.powerOn();// 使用鼠标设备computer.useDevice(new Mouse());// 使用键盘设备computer.useDevice(new KeyBoard());computer.powerOff();}}

接口虽然是一种引用类型但是，他不能new(),必需通过引用类来重写接口中的所有方法，并且每个方法都默认为public abstract,也可以使用static和default修饰但是必须立即定义该方法，注意重写方法时一定要用public修饰。

public interface USB {void openDevice(); // 默认是public的void closeDevice(); // 默认是public的}public class Mouse implements USB {@Overridevoid openDevice() {System.out.println("打开鼠标");}// ...}// 编译报错，重写USB中openDevice方法时，不能使用默认修饰符// 正在尝试分配更低的访问权限; 以前为public

而且一个类是可以实现多个接口的，这也间接解决了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);}@Overridepublic void run() {System.out.println(this.name + "正在用四条腿跑");}}
class Fish extends Animal implements ISwimming {public Fish(String name) {super(name);}@Overridepublic void swim() {System.out.println(this.name + "正在用尾巴游泳");}}