Java中类与类的关系

时间:2024-08-19 17:05:20

在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.****.net/fantian830211/article/details/1753520

http://blog.****.net/qq_31655965/article/details/54645220