java继承---->类的复用

复用类

类的复用主要有以下的三种方式：组合、继承、代理

一、组合：

将现有类型作为新类型底层实现的一部分来复用。在新类中声明要复用的对象的引用。组合技术通常用于在新类中使用现有类的功能而非它的接口。”has-a”的关系

二、继承：

组合和继承都是在新的类中放置子对象，组合是显式的这样做，继承则是隐式的这样做。继承是使用现有类，为了某种特殊需要将其特殊化。“is-a”的关系.

三、代理：

继承和组合的中庸之道。将一个成员对象置于要构造的类中（就像组合），与此同时在新类中暴露了该类成员所有的方法（就像继承）。举例如下：

太空飞船控制模块

public class SpaceShipControls {

void up(int velocity) {}

void down(int velocity) {}

void left(int velocity) {}

void right(int velocity) {}

void forward(int velocity) {}

void back(int velocity) {}

void turboBoost() {}

}

如果使用继承，假如SpaceShip继承控制模块(如下)，但是SpaceShip并不是真正的SpaceShipControls的类型，显得不伦不类。即便它可以forward.

public class SpaceShip extends SpaceShipControls {

private String name;

public SpaceShip(String name) {

this.name = name;

}

public String toString() {

return name;

}

public static void main(String[] args) {

SpaceShip protector = new SpaceShip("NSEA Protector");

protector.forward(100);

}

}

太空船代理

public  class SpaceShipDelegation {

private String name;

private SpaceShipControls controls = new SpaceShipControls();

public SpaceShipDelegation(String name) {

this.name = name;

}

// Delegated methods:

public void back(int velocity) {

controls.back(velocity);

}

public void down(int velocity) {

controls.down(velocity);

}

public void forward(int velocity) {

controls.forward(velocity);

}

public void left(int velocity) {

controls.left(velocity);

}

public void right(int velocity) {

controls.right(velocity);

}

public void turboBoost() {

controls.turboBoost();

}

public void up(int velocity) {

controls.up(velocity);

}

public static void main(String[] args) {

SpaceShipDelegation protector = new SpaceShipDelegation("NSEA Protector");

protector.forward(100);

}

}

四、结合使用组合和代理

class Plate {

Plate(int i) {

System.out.println("Plateconstructor");

}

}

class DinnerPlate extends Plate {

DinnerPlate(int i) {

super(i);

System.out.println("DinnerPlateconstructor");

}

}

// 器具

class Utensil {

Utensil(int i) {

System.out.println("Utensilconstructor");

}

}

// 汤匙

class Spoon extends Utensil {

Spoon(int i) {

super(i);

System.out.println("Spoonconstructor");

}

}

class Fork extends Utensil {

Fork(int i) {

super(i);

System.out.println("Forkconstructor");

}

}

class Knife extends Utensil {

Knife(int i) {

super(i);

System.out.println("Knifeconstructor");

}

}

// A cultural way of doingsomething:

class Custom {

Custom(int i) {

System.out.println("Customconstructor");

}

}

publicclass PlaceSetting extends Custom {

private Spoon sp;

private Fork frk;

private Knife kn;

private DinnerPlate pl;

public PlaceSetting(int i) {

super(i + 1);

sp = new Spoon(i + 2);

frk = new Fork(i + 3);

kn = new Knife(i + 4);

pl = new DinnerPlate(i + 5);

System.out.println("PlaceSettingconstructor");

}

public static void main(String[] args) {

PlaceSetting x = new PlaceSetting(9);

}

} /*

* Output: Customconstructor Utensil constructor Spoon constructor Utensil

* constructor Forkconstructor Utensil constructor Knife constructor Plate

* constructor DinnerPlateconstructor PlaceSetting constructor

*/

五、在组合和继承之间选择

“is-a”的关系用继承，“has-a”的关系用组合。

class Vehicle {

}

class Engine {

public void start() {

}

public void rev() {

}

public void stop() {

}

}

class Wheel {

public void inflate(int psi) {

}

}

class Window {

public void rollup() {

}

public void rolldown() {

}

}

class Door{

public Window window = new Window();

public void open() {

}

public void close() {

}

}

public class Car extends Vehicle {

public Engine engine = new Engine();

public Wheel[] wheel = new Wheel[4];

public Doorleft = new Door(), right = new Door(); // 2-door

public Car() {

for (int i = 0; i < 4; i++)

wheel[i] = new Wheel();

}

public static void main(String[] args) {

Car car = new Car();

car.left.window.rollup();

car.wheel[0].inflate(72);

}

}