目录

 继承和组合：

 区别和联系

1.安全性角度（封装性）

2.灵活性角度（牵一发动全身）

 多态：

一.怎样实现多态

1.完成向上转型

直接赋值：​​​​​​​

方法传参

方法的返回值

2.完成方法重写：

3.通过父类引用指向子类对象（重写的方法）

 动态绑定

父类引用指向子类对象：

二.什么是多态：

三.多态思想的运用（画图形）

四.多态的好处：

补充内容：

1.总结重写和重载区别：

2. 向下转型

• 不安全的：
• 引入instance of 

---

 前言
这些内容是对javase基础部分的复习

---

 继承和组合：

1.关系上说：
继承 is a
组合 has a
2.用法上说：
组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用组合。

>类似于造车，一个车可以由轮子，灯.....构成用组合写代码如下

组合的代码：

```java
//演示组合
class Tire{private int size;public void run(){System.out.println("轮胎转动");}}
class Light{public void bright(){System.out.println("灯亮");}}
public class Vehicle {private Tire tire;private Light light;public Vehicle(Tire tire,Light light){this.tire=tire;this.light=light;}public void operation(){tire.run();light.bright();}public static void main(String[] args) {Tire tire=new Tire();Light light=new Light();Vehicle vehicle=new Vehicle(tire,light);vehicle.operation();}}

 区别和联系

1.安全性角度（封装性）

组合是拼装在一起内部实现细节是不可见的，具有更好的封装性（黑盒）
在继承结构中，父类的内部细节对于子类是可见的。所以我们通常也可以说通过继承的代码复用是一种白盒式代码复用。（如果基类的实现发生改变，那么派生类的实现也将随之改变。这样就导致了子类行为的不可预知性；）

比如：类的方法被其他类用到，万一其他类重写了该方法，这个方法对后续会有影响（所有用到）

2.灵活性角度（牵一发动全身）

继承，在写代码的时候就要指名具体继承哪个类，所以，在编译期就确定了关系。（从基类继承来的实现是无法在运行期动态改变的，因此降低了应用的灵活性。）
比如：回调（每次继承一次，回调一遍其中的方法和属性）

组合，在写代码的时候可以采用面向接口编程。所以，类的组合关系一般在运行期确定

 多态

一.怎样实现多态

1.完成向上转型

注意三点

直接赋值：

直接把子类对象赋给父类

Animal animal=new Bird("鹦鹉",2);animal.eat()

此时父类引用只能访问自己的方法,要想访问子类特有方法的需要向下转型

方法传参

方法的返回值

2.完成方法重写：

注意6点

 animal.eat();

 调用的是子类的eat()

上述过程其实就是一次方法重写

满足方法重写的条件：
1.方法名相同，
2.参数列表相同【个数，类型，顺序】
3.返回值相同（或者子类的返回值和父类构成父子类关系（协变类型））

这是子类

这是父类：

public Animal eat() {System.out.println(name + "会干饭");return new Animal("动物",18);}

由于子类的返回值和父类构成父子类关系，运行结果还是子类的eat

4.static修饰方法不能被重写

5.private修饰方法不能被重写（private只能在当前类使用）

6.子类的访问修饰符，需要大于等于父类的访问修饰符

对父类方法重写

3.通过父类引用指向子类对象（重写的方法）

发生了动态的绑定

 动态绑定

又叫运行时绑定，子类和父类都有这个方法

编译的时候，还是调用父类自己的，但是在运行的时候，程序发生了动态绑定---子类自己的

这是编译时候的样子：

 运行时候，编译器悄悄将animal.eat方法地址改成0x56

父类引用指向子类对象：

//        Bird bird=new Bird("鹦鹉",2);
//        Animal animal=bird;

Animal animal=new Bird("鹦鹉",2);

animal.eat()

此时父类引用只能访问自己的方法,要想访问子类特有方法的需要向下转型

二.什么是多态：

public static void function(Animal animal) {animal.eat();//调用者不关心谁吃
}public static void main(String[] args) {function(new Bird("鹦鹉",2));function(new Dog("狗子",1));
}

父类引用引用了子类对象，通过父类引用，调用这个重写的方法，此时发生了动态绑定，此时父类引用就这一个，但是我引用的对象不一样，通过调用同一个方法，我们发现，此时所表现的形式是不一样的，把这样的现象叫做多态

三.多态思想的运用（画图形）

package 多态;
class Shape{public void draw(){System.out.println("画图形");}
}
class Rect extends Shape{@Overridepublic void draw() {System.out.println("长方形");}
}
class Cycle extends Shape{@Overridepublic void draw() {System.out.println("圆形");}
}
class Triangle extends Shape{@Overridepublic void draw() {System.out.println("△");}
}
public class Test2 {public static void drawMAP(Shape shape){shape.draw();}public static void main(String[] args) {Rect rect=new Rect();Cycle cycle=new Cycle();Triangle triangle=new Triangle();drawMAP(rect);drawMAP(cycle);drawMAP(triangle);}
}

假设现在要画的图形在shape数组中

    public static void main(String[] args) {Rect rect=new Rect();Cycle cycle=new Cycle();Triangle triangle=new Triangle();Shape[]shapes={rect,cycle,rect,cycle,rect,triangle};for (Shape shape:shapes) {//当前shape引用对象重写draw方法就调用,没有就调用自己的（已经向上转型和动态绑定了）shape.draw();}}

如果不使用多态

四.多态的好处：

1.降低了圈复杂度（减少条件循环语句出现的个数）

2.扩展能力强

补充内容：

总结重写和重载区别：

方法重载是静态绑定，在编译的时候，在编译时根据实参类型就知道具体的方法

方法重写是动态绑定，在运行的时候，确定调用哪个方法，

 重写就是重写再搭一个弓箭，重载是在原来基础上加功能，

 即：方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现

 向下转型

不安全的：

编译不报错： 

   //说明向下转型不安全public static void main(String[] args) {Animal animal = new Dog("狗子", 16);Bird bird = (Bird) animal;bird.fly();}public static void main1(String[] args) {Animal animal=new Bird("小鸟",2);Bird bird=(Bird)animal;//向下转型，父类类型给子类类型bird.fly();}

运行时,main显示：（狗子不是鸟）

 main1因为子类具有这个属性没事（鸟是动物）

修改代码：

引入instance of 

public static void main(String[] args) {Animal animal = new Dog("狗子", 16);if (animal instanceof Bird) {//不是所有动物都是鸟Bird bird = (Bird) animal;bird.fly();}}

狗子不是鸟，显然，没有输出，无法向下转型