一.继承

1.1我们为什么需要继承?

首先，Java中使用类对现实世界中实体来进行描述，类经过实例化之后的产物对象，则可以用来表示现实中的实体，但是 现实世界错综复杂，事物之间可能会存在一些关联，那在设计程序是就需要考虑。

例如猫和狗：

<code>public class Dog {

String name;

int age;

float weight;

public void eat(){

System.out.println(name+"正在吃饭！");

}

public void sleep(){

System.out.println(name+"正在睡觉！");

}

public void bark(){

System.out.println(name+"正在汪汪汪！");

}

}

public class Cat {

String name;

int age;

float weight;

public void eat(){

System.out.println(name+"正在吃饭！");

}

public void sleep(){

System.out.println(name+"正在睡觉！");

}

public void bark(){

System.out.println(name+"正在喵喵喵！");

}

}

我们可以看到上面的代码我们可以知道，猫和狗他们有一些共性代码例如eat和sleep,这时我们就可以想到它们都是动物我们是否有什么方法可以将使用一个类方法它们放在一起。确实我们这就就可以用到我们的继承方法，因为它们都是动物这时我们就可以定义一个Animal作为父类用于存放相同共性的代码，之后我们Dog和Cat就只需要继承Animal这时就达到了简便，从而实现代码的复用。

1.2继承的概念

继承(inheritance)机制：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了 由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

继承关系如图所示：

 这里我们可以看出继承其实就是父类和子类的关系，当我们父类中有的代码时子类可以继承，子类只需要关心自已特有的特性。

继承的意义：实现代码的复用。

 1.3继承的语法

在Java中类之间的继承需要我们用到extends关键字。

例如：上面的猫和狗我们就可以用继承关系进行eat和sleep方法的复用。

<code>public class Animal {

String name;

int age;

public void eat(){

System.out.println(name+"正在吃饭！");

}

public void sleep() {

System.out.println(name + "正在睡觉！");

}

}

public class Cat extends Animal{

public void bark(){

System.out.println(name+"正在汪汪汪！");

}

}

public class Dog extends Animal {

public void bark(){

System.out.println(name+"正在喵喵喵！！");

}

}

public class Test {

public static void main(String[] args) {

Dog dog=new Dog();

dog.name="旺财";code>

dog.age=10;

dog.sleep();

dog.eat();

dog.bark();

}

}

例如上面这一段代码，我们可以看到在测试方法里面我们可以直接通过dog.的形式来调用name,age,sleep,eat方法，但是我们的dog类方法中并没有这这些方法，这是它就是继承了父类Animal中的方法。

注意事项： 

1. 子类会将父类中的成员变量或者成员方法继承到子类中了

2. 子类继承父类之后，必须要新添加自己特有的成员，体现出与基类的不同，否则就没有必要继承了

<code>public class Animal {

static{

System.out.println("static::Animal().......");

}

private final String name;

private final int age;

{

System.out.println("实例代码块Animal().....");

}

public Animal(String name,int age){

this.name=name;

this.age=age;

System.out.println("Animal().......");

}

}

public class Dog extends Animal{

static{

System.out.println("static::Dog()....");

}

{

System.out.println("实例代码块Dog().......");

}

public Dog(String name, int age) {

super(name, age);

System.out.println("Dog().......");

}

}

以上是父类和子类的静态，实例，构造代码，那么我们接下来就可以通过运行结果来获得它们的执行顺序是怎样的？

通过上图我们可以看出代码执行顺序：

 从而我们可以得到以下结论：

注意：第二次实例化子类对象时子类和父类的静态方法将不再执行

 1.7protect关键字

我们在前面学习了类和对象中我们可以知道在实现封装的时候，Java中引入了限定修饰符，主要限定：类或者类中成员能否在类外或者其他包中被访问。

protect的定义如下：

那么在不同包中的子类使用具体是如何的呢？我们用下面的具体实例来说明

上面这一段代码就很好的说明了protect在不同包中子类的使用。 

1.8继承方式 

Java中继承的方式多种多样下面我们来举出几个具体的例子：

在Java中我们一般采用前三种继承方式，多继承一般不会被使用。我们又是想要限制继承，这时我们就要用到关键字final。

1.9final关键字

1.修饰变量

被final修饰的变量不能被修改。

2.修饰类

此类将无法被继承。 

3.修饰方法

此方法不能被重写。

1.10继承和组合

和继承相似组合也是一种表达类之间的关系，也可以起到代码复用的效果，给我们带来简便，但在组合中并没用想继承中的extend之类的关键词，仅仅时将一个类的实例作为另一个类的字段。

继承表示对象是is-a的关系，例如： 狗是动物，猫是动物

组合表示对象时has-a的关系，例如：汽车

<code>// 轮胎类

class Tire{

// ...

}

// 发动机类

class Engine{

// ...

}

// 车载系统类

class VehicleSystem{

// ...

}

class Car{

private Tire tire; // 可以复用轮胎中的属性和方法

private Engine engine; // 可以复用发动机中的属性和方法

private VehicleSystem vs; // 可以复用车载系统中的属性和方法

// ...

}

// 奔驰是汽车

class Benz extend Car{

// 将汽车中包含的：轮胎、发送机、车载系统全部继承下来

}

组合和继承都可以实现代码复用，应该使用继承还是组合，需要根据应用场景来选择，一般建议：能用组合尽量用 组合。

二.多态

2.1多态的概念

多态的概念简单的来说就是当不同的对象去完成相同的事的时候会产生不同的状态。

例如：

从上面两个例子我们可以看出：同一件事情发生在不同的对象身上就会产生不同的结果。 

2.2多态的实现条件

首先在Java中多态实现的必要条件：

1. 必须在继承体系下

2. 子类必须要对父类中方法进行重写

3. 通过父类的引用调用重写的方法

<code>public class Animal {

String name;

int age;

public Animal(String name,int age){

this.name=name;

this.age=age;

}

public void eat(){

System.out.println(name+"正在吃饭");

}

}

public class Dog extends Animal{

public Dog(String name, int age) {

super(name, age);

}

@Override

public void eat() {

super.eat();

System.out.println(name+"吃骨头");

}

}

public class Cat extends Animal{

public Cat(String name, int age) {

super(name, age);

}

@Override

public void eat() {

super.eat();

System.out.println(name+"正在吃鱼");

}

}

public class TestAnimal {

public void eat(Animal a){

a.eat();

}

public static void main(String[] args) {

Dog dog=new Dog("旺财",1);

Cat cat=new Cat("元宝",2);

dog.eat();

cat.eat();

}

}

当不同的对象进行相同的行为会产生 不同的结果这就是多态。

2.3重写

重写：就是覆盖，重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程 进行重新编写，返回值和形参都不能改变。即外壳不变，核心重写。

注意： 1.被重写的方法返回值类型可以不同，但是必须是具有父子关系的。

            2.访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类方法被public修饰，则子类中重写该方 法就不能声明为 protected

            3.父类被static、private修饰的方法、构造方法都不能被重写。

            4.重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心 将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法 构成重写.

重写和重载的区别：

 2.4静态绑定和动态绑定

静态绑定：也称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代 表函数重载。

动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体 调用那个类的方法。

动态绑定具体如下：

2.5向上转型和向下转型

2.5.1向上转型：

向上转型顾名思义在我们的继承中就是由子类向父类进行向上转型。也就是创造一个子类对象把它当作父类对象来使用。

语法格式：

使用场景具体的有三种：

1.直接赋值

2.方法传参

3.方法返回

向上转型的优点：让代码实现更简单灵活。

向上转型的缺陷：不能调用到子类特有的方法。

 2.5.2向下转型

将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的 方法，此时：将父类引用再还原为子类对象即可，即向下转换。

但我们需要注意的是向下转型存在安全隐患

<code>public static void main(String[] args) {

Cat cat=new Cat("元宝",10);

Dog dog=new Dog("旺财",20);

//向上转型

Animal animal=cat;

animal.eat();

animal=dog;

animal.eat();

//向下转型

cat=(Cat)animal;//此时animal指向的是dog但这里向下转型为cat运行时会抛出异常

cat.mew();

dog=(Dog)animal;

dog.bark();//这里animal指向的就是dog故这里不会报错

}

向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入 了 instanceof ，如果该表达式为true，则可以安全转换。

public class TestAnimal {

public static void main(String[] args) {

Cat cat = new Cat("元宝",2);

Dog dog = new Dog("小七", 1);

// 向上转型

Animal animal = cat;

animal.eat();

animal = dog;

animal.eat();

if(animal instanceof Cat){

cat = (Cat)animal;

cat.mew();

}

if(animal instanceof Dog){

dog = (Dog)animal;

dog.bark();

}

}

}

2.6多态的优缺点

使用多态能够大大降低代码的“圈复杂度”，避免大量使用if-else.

圈复杂度:圈复杂度是一种描述一段代码复杂程度的方式. 一段代码如果平铺直叙, 那么就比较简单容易理解. 而如 果有很多的条件分支或者循环语句, 就认为理解起来更复杂.

例如：

public class Shape {

public void draw(){

System.out.println("画图形！");

}

}

public class Cycle extends Shape{

@Override

public void draw() {

super.draw();

System.out.println("●");

}

}

public class Rect extends Shape{

@Override

public void draw() {

super.draw();

System.out.println("♦");

}

}

public class Flower extends Shape{

@Override

public void draw() {

super.draw();

System.out.println("❀");

}

}

public class TestShape {

public static void main(String[] args) {

Rect rect = new Rect();

Cycle cycle = new Cycle();

Flower flower = new Flower();

String[] shapes = {"cycle", "rect", "cycle", "rect", "flower"};

for (String shape : shapes) {

if (shape.equals("cycle")) {

cycle.draw();

} else if (shape.equals("rect")) {

rect.draw();

} else if (shape.equals("flower")) {

flower.draw();

}

}

}

}

这里我们没有使用多态我们就会使用大量的if-else循环语句这时代码就比较繁琐，那当我们使用多态会是什么效果呢？

public class Shape {

public void draw(){

System.out.println("画图形！");

}

}

public class Cycle extends Shape{

@Override

public void draw() {

super.draw();

System.out.println("●");

}

}

public class Rect extends Shape{

@Override

public void draw() {

super.draw();

System.out.println("♦");

}

}

public class Flower extends Shape{

@Override

public void draw() {

super.draw();

System.out.println("❀");

}

}

public class TestShape {

public static void main(String[] args) {

Shape[] shapes = {new Cycle(), new Rect(), new Cycle(),

new Rect(), new Flower()};

for (Shape shape : shapes) {

shape.draw();

}

}

}

这里我们不难看出当我们使用了多态以后，代码就会变得简单易懂，这就是多态的好处。

2.使用多态可扩展性强

简而言之就是当我们要增加一种新的形状的时候，改动代码的成本比较低，例如：

class Triangle extends Shape {

@Override

public void draw() {

System.out.println("△");

我们只需要在上面代码的基础上新增加一个类就可以了，不需要去改动其他地方。

但是多态除了它的优点也有缺点

1. 属性没有多态性 当父类和子类都有同名属性的时候，通过父类引用，只能引用父类自己的成员属性

2. 构造方法没有多态性

好了以上就是关于继承和多态的全部内容，我们下期见！