Java基础教程——继承

继承

一个类 可以 继承自 另一个类；

派生的类（子类）继承父类的方法和数据成员；

关键字：子类 extends 父类。

public class 继承 {
	public static void main(String[] args) {
		王思聪 a = new 王思聪();
		System.out.println(a.money);
		a.show();
	}
}
class 王健林 {
	double money = 188.88;
	void show() {
		System.out.println("不差钱");
	}
}
class 王思聪 extends 王健林 {
}

设计示例

继承主要解决的问题是：共性抽取。

继承的特点：
|--子类可以拥有父类的“内容”
|--子类可以拥有自己的“内容”

卡车和巴士都是汽车，它们共有的特征来自汽车，他们也可以有自己的特征：

public class 继承2 {
	public static void main(String[] args) {
	}
}
class 汽车 {
	private int wheels;
	public int getWheels() {
		return wheels;
	}
	public void setWheels(int wheels) {
		this.wheels = wheels;
	}
	// ------------------------
	public void 开车() {
		System.out.println("开车了");
	}
	public void 刹车() {
		System.out.println("刹车");
	}
}
class 卡车 extends 汽车 {
	private int carryingCapacity;
	public int getCarryingCapacity() {
		return carryingCapacity;
	}
	public void setCarryingCapacity(int carryingCapacity) {
		this.carryingCapacity = carryingCapacity;
	}
	// ------------------------
	public void 挂箱() {
		System.out.println("挂箱");
	}
}
class Bus extends 汽车 {
	private int seatings;
	public int getSeatings() {
		return seatings;
	}
	public void setSeatings(int seatings) {
		this.seatings = seatings;
	}
	// ------------------------
	public void 报站(String str站名) {
		System.out.println(str站名 + "已到");
	}
}

继承控制

protected：继承即可用，即使不在同一个包中

private：不给继承

this和super

this：自己的
super：父类的
|-|-super()：父类构造方法
|-|-super.XXX：父类的成员（方法或变量）

public class This_and_Super {
	public static void main(String[] args) {
		S _s = new S();
		_s.m();// 直接通过子类对象，调用的是子类的方法
		_s.newNethod();
	}
}
class F {
	protected int a = 1;
	protected void m() {
		System.out.println("F");
	}
}
class S extends F {
	protected int a = 99;
	protected void m() {
		System.out.println("S");
	}
	protected void newNethod() {
		System.out.println(super.a);
		System.out.println(this.a);
		System.out.println(a);// 直接调用，是自己的值
		// ---------
		super.m();
		this.m();
		m();// 直接调用，是自己的方法
	}
}

super()：再论构造方法

super必须有，不写也默认，必须第一句，只能有一个

​ (1)默认调父类的无参构造方法，直到显式调用父类的有参构造方法。

​ 详解：无论子类构造方法带不带参数，默认都是执行父类的无参构造方法。【隐藏一句代码:super()】
如果非要执行父类带参构造方法的话，使用super(参数列表)。

​ (2)super(父类构造方法)只能放在构造方法中，且必须放在第一句，因此也不能多次调用父类构造方法。

测试：

public class 构造顺序 {
	public static void main(String[] args) {
		new S();
		new S(1);
		new S(1L);
	}
}
class F {
	F() {
		System.out.println("父类构造方法");
	}
	F(int a) {
		System.out.println("父类构造方法(带参)");
	}
}
class S extends F {
	S() {
		System.out.println("子类构造方法\n");
	}
	S(int a) {
		System.out.println("子类构造方法(带参)\n");
	}
	S(long a) {
		super(1);
		System.out.println("子类构造方法2(带参)，显示调用父类的带参构造方法\n");
	}
}

父类构造方法
子类构造方法

父类构造方法
子类构造方法(带参)

父类构造方法(带参)
子类构造方法2(带参)，显示调用父类的带参构造方法

this()

this(...)也可以调用自己的其它构造方法，也必须放在第一句，一个构造方法中只能写一句。

class S2 extends F {
	S2() {
		this(100);
	}
	S2(int a) {
		this(100, 200);
	}
	S2(int a, int b) {
	}
}

思考题：总结super和this的用法

重写·Override

Override：方法重写、方法覆盖。
子类可以重新定义继承自父类的方法。子类方法中，可通过super来调用父类的方法。

• 两同：方法名相同，形参列表相同
• 两不大：返回类型不比父类大（大手大脚败家子），异常不比父类大（不得扩大范围）
• 一不小：访问权限不比父类小（不得废公为私）

public class 重写 {
	public static void main(String[] args) {
		Ostrich os = new Ostrich();
		os.twitter();
		os.fly();
	}
}
class Bird {
	public void twitter() {
		System.out.println("wakuwaku");
	}
	public void fly() {
		System.out.println("飞");
	}
}
// 鸵鸟类
class Ostrich extends Bird {
	@Override// 不写也是重写，写了会做检测，若方法在父类不存在将报错
	public void fly() {
		super.fly();
		System.out.println("?并不会");
	}
}

wakuwaku
飞
?并不会

返回类型不比父类大（注：Object是String的父类）

访问权限不比父类小（尧→舜→禹，启结束了禅让制度。）

class Bird {
	public Object twitter() {
		return null;
	}
	public String fly() {
		return null;
	}
}
// 鸵鸟类
class Ostrich extends Bird {
	public String twitter() {// 父类是Object，子类是String，没问题
		return null;
	}
	@Override// 父类返回类型String，改为Object
	public Object fly() {// The return type is incompatible with Bird.fly()
		return null;
	}
}
// 鸽子类
class Pigeon extends Bird {
	@Override
	private String fly() {// 父类是public，改为private
		// Cannot reduce the visibility of the inherited method from Bird
		return null;
	}
}

重写的应用场景：

对于已经存在的类，尽量不要进行代码修改，而是派生一个新的子类，对响应的方法进行重写。

final（不准修改）

Final修饰类：该类不可被继承（比如String类）
Final修饰方法：该方法不能被重写
Final修饰变量：不能被重新赋值

Java里的“常量”：

public static final int CHANG_LIANG = 10;

继承的坏处

继承是实现类复用的重要手段，但是继承会破坏封装。
每个类都应该封装其内部信息和实现细节，仅暴露必要的方法给其他类使用。但子类可以直接访问父类的内部信息，甚至可以重写父类的方法，这增加了子类和父类的耦合度，破坏了封装。

设计父类时，应遵循以下原则：

• 尽量将父类的成员变量设置为private。
• 尽量缩小方法的访问权限，能私有尽量不要共有。
• 不希望被子类重写的方法设置为final。
• 不要在父类的构造方法中调用被子类重写的方法。

​ 下例代码中，父类A的构造方法，该方法调用了被重写的method()方法，因为是先执行父类构造方法，而其调用的method()方法是被子类重写的，此时并没有变量s，因此s为null。

class A {
	public A() {
		System.out.println("A的构造方法");
		method();
		this.method();
	}
	public void method() {
		System.out.println("A method");
	}
}
class B extends A {
	public String s = "子类变量";
	public void method() {
		System.out.println("B method：" + s);
	}
}
public class TestInstanceOf {
	public static void main(String[] args) {
		B b = new B();
	}
}