面向对象三大特性---继承

问题导入(为什么要用继承)--->继承带给了我们什么--->继承的一些知识

假如现在我们要写2个类,一个老师Teacher类和一个学生Student类

其中,在Teacher类中,我们有name,age,wage三个属性;在Student类中,我们有name,age,grade三个属性,那么我们需要这样定义:

Student类:

class Student {
	private String name;
	private int age;
	private int grade;
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		if(age>0){
			this.age = age;
		}else{
			this.age=0;
		}
	}
	public int getAge() {
		return age;
	}
	public void setGrade(int grade) {
		this.grade = grade;
	}
	public int getGrade() {
		return grade;
	}
}

Teacher类:

class Teacher {
	private String name;
	private int age;
	private int wage;
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		if(age>0){
			this.age = age;
		}else{
			this.age=0;
		}
	}
	public int getAge() {
		return age;
	}
	public void setWage(int wage) {
		this.wage = wage;
	}
	public int getWage() {
		return wage;
	}
}

可以看到,在这两个类中,我们其实写了2次大量的重复代码,这只是2个类,如果还有校长类,警察类...他们中都有name和age属性以及相关方法,那么这样的 重复代码量就太大了!
为了解决这种重复代码的问题,继承就应运而生.继承的出现解决了这种相同代码反复定义的问题,可以将多个类中执行相同任务的代码抽调出来,组成一个类,其它需要此方法或属性的类都可以继承这个类,从而使用相关方法和属性,这个类成为父类,继承他的类称为子类,也成为派生类.

继承的格式为:

public class 子类 extends 父类{
	......
}

请注意:在Java中,只允许多层继承,不允许多重继承!

在使用继承时候,应当注意三点:

1、子类拥有父类非private的属性和方法。
2、子类可以拥有自己属性和方法，即子类可以对父类进行扩展。
3、子类可以用自己的方式实现父类的方法--->即覆写.

下面说下继承里面需要知道的几个方面

一丶子类对象的实例化过程

如果一个子类需要实例化,则它必须先调用父类的构造,然后才调用本类构造,即要"先有父亲,然后才能有孩子"

如:

class Person{
	private String name;
	private int age;
	
	public Person() {
		System.out.println("父类Person中的构造");
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public int getAge() {
		return age;
	}
}

class Teacher extends Person{
	public Teacher() {
		System.out.println("子类Teacher中的构造");
	}
	private int grade;
	public void setGrade(int grade) {
		this.grade = grade;
	}
	public int getGrade() {
		return grade;
	}
}

public class Test{
	public static void main(String []args){
		Teacher t = new Teacher();
	}
}

程序执行结果为:
父类Person中的构造
子类Teacher中的构造

其实,在上述的代码中,隐藏了一个方法:super(),在子类构造中,其实是这样的:

public Teacher() {
		super();
		System.out.println("子类Teacher中的构造");
	}

super()是默认隐藏的,它必须在子类构造的第一行,super()表示默认调用父类无参构造函数

二丶方法的覆写

指子类定义了与父类同名的方法,但是在方法覆写时必须考虑到权限,即被子类覆写的方法的权限不能比父类更严格!

即如果父类方法是protect,则子类必须是protect或者是public.

如果父类方法是public,则子类必须是public.

如果存在方法覆写,则子类中默认调用本类方法,若想调用父类方法,可以用super().方法来完成

三丶向上转型

即我们可以把Student当作是Person来操作,它是安全的,但是丢失了Student类中的属性和方法.

那么当我们使用继承的时候，我们需要确信使用继承确实是有效可行的办法。那么到底要不要使用继承呢？

《Think in java》中提供了解决办法：问一问自己是否需要从子类向父类进行向上转型。如果必须向上转型，则继承是必要的，但是如果不需要，则应当好好考虑自己是否需要继承。

最后提一点,继承要慎用.因为继承存在以下缺陷:

1.继承破坏了封装!

2.父类变,子类必须要变!