Java继承与多态的理解

继承

---

概述

多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类即可
单独的这个类称为父类，基类或者叫超类，多个类可以称为子类或者派生类
有了继承以后，我们定义一个类的时候，可以在一个已经存在的类的基础上，还可以定义自己的新成员

实现方式

通过extends关键字可以实现类与类的继承

格式：
public class 子类名 extends 父类名{}

代码

public class Person {//学生和老师类都有name，age属性
	private String name;
	private int age;
	
	public Person() {}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}
	
}

public class Student extends Person {
	public void study() {
		System.out.println("学生要好好学习");
	}
}

public class Teacher extends Person {
	public void teach() {
		System.out.println("老师要好好讲课");
	}
}

继承的好处和弊端

---

继承的好处

• 提高了代码的复用性
  多个类相同的成员可以放到同一个类中
• 提高了代码得到维护性
  如果功能的代码需要修改，修改一处即可
• 让类与类之间产生了关系，是多态的前提

继承的弊端

由于类与类之间产生了关系，让类的耦合性增强了，而程序设计的原则是：高内聚低耦合。

继承的特点

Java中单继承以及多级继承

1. Java中只支持单继承，不支持多继承
2. Java中类支持多层继承

继承中成员变量的特点

1.成员变量名称不同，那就正常使用了

2.父类与子类成员变量一样：

在子类中访问变量：（就近原则）

• 在方法的局部范围找，如果有就使用
• 在子类的成员范围找，如果有就使用
• 在父类的成员范围找，如果有就使用
• 如果还找不到 就报错

继承中成员方法的特点

同样的就近原则：先在子类中找，再去父类中找

继承中构造方法的特点

1.由于子类会继承父类中的数据，还可能会使用父类中的数据，所以在子类初始化之前，一定要先完成对父的初始化。子类中每一个构造方法的第一条默认语句都是super。

2.子类中的所有构造方法默认都会访问父类中无参数的构造方法。

3.那如果父类中没有构造函数怎么办？

• 他没有那就给他加一个呗
• 通过使用super关键字去访问父类的带参构造方法
• 在平常使用中建议直接每次都自己建一个无参构造方法

super关键字

1.概述
super代表父类存储空间的标识（可以理解为父类对象引用），可以用此去访问父类的属性，方法，构造，但是私有属性和方法不能被访问，用法与this相似

2.使用格式
使用父类成员变量

super.成员变量名；

使用父类的方法

super.成员方法名()；

使用父类的构造方法

super(…)；

3.好处
当子类与父类的成员重名时，由于访问成员时会遵循就近原则，要想使用父类的成员，那么就是我们使用super的时候了，区分子类与父类的成员

4.代码

public class Father {//父类
	public int age = 45;
}

public class Son extends Father {//子类
	public int age = 20;
	
	public void printAge() {
		int age = 10;
		//根据继承中成员变量的访问方法--就近原则，会先访问局部变量
		System.out.println(age);
		//我要访问成员范围的age?
		System.out.println(this.age);
		//我要访问父类成员范围的age?
		System.out.println(super.age);
	}
}

public class ExtendsTest {//测试
	public static void main(String[] args) {
		Son s = new Son();
		s.printAge();
	}
}

方法重写

---

概述

子类中出现了和父类中一摸一样的方法声明

使用

当子类需要父类的功能，而功能主体子类有自己特有的内容时，可以重写父中的方法，这样重写父类中的方法，既沿袭了父类的功能，又定义了子类特有的内容

注意事项

• 注解

@Override
表明该方法的重写父类的方法

• 方法重写的注意事项

-	父类中私有方法不能被重写
-	子类重写父类方法时，访问权限不能更低（父类的私有方法，可理解为被子类继承，但是不被子类可见，不可访问）
-	子类重写父类方法时，建议访问权限一摸一样
-	父类的成员方法只能被它的子类重写。
-	声明为 final 的方法不能被重写。
-	声明为 static 的方法不能被重写，但是能够被再次声明。
-	构造方法不能被重写。
-	如果一个方法不能被继承，那么它一定不能被重写

代码

public class Phone {	
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}
/*
 * 方法重写：子类中出现了和父类中一模一样的方法声明的情况
 * 方法重写的应用：
 * 当子类需要父类的功能，而功能主体子类又有自己的特有内容的时候，就考虑使用方法重写，
 * 这样即保证了父类的功能，还添加了子类的特有内容。
 */
public class NewPhone extends Phone {	
	public void call(String name) {
		System.out.println("打开微信");
		//System.out.println("给"+name+"打视频电话");
		super.call(name);
	}
}

public class PhoneTest {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.call("刘诗诗");
		System.out.println("-----------");
		NewPhone np = new NewPhone();
		np.call("刘诗诗");
	}
}

多态

---

概述

多态是同一个行为具有多个不同表现形式或形态的能力（多个子类对同一方法的重写可以表现出不同的行为），父类的引用指向哪个子类的实例，就调用哪个类中的重写方法。

类型

• 静态多态（编译时多态）：程序在编译时就知道调用哪个方法，表现为方法重载
• 动态多态（运行时多态）：程序在运行时才知道调用哪个方法，表现为方法重写

产生动态多态的条件：

a.有继承
b.有方法重写
c.父类的引用指向子类的实例（向上转型）

本质

多态的本质就是将子类对象赋值给父类变量,在运行时期会表现出具体的子类特征(调用子类的重写方法）

成员访问特点

• 成员变量访问特点
  编译看左边(基类)，运行看左边（基类）

• 成员方法访问特点
  编译看左边（基类），运行在右边（派生类）

动态的好处

• 应用程序不必为每一个派生类编写调用功能，只需对抽象类进行处理即可。大大提高程序的可复用性，这是由于继承。

• 派生类的功能可以被基类的方法或引用变量所调用，这叫向后兼容，可以提高扩容性和可维护性。

• 具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。

多态的弊端：不能使用子类的特有功能

代码

public class DuoTaiDemo {
	public static void main(String[] args) {
		//多态
		Animal a = new Cat(); //向上转型
		a.eat();
		System.out.println(a.age);	
	}
}

public class Cat extends Animal {
	public int age = 20;
	@Override
	public void eat() {
		System.out.println("猫吃鱼");
	}
	
	public void play() {
		System.out.println("猫玩皮球");
	}
}

public class Animal {
	public int age = 18;
	public void eat() {
		System.out.println("吃东西");
	}
}

结果

猫吃鱼
18