本节目标

组合

多态

一、什么是组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果. 例如表示一个学校:

public class Student { 
 ... 
} 
public class Teacher { 
 ... 
} 
public class School { 
 public Student[] students; 
 public Teacher[] teachers; 
} 

组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段. 这是我们设计类的一种常用方式之一

组合表示 has - a 语义

在刚才的例子中, 我们可以理解成一个学校中 "包含" 若干学生和教师

继承表示 is - a 语义

在上面的 "动物和狗" 的例子中, 我们可以理解成一只狗也 "是" 一种动物.

二、什么是多态

多态：字面理解：一种事物多种形态（这句话万万不可和面试官说） 

向上转型： 

向上转型：一句话，父类引用，引用子类对象

class Animal{
    public String name;
    public int age;

    public void eat(){
        System.out.println("eat()");
    }

    public Animal(String name,int age){
        this.name = name;
        this.age = age;
    }
}
class Dag extends Animal {
    public Dag(String name,int age){
        super(name,age);
    }


}
class Bird extends Animal{

    public String wing;

    public void fly(){
        System.out.println(age+"fly");

    }

    public Bird(String name,int age,String wing){
        super(name,age);
        this.wing = wing;
    }

}
public class TestDemo{
    public static void main(String[] args) {
        //Dag dag = new Dag("HAHAH",12);
        //Animal animal = dag;
        Animal animal1 = new Dag("HAHAH",12);
    }

什么情况下会发什么向上转型：

1、直接赋值

2、方法传参

3、方法返回

直接赋值的方式我们已经演示了. 另外两种方式和直接赋值没有本质区别

方法传参：

 此时形参 animal 的类型是 Animal (基类), 实际上对应到 Dag (父类) 的实例

 方法返回：

动态绑定：

动态绑定：

两个前提：

1、父类引用，引用子类的对象

2、通过这个父类引用，调用父类和子类同名的覆盖方法

同名的覆盖方法，术语：重写

重写：

1：方法名相同

2：参数列表校相同（个数+类型）

3：返回值相同

重写必须在父子类的情况下

动态绑定是多态的基础

// Animal.java 
public class Animal { 
 protected String name; 
 public Animal(String name) { 
 this.name = name; 
 } 
 public void eat(String food) { 
 System.out.println("我是一只小动物"); 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Bird.java 
public class Bird extends Animal { 
 public Bird(String name) { 
 super(name); 
 } 
 public void eat(String food) { 
 System.out.println("我是一只小鸟"); 
 System.out.println(this.name + "正在吃" + food); 
 } 
} 
// Test.java 
public class Test { 
 public static void main(String[] args) { 
 Animal animal1 = new Animal("圆圆"); 
 animal1.eat("谷子"); 
 Animal animal2 = new Bird("扁扁"); 
 animal2.eat("谷子"); 
 } 
} 
// 执行结果
我是一只小动物
圆圆正在吃谷子
我是一只小鸟
扁扁正在吃谷子

此时, 我们发现:

animal1 和 animal2 虽然都是 Animal 类型的引用, 但是 animal1 指向 Animal 类型的实例, animal2 指向 Bird 类型的实例.

针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而 animal2.eat() 实际调用了子类的方法

因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引 用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为 动态绑定

注意事项：

1、方法不可以是static的

2、子类的访问修饰限定符，要大于等于父类的访问修饰限定符

3、private方法，不能重写

4、被final修饰的方法，不能被重写

另外, 针对重写的方法, 可以使用 @Override 注解来显式指定

// Bird.java 
public class Bird extends Animal { 
 @Override 
 private void eat(String food) { 
 ... 
 } 
} 

有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发 现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写. 我们推荐在代码中进行重写方法时显式加上 @Override 注解

总结：

我们先简单的了解一下多态的概念，后续多态的有关知识我们会通过代码的方式，加深对多态的理解和认识，让大家能跟完完全全的掌握多态的语法知识。