继承和多态

面向对象的编程语言的特性：继承、封装、多态。

包：（文件夹）

包是组织类的一种方式；
使用包的目的是保证类的唯一性。
包的命名是小写字母，且公司网站采用倒序。
用谁导入谁，当需要两个不同的包中的类时，需要确定那个地方用哪个，此时需要写全名来区分；
静态导入：

import static java.long.System.*;`

包的访问权限：

默认只能访问包当中的内容。default
如果某个成员不包含 public 和 private 关键字, 此时这个成员可以在包内部的其他类使用, 但是不能在包外部的类使用。
protected 关键字：在继承中使用，protected修饰的成员和方法是受保护的，只有本类和继承了该类的子类才可以使用。

继承：（is a的关系）

**目的：为了代码的复用； extends，super（）；**
使用extends关键字实现继承：

子类\派生类    extends  父类\基类\超类

子类继承父类，继承了除构造方法外的所有东西。
子类帮助父类进行构造：

super（父类的public的数据成员）：调用父类的构造方法，必须放在第一行
super.父类的构造方法；

如果要构造子类，必须要先构造父类。
Java只允许单继承 ，也就是说一个子类只能继承自一个父类。
父类\基类只能访问自己的成员或者方法。
被final修饰的类称为密封类，不能被继承

final  class  类名{  
}
所有被final修饰的都不能随意被改动。

继承中代码块执行顺序：父类的静态—>子类的静态—>父类的实例—>父类的构造方法—>子类的实例—>子类的构造方法；（静态代码块只执行一次）

组合：（has a / a part of的关系）一部分

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

多态：运行时绑定（运行时多态）

构造方法内也可以发生运行时绑定（动态绑定）：因为在调用子类的构造方法时会先去调用父类的构造方法，但是由于子类已经将父类的构造方法进行了重写，所以直接调用子类的构造方法，这个过程也称为动态绑定。
在编写程序时尽量不要再编译器中进行动态绑定。

发生多态的条件：
1、继承-》父类需要引用子类对象（向上转型）；
2、通过父类的引用去调用子类和父类同名的覆盖方法。

向上转型：父类引用子类的对象，父类只能调用父类自己的方法或者成员属性

	Bird bird = new Bird("圆圆");
	Animal bird2 = bird;   //向上转型  直接赋值
	// 或者写成下面的方式
	Animal bird2 = new Bird("圆圆");
此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为 向上转型

向上转型的三种方法：直接赋值、方法传参、方法返回。
方法传参：

public class Test {
	public static void main(String[] args) {
		Bird bird = new Bird("圆圆");
		feed(bird);
	}
	public static void feed(Animal animal) {
		animal.eat("谷子");
	}
}

方法返回：

public class Test {
	public static void main(String[] args) {
		Animal animal = findMyAnimal();
	}
	public static Animal findMyAnimal() {
		Bird bird = new Bird("圆圆");
		return bird;
	}
}

在发生运行时多态时比较容易发生方法重写。

方法重写（覆盖）：方法名相同，参数列表相同，返回值相同。Override

重写注意事项：

1. 方法不能是private私有的
2. 子类方法的权限一点要大于父类方法的权限
   方法权限：public > protected > default > private
3. 不能是一个静态的方法

方法重载：方法名相同，参数列表不同，返回值不做要求。Overload

重写和重载的区别：

this和super的区别：
this代表当前对象的引用；
super代表获取到父类实例的引用。

向下转型：把父类的对象进行强转赋给子类。必须先进行向上转型

Animal animal = new Bird("圆圆");
animal.eat("谷子");
// 执行结果
圆圆正在吃谷子
// (Bird) 表示强制类型转换
Bird bird = (Bird)animal; //向下转型
bird.fly(); 
// 执行结果
圆圆正在飞

Animal animal = new Cat("小猫");
if (animal instanceof Bird) {  // 相当于A  of  B：B 的 A//
	Bird bird = (Bird)animal;
	bird.fly();
}

使用多态的好处:

1. 类调用者对类的使用成本进一步降低.
   封装是让类的调用者不需要知道类的实现细节.
   多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这 个对象具有某个方法即可.
2. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
3. 可扩展能力更强.
   如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低