Java中类之间的关系

欢迎关注我的公众号【软件大爆炸】
Java学习中的碎碎念
Java中易忽略的基础知识
Java面向对象基础
Java中的核心类
Java抽象类和接口
Java中的异常
Java中的泛型与集合
UML（ Unified Modeling Language），统一建模语言
类与类之间存在六种关系

• 继承：继承也称泛化，表现的是一种共性与特性的关系。

public class Test{
    public static void main(String args[]){
        Son s = new Son("zhengzhou","ZZU");
        System.out.println(s.toString());
    }
}

class Father{
        String address;

        public Father(String address){
            this.address = address;
            System.out.println("调用父类方法...");
        }
}

class Son extends Father{
    String school;

    public Son(String address, String school) {
        super(address);
        this.school = school;
        System.out.println("调用子类方法...");
    }

    @Override
    public String toString() {
        return "Son{" +
                "address=" + address+'\'' +
                "school='" + school + '\'' +
                '}';
    }
}

调用父类方法...
调用子类方法...
Son{address=zhengzhou'school='ZZU'}

在构造一个子类对象时，会首先调用父类的构造方法进行初始化，而后再调用子类的构造方法进行初始化
Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量所使用的类型决定；运行时类型则由实际赋给该变量的对象决定。如果编译时类型与运行时类型不一致，则称为“多态”。
一个父类具有多个子类，可以将子类对象直接赋值给一个父类引用变量，无需任何类型转换
例如：

Father s1 = new Son("zhengzhou", "ZZU");
Father s2 = new Son("Beijing", "THU");

• 实现：是类与接口之间常见的关系，其中接口对方法进行声明，而类完成对方法的定义。

//源码
public interface Move {
	void move();
}

//源码  
public class Animal implements Move {

	@Override
	public void move() {
		System.out.println("Animal move");
	}
	
}

public class Human implements Move{

	@Override
	public void move() {
		System.out.println("Human move");
	}

}

public class Car implements Move {

	@Override
	public void move() {
		System.out.println("Car move");
	}

}

public class MoveTest {

	public static void main(String[] args) {
		Move [] move = {new Animal(), new Human(), new Car()};
		for (Move m : move) {
			m.move();
		}
	}

}

//执行结果
Animal move
Human move
Car move

• 依赖：在一个类的方法中操作另一个类的对象。

public class DependentDemo {
//Person 依赖 Car
    public static void main(String[] args) {
        Car car = new Car();
        Person1 p = new Person1();
        p.travel(car);
    }
}

class Car{
    void run(String spl){
        System.out.println("开车去"+spl);
    }
}

class Person1{
    void travel(Car car){
        car.run("ZZU");
    }
}

依赖关系通常都是单向的。
并且人依赖车可以理解为：人的旅游依赖车，但并不关系车是如何得到的。只需要调用travel()方法时有车即可，旅游完毕后这辆车的去向也不必关心。

• 关联：在一个类中使用另一个的对象作为该类的成员变量。关联体现的是两个类之间语义级别的一种强依赖关系。
  关联关系比依赖关系更紧密，通常体现为一个类中使用另一个类的对象作为该类的成员变量。继续以人驾车旅游为例。
  将上例的代码稍作修改可以得到下面代码

public class AssociationDemo {
    public static void main(String[] args) {
        Car car = new Car();
        Person1 p = new Person1(car);
        p.travel();
    }
}

class Car{
    void run(String spl){
        System.out.println("开车去"+spl);
    }
}

class Person1{
    Car car = new Car();

    Person1(Car car){
        this.car = car;
    }

    void travel(){
        car.run("ZZU");
    }
}

人和车的关联关系可以理解为：人拥有辆车，旅游时可以用这辆车，做别的事情时也可以用。但是关联关系并不要求是独占的，以人车关联为例，即车也可以被别的人拥有。

• 聚合：关联关系的一种特例。体现的是整体与部分之间的关系，即has-a。通常表现为一个类（整体）由多个其他类的对象（部分）作为该类的成员变量，此时整体与部分之间是可以分离的，整体和部分都可以具有各自的生命周期，部分可以属于多个整体对象，也可以为多个整体对象共享。

public class AggregationDemo {
    public static void main(String[] args) {
        Employee[] emps = {
                new Employee("xiaowang"),
                new Employee("Laoli"),
                new Employee("xiaozhao"),
        };
        Department dept = new Department(emps);
        dept.show();
    }
}

class Employee{
    String name;
    Employee(String name){
        this.name = name;
    }
}

class Department{
    Employee[] emps;
    Department(Employee[] emps){
        this.emps = emps;
    }
    void show(){
        for (Employee emp : emps){
            System.out.println(emp.name);
        }
    }
}

xiaowang
Laoli
xiaozhao

上述代码中，部门类 Department中的 Employee数组代表此部门的员工。部门和员工的聚合关系可以理解为：部门由员工组成（从代码中可以明显看到），同一个员工也可能属于多个部门（可以构建其他部门类来包含员工），并且部门解散后，员工依然是存在的，并不会随之消亡。

• 组成：组成关系也是关联关系的一种特例，与聚合关系一样也是体现整体与部分的关系，但组成关系中的整体与部分是不可分离的，即 contains-a的关系，这种关系比聚合更强，也称为强聚合，当整体的生命周期结束后，部分的生命周期也随之结束。
  组成关系是比聚合关系要求更高的一种关联关系，体现的也是整体与部分的关系，但组成关系中的整体与部分是不可分离的，整体的生命周期结束后，部分的生命周期也随之结束。例如，汽车是由发动机、底盘、车身和电路设备等组成，是整体与部分的关系，如果汽车消亡后，这些设备也将不复存在，因此属于一种组成关系。

public class CompostionDemo {
    public static void main(String[] args) {
        Engine engine = new Engine();
        Chassis chassis = new Chassis();
        Bodywork bodywork = new Bodywork();
        Circuitry circuitry = new Circuitry();
        Car0 car0 = new Car0(engine, chassis, bodywork, circuitry);
    }
}

class Engine{
}

class Chassis{
}

class Bodywork{
}

class Circuitry{
}

class Car0{
    Engine engine;
    Chassis chassis;
    Bodywork bodywork;
    Circuitry circuitry;

    public Car0(Engine engine, Chassis chassis, Bodywork bodywork, Circuitry circuitry) {
        this.engine = engine;
        this.chassis = chassis;
        this.bodywork = bodywork;
        this.circuitry = circuitry;
    }
}

其中：
继承和实现体现的是类与类之间纵向关系，其他的四个则是横向关系。并且关联、聚合、组成更多的是语义上的区别，代码上无法区分。