【java】组合 and 继承

继承是所有OOP语言和Java语言不可缺少的组成部分。

当创建一个类时，总是在继承，因此，除非已明确指出要从其他类中继承，否则就是在隐式的从Java的标准根类Object进行继承。

继承会自动得到基类中所有的域和方法。

private成员，只有父类才可以访问，但是可以理解为隐性的继承。

package source.saterday;
//子类Detergent隐形继承了父类Cleanser
class Cleanser {
	private String s = "Cleanser";
	public void append(String a) { s += a; }
	public void dilute() { append("  dilute()"); }
	public void apply() { append("  apply()"); }
	public void scrub() { append("  scrub()"); }
	public String toString() { return s; }
	public static void main(String[] args) {
		Cleanser x = new Cleanser();
		x.dilute();
		x.apply();
		x.scrub();
		System.out.println(x.toString());
	}
}
public class Detergent extends Cleanser{
	public void scrub() {
		append("  Detergent.scrub()");
		super.scrub();
	}
	public void foam() {
		append("  foam()");
	}
	public static void main(String[] args) {
		Detergent x = new Detergent();
		x.dilute();
		x.apply();
		x.scrub();
		x.foam();
		System.out.println(x.toString());
		System.out.println("Testing base class:");
		Cleanser.main(args);
	}
}

output：

初始化基类

当创建了一个导出类的对象时，该对象包含了一个基类的子对象。这个子对象与你用基类直接创建的对象是一样的。二者区别在于，后者来自于外部，而基类的子对象被包装在导出类对象内部。

package source.saterday;

class Art {
	Art() {
		System.out.println("Art Constructor!");
	}
}
class Drawing extends Art {
	Drawing() {
		System.out.println("Drawing Constructor!");
	}
}
public class Cartoon extends Drawing{
	Cartoon() {
		System.out.println("Cartoon Constructor!");
	}
	public static void main(String[] args) {
		Cartoon cartoon = new Cartoon();
	}
}

output：

带参数的构造器

必须要在子类中，添加初始化父类的方法，否则会报错。

package source.saterday;

class Game {
	Game( int i ){
		System.out.println("Game constructor!");
	}
}
class BoardGame extends Game {
	BoardGame(int i) {
		super(i);
		// TODO Auto-generated constructor stub
		System.out.println("BoardGame constructor!");
	}
}
public class Chess extends BoardGame{

	Chess() {
		super(11);
		// TODO Auto-generated constructor stub
		System.out.println("Chess constructor!");
	}
	public static void main(String[] args) {
		Chess x = new Chess();
	}
}

output：

附加：

名字不屏蔽

最好的方式：将域依旧保持private，将方法设置为protected

向上转型（导出类是基类的一个超集）

结合使用组合和继承

package source.saterday;
class Plate {
	Plate(int i) {	System.out.println("Plate Constructor!");}
}
class DinnerPlate extends Plate {
	DinnerPlate(int i) {
		super(i);
		// TODO Auto-generated constructor stub
		System.out.println("DinnerPlate Constructor!");
	}
}
class Utensil {
	Utensil(int i) { System.out.println("Utensil Constructor!"); }
}
class Spoon extends Utensil {

	Spoon(int i) {
		super(i);
		// TODO Auto-generated constructor stub
		System.out.println("Spoon Constructor!");
	}
}
class Fork extends Utensil {	
	Fork(int i) {
		super(i);
		// TODO Auto-generated constructor stub
		System.out.println("Fork Constructor!");
	}
}
class Knife extends Utensil {
	Knife(int i) {
		super(i);
		System.out.println("Knife Constructor!");
	}
}
class Custom {
	Custom(int i) {
		System.out.println("Custom Constructor!");
	}
}

public class PlaceSetting extends Custom{
	private Spoon sp;
	private Fork frk;
	private Knife kn;
	private DinnerPlate dp;
	public PlaceSetting(int i ){
		super( i + 1 );
		sp = new Spoon( i + 2 );
		frk = new Fork(i + 3);
		kn = new Knife(i + 4);
		dp = new DinnerPlate(i + 5);
		System.out.println("PlaceSetting Constructor!");
	}
	public static void main(String[] args) {
		PlaceSetting ps = new PlaceSetting(9);
	}
}

output：