Java基础 -- 复用类(组合和继承)

复用类有两种实现方式。

• 在新的类中产生现有类的对象，由于新的类是由现有类的对象所组成，所以这种方法称之为组合。
• 采用继承实现。

一  组合语法

下面创建两个类WaterSource和SprinklerSystem。其中SprinklerSystem中包含WaterSource的对象引用。

class WaterSource {
    //如果定义时没有初始化，则基本类型会被自动初始化为0，对象引用初始化为Null
    private String s;
    WaterSource(){
        System.out.println("WaterSource()");
        s = "Constructed";
    }
}

public class SprinklerSystem {
    private String value1,value2,value3,value4;
    //定义时初始化
    private WaterSource source = new WaterSource();
    private int i;
    private float f;
    public String toString() {
        return
                "value1 = " + value1 + " " +
                "value2 = " + value2 + " " +
                "value3 = " + value3 + " " +
                "value4 = " + value4 + "\n" +
                "i = " + i + "  " + "f = " + f + " " +
                "source = " + source;
    }

    public static void main(String[] args) {
        SprinklerSystem sprinklers = new SprinklerSystem();
        System.out.println(sprinklers);
    }
}

运行结果如下：

WaterSource()
value1 = null value2 = null value3 = null value4 = null
i = 0  f = 0.0 source = WaterSource@15db9742

注意：如果把一个对象以String类型输出，则默认调用的是该对象的toString()方法。

类中成员变量如果是基本基本类型则默认被初始化为零，如果是对象引用则会被初始化为null。

我们也可以自己去初始化他们：

• 在定义成员变量的时候初始化，比如private String s1 = "happy"；这意味着他们能够在构造函数被调用之前初始化。
• 在类的构造函数中初始化；
• 在使用这些成员变量之前初始化，这种方式称之为惰性初始化；
• 使用实例初始化{s1 = "happy";}。

二 继承语法

Java创建一个类时，默认都是继承于Object，除非自己指定从哪个类继承。

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);
	}

}

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);
		System.out.println("Testing base class:");

		Cleanser.main(args);
	}

}

运行结果如下：

Cleanser  dilute()  apply() Detergent.scrub()  scrub() foam()
Testing base class:
Cleanser  dilute()  apply()  scrub()

看以看到继承使用的是关键字extends，如果在子类中想调用父类方法，可以使用super.*。

1、初始化父类

在创建一个子类对象时，父类构造器总会在子类构造器之前被调用。

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 x = new Cartoon();
	}
}

运行输出如下：

Art constructor
Drawing constructor
Cartoon constructor

所以很容易发现，子类对象的构建过程是从父类"向外"扩散的，所以父类在子类构造器可以访问它之前，就已经完成了初始化。

上面的父类构造函数是没有参数的，如果父类只有一个带有参数的构造器，就必须在子类构造器中用关键字super显式的编写调用父类构造器的语句，否则编译器将无法找到符合'类名()'形式的构造器。

2、重载

重载是指不同的函数使用相同的函数名，但是函数的参数个数和类型不同。调用的时候根据函数的参数来区别不同的函数。在Java中，子类可以重载父类的方法。

//重载显示
class Homer{
	char doh(char c) {
		System.out.println("doh(char)");
		return 'd';
	}

	float doh(float f) {
		System.out.println("doh(float)");
		return 1.0f;
	}
}

class Milhouse{}

class Bart extends Homer{
	void doh(Milhouse m) {
		System.out.println("doh(Milhouse)");
	}
}

public class Overload {
	public static void main(String[] args) {
		Bart b = new Bart();
		b.doh(1);
		b.doh('x');
		b.doh(1.0f);
		b.doh(new Milhouse());
	}

}

运行结果如下：

doh(float)
doh(char)
doh(float)
doh(Milhouse)

3、protected

在实际的项目中，经常会想要将某些事物尽可能对整个世界隐藏起来，但仍然允许子类的成员访问它们。关键字protected就起这个作用，它指明"就用户而言，这是private的，但对于任何继承于此类的子类，它是可以访问的“。

//Protected关键字的使用
class Villain{
	private String name;
	protected  void set(String nm) {name = nm;}
	public Villain(String name) {this.name = name;}
	public String toString() {
		return "I'm a Villain and my name is " + name;
	}
}

public class Orc  extends Villain{
	private int orcNumber;
	public Orc(String name,int orcNumber) {
		super(name);
		this.orcNumber = orcNumber;
	}

	public void change(String name,int orcNumber) {
		set(name);
		this.orcNumber = orcNumber;
	}

	public String toString() {
		return "Orc " + orcNumber + ": " + super.toString();
	}

	public static void main(String[] args) {
		Orc orc = new Orc("Z3",12);
		System.out.println(orc);
		orc.change("l4", 23);
		System.out.println(orc);
	}
}

运行结果如下：

Orc 12: I'm a Villain and my name is Z3
Orc 23: I'm a Villain and my name is l4

可以发现子类change()方法可以访问父类的set()，这是因为set()的访问修饰符是protected。

 参考文献：

[1]Java编程思想