Java中类与类的关系

在java中类和类的关系大致分三种：泛化、关联、依赖。

1. 泛化(Generalization)

"XX是一个XX"关系（is a）,通常使用的关键词为 extends、implements

继承:继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

继承的特点：

1.继承关系是传递的。若类C继承类B，类B继承类A（多层继承），则类C既有从类B那里继承下来的属性与方法，也有从类A那里继承下来的属性与方法，还可以有自己新定义的属性和方法。继承来的属性和方法尽管是隐式的，但仍是类C的属性和方法。继承是在一些比较一般的类的基础上构造、建立和扩充新类的最有效的手段。

2.继承简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。

3.继承提供了软件复用功能。若类B继承类A，那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。这种做法能减小代码和数据的冗余度，大大增加程序的重用性。

4.继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。

5.提供多重继承机制。从理论上说，一个类可以是多个一般类的特殊类，它可以从多个一般类中继承属性与方法，这便是多重继承。Java出于安全性和可靠性的考虑仅支持单重继承，而通过使用接口机制来实现多重继承。

注意：如果父类是接口那么其中所有的方法必须由子类重写。如果父类是抽象类那么父类中的未实现方法必须有子类重写，

一般父类

//父类
public class Car {

	public void drive() {
		System.out.println("车可以开");
	}
}
//子类
public class Bus extends Car {

	public void buyTickets(){
    System.out.println("公交车要买票");
  }
}

公交车拓展了车的功能增加了一个买票的功能

抽象父类

public abstract class Animal {
	public void eat() {
		System.out.println("动物可以吃东西");
	}
	public abstract void move();
}

public class Dog extends Animal {
	@Override
	public void move() {
		System.out.println("狗在地上跑");
	}
}

有部分未实现的方法必须在子类中实现。

接口父类

public interface Phone {

	void call();

	void sendMsg();
}

public class SmartPhone implements Phone {
	@Override
	public void call() {
		System.out.println("手机可以打电话");
	}

	@Override
	public void sendMsg() {
		System.out.println("手机可以发短信");
	}

}

所有方法都在子类实现

2.关联(Association)

"XX是XX的一部分"关系（has a）通常使用的关键字 new
当一个对象中，加入了另外一个对象时就形成关联关系。

关于分为有两种特殊的形式，聚合（Aggregation）和组合（Composition），聚合和组合只有概念上的区别，在Java中的代码实现上没有区别。

在代码中具体表现为成员变量。

1.组合

组合:表示类之间的整体和部分的关系，所有组合在一起的对象作为一个整体存在，当整体不存在了那么部分对象也就不存在了

组合就像是人体，一旦人死亡每个器官就都死亡了。

2.聚合

聚合:表示整体和部分的关系，所有聚合在一起的对象作为一个整体存在，但个体的生命周期并不依赖整体的生命周期。

聚合就像人群，即使一个个体走散了个体也能生存。

下面我们就举个例子来说明两者关系：

有如下场景，汽车要开动之前需要先清洁汽车，检修完成后使用发动机点火启动。

/**
 * 汽车清理工具
 */
public class CleaningTools {

	private static final CleaningTools cleaningTools = new CleaningTools();
	private CleaningTools() {}

	public static CleaningTools getCleaningTools() {
		return cleaningTools;
	}

	public void clean() {
		System.out.println("清洁汽车");
	}

}
/**
 * 汽车发动机
 */
public class Motor {

	public void startUp() {
		System.out.println("发动汽车");
	}
}

public class Car {

	private CleaningTools cleaningTools = CleaningTools.getCleaningTools();
	private Motor motor = new Motor();

	public void dirver() {
		cleaningTools.clean();
		motor.startUp();
	}

	public static void main(String[] args) {
		Car car = new Car();
		car.dirver();
	}
}

在这个例子中汽车发动机和汽车就是组合关系。当汽车报废后发动机也会报废。（强关联）

汽车和汽车清理工具的关系是，即便汽车报废清理工具也能清理其他汽车。（弱关联）

3. 依赖(Dependency)

"XX用了一个XX"关系（use a）关键字 import

代码中的表现为局部变量，方法的参数，以及对静态方法的调用

1.依赖

依赖: 指两个相对独立的类，一个类负责构造另外一个类时两个类就形成了依赖关系。

依赖关系是最普遍的关系

public class StringUtil {

	public static boolean isNotEmpty(String str) {
		return str != null && "".equals(str.trim());
	}

}
public class Customer {

	public static void main(String[] args) {

		StringUtil.isNotEmpty("111");
	}
}

我们调用了StringUtil中的isNotEmpty方法,那么我们就可以说Customer类依赖了StringUtil类

4.总结

应该尽量优先使用关联，而不是泛化，因为泛化会使得类关系过于复杂化，破坏了封装性，使用组合一样可以获得已有类的功能，而且会使新类更加稳固。

实际上，从依赖 ⇒ 关联 ⇒ 泛化，类与类之间的关系更加紧密，互相之间的影响越来越大。

1.泛化

优点

• 子类能自动继承父类的接口
• 创建子类的对象时，无须创建父类的对象

缺点

• 破坏封装，子类与父类之间紧密耦合，子类依赖于父类的实现，子类缺乏独立性
• 支持扩展，但是往往以增加系统结构的复杂度为代价
• 不支持动态继承。在运行时，子类无法选择不同的父类
• 子类不能改变父类的接口

2.关联

优点

• 不破坏封装，整体类与局部类之间松耦合，彼此相对独立
• 具有较好的可扩展性
• 支持动态组合。在运行时，整体对象可以选择不同类型的局部对象
• 整体类可以对局部类进行包装，封装局部类的接口，提供新的接口

缺点

• 整体类不能自动获得和局部类同样的接口
• 创建整体类的对象时，需要创建所有局部类的对象

3.使用泛化还是关联。

新类是否需要向上造型。也就是说当我们想重用原类型作为新类型的内部实现的话，我们最好自己关联，如果我们不仅想重用内部实现而且还想重用接口的话，那就用泛化。

4.依赖

依赖是一种极为松散的类组织结构。

引用

http://blog.csdn.net/fantian830211/article/details/1753520
http://blog.csdn.net/qq_31655965/article/details/54645220