组合
多态
一、什么是组合
和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果. 例如表示一个学校:
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) {
...
}
}
————————————————
