从头认识java-6.3 组合使用聚合和继承

这一章节我们来讨论一些组合使用聚合和继承

之前已经讲过想过的基础知识以及注意点，现在我们直接上代码：

1.例子

package com.ray.ch05;

public class PlaceSetting extends Custom {
	private DinnerPlate dinnerPlate;
	private Spoon spoon;
	private Fork fork;
	private Knife knife;

	public PlaceSetting(int i) {
		super(i);
		dinnerPlate = new DinnerPlate(i + 1);
		spoon = new Spoon(i + 1);
		fork = new Fork(i + 1);
		knife = new Knife(i + 1);
		System.out.println("done");
	}

	public static void main(String[] args) {
		new PlaceSetting(9);
	}
}

class Plate {
	public Plate(int i) {
		System.out.println("create Plate");
	}
}

class DinnerPlate extends Plate {
	public DinnerPlate(int i) {
		super(i);
		System.out.println("create DinnerPlate");
	}
}

class Utensil {
	public Utensil(int i) {
		System.out.println("create Utensil");
	}
}

class Spoon extends Utensil {
	public Spoon(int i) {
		super(i);
		System.out.println("create Spoon");
	}
}

class Fork extends Utensil {
	public Fork(int i) {
		super(i);
		System.out.println("create Fork");
	}
}

class Knife extends Utensil {
	public Knife(int i) {
		super(i);
		System.out.println("create Knife");
	}
}

class Custom {
	public Custom(int i) {
		System.out.println("create Custom");
	}
}

输出：

create Custom
create Plate
create DinnerPlate
create Utensil
create Spoon
create Utensil
create Fork
create Utensil
create Knife
done

上面就是一个同时使用聚合以及继承的典型的例子。

上面的例子体现了我们之前所说的有参数继承的初始化和聚合对象。

再次强调：编译器不会给对象初始化成new，只会初始化为null，因此这一点大家必须注意。

2.对象的清理以及清理顺序

沿用上一点的代码，然后我们分别在每个类里面加上一个dispose的方法，看看对象的清理以及清理的顺序。

代码：

package com.ray.ch05;

public class PlaceSetting extends Custom {
	private DinnerPlate dinnerPlate;
	private Spoon spoon;
	private Fork fork;
	private Knife knife;

	public PlaceSetting(int i) {
		super(i);
		dinnerPlate = new DinnerPlate(i + 1);
		spoon = new Spoon(i + 1);
		fork = new Fork(i + 1);
		knife = new Knife(i + 1);
		System.out.println("done");
	}

	@Override
	public void dispose() {
		dinnerPlate.dispose();
		spoon.dispose();
		fork.dispose();
		knife.dispose();
		System.out.println("PlaceSetting dispose");
		super.dispose();
	}

	public static void main(String[] args) {
		PlaceSetting placeSetting = null;
		try {
			placeSetting = new PlaceSetting(9);
		} catch (Exception e) {
		} finally {
			placeSetting.dispose();
		}
	}
}

class Plate {
	public Plate(int i) {
		System.out.println("create Plate");
	}

	public void dispose() {
		System.out.println("Plate dispose");
	}
}

class DinnerPlate extends Plate {
	public DinnerPlate(int i) {
		super(i);
		System.out.println("create DinnerPlate");
	}

	@Override
	public void dispose() {
		System.out.println("DinnerPlate dispose");
		super.dispose();
	}
}

class Utensil {
	public Utensil(int i) {
		System.out.println("create Utensil");
	}

	public void dispose() {
		System.out.println("Utensil dispose");
	}
}

class Spoon extends Utensil {
	public Spoon(int i) {
		super(i);
		System.out.println("create Spoon");
	}

	@Override
	public void dispose() {
		System.out.println("Spoon dispose");
		super.dispose();
	}
}

class Fork extends Utensil {
	public Fork(int i) {
		super(i);
		System.out.println("create Fork");
	}

	@Override
	public void dispose() {
		System.out.println("Fork dispose");
		super.dispose();
	}
}

class Knife extends Utensil {
	public Knife(int i) {
		super(i);
		System.out.println("create Knife");
	}

	@Override
	public void dispose() {
		System.out.println("Knife dispose");
		super.dispose();
	}
}

class Custom {
	public Custom(int i) {
		System.out.println("create Custom");
	}

	public void dispose() {
		System.out.println("Custom dispose");
	}
}

输出：

create Custom
create Plate
create DinnerPlate
create Utensil
create Spoon
create Utensil
create Fork
create Utensil
create Knife
done
DinnerPlate dispose
Plate dispose
Spoon dispose
Utensil dispose
Fork dispose
Utensil dispose
Knife dispose
Utensil dispose
PlaceSetting dispose
Custom dispose

从输出结果可以看见，生成对象依然是先父后子，但是清理确相反，先子后父。

当然，大部分的情况我们是不需要手动清理，只需要垃圾回收器自动清理即可。

但是有一点必须注意：当必须手动清理对象的时候，我们千万注意子类与子类、子类与父类等各种聚合和继承关系。

3.一个被多次重载的方法，在子类里面重载机制也是可以运行的。

package com.ray.ch05;

public class DinnerPlate extends Plate {
	public DinnerPlate(int i) {
		super(i);
		System.out.println("create DinnerPlate");
	}

	@Override
	public void dispose() {
	}

	public void dispose(double i) {
	}
}

class Plate {
	public Plate(int i) {
		System.out.println("create Plate");
	}

	public void dispose() {
		System.out.println("Plate dispose");
	}

	public int dispose(int i) {
		return i;
	}

	public float dispose(float i) {
		return i;
	}
}

从上面的代码可以看见，dispose被多次的重载，而且同时也通过不同的方式来重写。

总结：这一章节主要讲述了如何组合使用聚合和继承，以及描述在使用过程中会出现的一些问题。

这一章节就到这里，谢谢。

-----------------------------------

目录

版权声明：本文为博主原创文章，未经博主允许不得转载。