在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