韩老师设计模式1：7原则。依赖关系3种方法。UML类图6关系。

天海华兮

已于 2022-06-04 16:33:34 修改

阅读量214

点赞数

分类专栏： java SE 文章标签： uml 设计模式 7大原则依赖关系类图6关系

于 2022-06-04 16:31:32 首次发布

本文链接：https://blog.csdn.net/qq120631157/article/details/125122840

版权

java SE 专栏收录该内容

104 篇文章 3 订阅

订阅专栏

面试

在这里插入图片描述

1. 原型模式

1)有请使用UML类图画出原型模式核心角色

2) 原型设计模式的深拷贝和浅拷贝是什么，并写出深拷贝的两种方式的源码(重写
clone方法实现深拷贝、 使用序列化来实现深拷贝)


3) 在Spring框架中哪里使用到原型模式，并对源码进行分析
bean的创建，就是原型模式

beans.xml
1. <bean id="id01" class="com.atguigu.spring.bean.Monster" scope="prototype"/> //原型

2. ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
	Object id01 = context.getBean("id01");

3. return this.doGetBean(name, (Class)null, (Object[])null, false);

4. 源码：
				else if (mbd.isPrototype()) {
                    var11 = null;

                    Object prototypeInstance;
                    try {
                        this.beforePrototypeCreation(beanName);
                        prototypeInstance = this.createBean(beanName, mbd, args);
                    } finally {
                        this.afterPrototypeCreation(beanName);
                    }

                    bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }

2. 七大原则

设计模式的七大原则: 要求：

七大设计原则核心思想
能够以类图的说明设计原则
在项目实际开发中，你在哪里使用到了ocp原则
- 工厂模式使用了开闭原则

设计模式常用的七大原则有:

单一职责原则
接口隔离原则
依赖倒转原则
里氏替换原则
开闭原则 ocp
迪米特法则
合成复用原则
依里接单开合笛

Open-Closed Principle 中文:开闭原则

principle 
英 /ˈprɪnsəpl/  美 /ˈprɪnsəpl/  全球(美国)  
简明 牛津 新牛津  韦氏  柯林斯 例句 百科
n. （行为）准则，（道德）原则；道义，正直；基本原则，基本法则；（机器等或自然界的）原理，定律；（宗教或政治的）主义，信条；起源，本原；本质，实质；（化）成分，要素

3. 状态模式

金融借贷平台项目：借贷平台的订单，有审核-
发布-抢单等等步骤，随着操作的不同，会改
变订单的状态, 项目中的这个模块实现就会使用
到状态模式，请你使用状态模式进行设计，并
完成实际代码

问题分析：
这类代码难以应对变化，在添加一种状态时，
我们需要手动添加if/else，在添加一种功能时，
要对所有的状态进行判断。因此代码会变得越
来越臃肿，并且一旦没有处理某个状态，便会
发生极其严重的BUG，难以维护

4. 解释器 spel

解释器设计模式
1) 介绍解释器设计模式是什么?
2) 画出解释器设计模式的UML类图,
分析设计模式中的各个角色是什
么?
3) 请说明Spring的框架中，哪里
使用到了解释器设计模式，并
做源码级别的分析


AbstractExpression	和 NonterminalExpression（是子类） 进行了聚合（空心的菱形 是聚合，实心是组合）

client指向 context 和 AbstractExpression ，叫做依赖

1) Spring框架中 SpelExpressionParser就使用到解释器模式
2) 代码分析+Debug源码+模式角色分析说明


public class Interpreter {
        public static void main(String[] args) {
        SpelExpressionParser parser = new SpelExpressionParser();
        Expression expression = parser.parseExpression("100 * (2 + 400) *
                1 + 66");
        int result = (Integer) expression.getValue();
        System.out.println(result);
    }
}

public interface ExpressionParser {  
    
Expression parseExpression(String expressionString) throws ParseException;
    
Expression parseExpression(String expressionString,ParserContext context) throws ParseException;
    
}

public abstract class TemplateAwareExpressionParser implements ExpressionParser {
    
public Expression parseExpression(String expressionString, ParserContext context) { 
    // 不同情况返回不同的Express. 
} //看源码

5. 单例

单例设计模式一共有几种实现方式？请分别用代码实现，并说明各个实现方式的
优点和缺点?

单例设计模式一共有8种写法， 后面我们会依次讲到
1) 饿汉式 两种
	定义全局静态变量，也算 饿汉式了
2) 懒汉式 三种
	加锁 和 不加锁，这里 CAS模式，也是 懒汉。
3) 双重检查
	也是懒汉呀
	
4) 静态内部类
	懒加载，也是懒汉
5) 枚举

设计模式的重要性

软件工程中，设计模式（design pattern）是对软件设计中普遍存在（反复出现）
的各种问题，所提出的解决方案。

这个术语是由埃里希·伽玛（Erich Gamma）等人
在1990年代从建筑设计领域引入到计算机科学的

大厦 VS 简易房

工厂模式：

简单工厂
工厂方法
抽象工厂

适配器模式：也是分3种

建造者模式：java.lang.StringBuilder

目的

编写软件过程中，程序员面临着来自

耦合性，
内聚性以及
可维护性，
可扩展性，
重用性，
灵活性等多方面的挑战，设计模式是为了让程序(软件)，具有更好

1) 代码重用性 (即：相同功能的代码，不用多次编写)
2) 可读性 (即：编程规范性, 便于其他程序员的阅读和理解)
3) 可扩展性 (即：当需要增加新的功能时，非常的方便，称为可维护)
4) 可靠性 (即：当我们增加新的功能后，对原来的功能没有影响)
5) 使程序呈现高内聚， 低耦合的特性

分享金句：
设计模式包含了面向对象的精髓，“懂了设计模式，你就懂了面向对象分析和设计
（OOA/D）的精要”

面向对象，3特性：继承 封装 多态。

Scott Mayers 在其巨著《Effective C++》 就曾经说过： C++老手和 C++新手的区别就是
前者手背上有很多伤疤。老手踩了很多坑

7大原则

设计模式常用的七大原则有:
1) 单一职责原则
2) 接口隔离原则
3) 依赖倒转(倒置)原则
4) 里氏替换原则 长江后浪推前浪，后浪的人，前浪的都会
5) 开闭原则
6) 迪米特法则 最少知道
7) 合成复用原则

1. 单一职责汽车在地上跑

各司其职

UserDao，单一职责

对类来说的，即一个类应该只负责一项职责。

如类A负责两个不同职责：职责1，职责2。

当职责1需求变更而改变A时，可能造成职责2执行错误，
所以需要将类A的粒度分解为 A1， A2

违反了职责

Vehicle vehicle = new Vehicle();
		vehicle.run("摩托车");
		vehicle.run("飞机");
		
class Vehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + " 在公路上运行....");
	}
}

使用类和方法

区分两个类

new RoadVehicle().run("汽车");
new AirVehicle().run("飞机");

class RoadVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "公路运行");
	}
}

class AirVehicle {
	public void run(String vehicle) {
		System.out.println(vehicle + "天空运行");
	}
}

一个类两个方法

方法上遵守单一职责

		Vehicle2 vehicle2  = new Vehicle2();
		vehicle2.run("汽车");
		vehicle2.runAir("飞机");

	public void run(String vehicle) {
		//处理
		System.out.println(vehicle + " 在公路上运行....");
	}
	
	public void runAir(String vehicle) {
		System.out.println(vehicle + " 在天空上运行....");
	}

事项和细节

单一职责原则注意事项和细节
1) 降低类的复杂度，一个类只负责一项职责。
2) 提高类的可读性，可维护性
3) 降低变更引起的风险
4) 通常情况下， 我们应当遵守单一职责原则，只有逻辑足够简单，才可以在代码级违
反单一职责原则；只有类中方法数量足够少，可以在方法级别保持单一职责原则

2. 接口隔离原则要什么功能实现什么接口

(Interface Segregation Principle)
基本介绍
\1) 客户端不应该依赖它不需要的接
口，即一个类对另一个类的依赖
应该建立在最小的接口上

我用不不到的方法，没有。
就是把接口，拆成最小的

UML类图，空心箭头是实现，实心箭头是依赖。

接口1 有5个方法，B类实现了5个方法。
A类，需要依赖 B，但只会使用B类的 1 2 3 方法。违反了接口隔离。

不使用原则

//接口
interface Interface1 {
	void operation1();
	void operation2();
}

class B implements Interface1 {
	public void operation1() {
		System.out.println("B 实现了 operation1");
	}
	
	public void operation2() {
		System.out.println("B 实现了 operation2");
	}
}

2 方法，白写了

class A { //A 类通过接口Interface1 依赖(使用) B类，但是只会用到1方法
	public void depend1(Interface1 i) {
		i.operation1();
	}
}

使用规则

方法1 为接口1

方法2，方法3 为接口2

方法4，方法5，为接口3

B类，实现接口 1,2

D类，实现接口 1,3

接口进行隔离

// 接口1
interface Interface1 {
	void operation1();
}

// 接口2
interface Interface2 {
	void operation2();
	void operation3();
}

// 接口3
interface Interface3 {
	void operation4();
	void operation5();
}

实现类，只实现需要的

class B implements Interface1, Interface2 {
	public void operation1() {
		System.out.println("B 实现了 operation1");
	}

	public void operation2() {
		System.out.println("B 实现了 operation2");
	}

	public void operation3() {
		System.out.println("B 实现了 operation3");
	}

}

A接口依赖，不变

class A { // A 类通过接口Interface1,Interface2 依赖(使用) B类，但是只会用到1,2,3方法
	public void depend1(Interface1 i) {
		i.operation1();
	}

	public void depend2(Interface2 i) {
		i.operation2();
	}

	public void depend3(Interface2 i) {
		i.operation3();
	}
}

进行测试

		A a = new A();
		a.depend1(new B()); // A类通过接口去依赖B类
		a.depend2(new B());
		a.depend3(new B());

 //因为：B implements Interface1, Interface2

3. 依赖倒转对接口的依赖

原则(Dependence Inversion Principle)是指：

1) 高层模块不应该依赖低层模块，二者都应该依赖其 抽象
2) 抽象不应该依赖细节，细节应该依赖 抽象
3) 依赖倒转(倒置)的中心思想是 面向接口编程

4) 依赖倒转原则是基于这样的设计理念：相对于细节的多变性，抽象的东西要稳定的
多。
以抽象为基础搭建的架构比以细节为基础的架构要稳定的多。
在java中，抽象指的是接口或抽象类，细节就是具体的实现类.

5) 使用接口或抽象类的目的是 制定好规范，而不涉及任何具体的操作，
把展现细节的任务交给他们的实现类去完成。

不适用规则


		Person person = new Person();
		person.receive(new Email());

class Email {
	public String getInfo() {
		return "电子邮件信息: hello,world";
	}
}

//完成Person接收消息的功能
//方式1分析
//1. 简单，比较容易想到
//2. 如果我们获取的对象是 微信，短信等等，则新增类，同时Perons也要增加相应的接收方法
//3. 解决思路：引入一个抽象的接口IReceiver, 表示接收者, 这样Person类与接口IReceiver发生依赖
//   因为Email, WeiXin 等等属于接收的范围，他们各自实现IReceiver 接口就ok, 这样我们就符号依赖倒转原则
class Person {
	public void receive(Email email ) {
		System.out.println(email.getInfo());
	}
}

使用规则和开闭一样

使用方，无需改变

//定义接口
interface IReceiver {
	public String getInfo();
}

class Email implements IReceiver {
	public String getInfo() {
		return "电子邮件信息: hello,world";
	}
}
//在增加一个 WX

//方式2
class Person {
	//这里我们是对接口的依赖
	public void receive(IReceiver receiver ) {
		System.out.println(receiver.getInfo());
	}
}

依赖关系传递

依赖关系传递的三种方式和应用案例

1) 接口传递


2) 构造方法传递


3) setter方式传递

3.1 接口(本)传递(形参)

//方式1： 通过接口传递实现依赖
//开关的接口
interface IOpenAndClose {
	public void open(ITV tv); //抽象方法,接收接口
}
interface ITV { //ITV接口
	public void play();
}

// 实现接口
class OpenAndClose implements IOpenAndClose {
	public void open(ITV tv) {
		tv.play();
	}
}

class ChangHong implements ITV {
	@Override
	public void play() {
		System.out.println("长虹电视机，打开");
	}
}

		ChangHong changHong = new ChangHong();
		OpenAndClose openAndClose = new OpenAndClose();
		openAndClose.open(changHong);

3.2 构造方法

// 方式2: 通过构造方法依赖传递
interface IOpenAndClose {
	public void open(); //抽象方法
}
interface ITV { //ITV接口
	public void play();
}

class OpenAndClose implements IOpenAndClose {
	public ITV tv; //成员

	public OpenAndClose(ITV tv) { //构造器
		this.tv = tv;
	}

	public void open() {
		this.tv.play();
	}
}

		ChangHong changHong = new ChangHong();

		//通过构造器进行依赖传递
		OpenAndClose openAndClose = new OpenAndClose(changHong);
		openAndClose.open();

3.3 定义set方法

interface IOpenAndClose {
	public void open(); // 抽象方法

	public void setTv(ITV tv);
}

interface ITV { // ITV接口
	public void play();
}

class OpenAndClose implements IOpenAndClose {
	private ITV tv;

	public void setTv(ITV tv) {
		this.tv = tv;
	}

	public void open() {
		this.tv.play();
	}
}

		OpenAndClose openAndClose = new OpenAndClose();
		openAndClose.setTv(changHong);
		openAndClose.open();

注意和细节

依赖倒转原则的注意事项和细节

1) 低层模块尽量都要有抽象类或接口，或者两者都有，程序稳定性更好.
2) 变量的声明类型尽量是抽象类或接口, 这样我们的变量引用和实际对象间，就存在
一个缓冲层，利于程序扩展和优化
3) 继承时遵循里氏替换原则

4. 里式替换提取父类，使用组合

OO中的继承性的思考和说明

1) 继承包含这样一层含义：父类中凡是已经实现好的方法， 实际上是在设定规范和契
约，虽然它不强制要求所有的子类必须遵循这些契约，但是如果子类对这些已经实
现的方法任意修改，就会对整个继承体系造成破坏。

2) 继承在给程序设计带来便利的同时，也带来了弊端。比如使用继承会给程序带来侵
入性，程序的可移植性降低，增加对象间的耦合性，如果一个类被其他的类所继承，
则当这个类需要修改时，必须考虑到所有的子类，并且父类修改后，所有涉及到子
类的功能都有可能产生故障

3) 问题提出：在编程中，如何正确的使用继承? => 里氏替换原则

1) 里氏替换原则(Liskov Substitution Principle)在1988年，由麻省理工学院的以为姓里
的女士提出的。
2) 如果对每个类型为T1的对象o1，都有类型为T2的对象o2，使得以T1定义的所有程序
P在所有的对象o1都代换成o2时，程序P的行为没有发生变化，那么类型T2是类型T1
的子类型。
换句话说，所有引用基类的地方必须能透明地使用其子类的对象。

3) 在使用继承时，遵循里氏替换原则，在子类中尽量不要重写父类的方法

4) 里氏替换原则告诉我们，继承实际上让两个类耦合性增强了， 在适当的情况下，可
以通过聚合，组合，依赖 来解决问题。 .
A 继承与 B，重写了B的 方法1，改成： A和B 上提一个 接口或超类，A和B分别重写 方法1

不遵循规则


		// TODO Auto-generated method stub
		A a = new A();
		System.out.println("11-3=" + a.func1(11, 3));

		B b = new B();
		System.out.println("11-3=" + b.func1(11, 3));//这里本意是求出11-3

// A类
class A {
	// 返回两个数的差
	public int func1(int num1, int num2) {
		return num1 - num2;
	}
}

// B类继承了A
// 增加了一个新功能：完成两个数相加,然后和9求和
class B extends A {
	//这里，重写了A类的方法, 可能是无意识
	public int func1(int a, int b) {
		return a + b;
	}

	public int func2(int a, int b) {
		return func1(a, b) + 9;
	}
}

B无意中重写了父类的
方法，造成原有功能出现错误。在实际编程中，我们常常会通过重写父类的方法完
成新的功能，这样写起来虽然简单，但整个继承体系的复用性会比较差。特别是运
行多态比较频繁的时候

通用的做法是：原来的父类和子类都继承一个更通俗的基类，原有的继承关系去掉，
采用依赖，聚合，组合等关系代替

generalization
n. （依据不足的）概括，泛论（=generalisation）

general 
英 /ˈdʒen(ə)rəl/  美 /ˈdʒen(ə)rəl/  全球(英国)  
adj. 总体的，普遍的；一般的，常规的；大致的，大概的；综合的，广泛的；首席的，总管的
n. 上将，将军；半军事化管理的宗教组织（如耶稣会修士、多明我会修士或救世军）的领袖；<古>大众，公众

使用组合关系

//创建一个更加基础的基类
class Base {
	//把更加基础的方法和成员写到Base类
}

// A类
class A extends Base {
	// 返回两个数的差
	public int func1(int num1, int num2) {
		return num1 - num2;
	}
}

// B类继承了A
// 增加了一个新功能：完成两个数相加,然后和9求和
class B extends Base {
	//如果B需要使用A类的方法,使用组合关系
	private A a = new A();
	
	//这里，重写了A类的方法, 可能是无意识
	public int func1(int a, int b) {
		return a + b;
	}

	public int func2(int a, int b) {
		return func1(a, b) + 9;
	}
	
	//我们仍然想使用A的方法
	public int func3(int a, int b) {
		return this.a.func1(a, b);
	}
}

5. 开闭原则核心。新增图形继承父类

1) 开闭原则（Open Closed Principle） 是编程中最基础、最重要的设计原则

2) 一个软件实体如类，模块和函数应该对扩展开放(对提供方)， 对修改关闭(对使用
方)。 用抽象构建框架，用实现扩展细节。

3) 当软件需要变化时，尽量通过扩展软件实体的行为来实现变化，而不是通过修改已
有的代码来实现变化。
4) 编程中遵循其它原则，以及使用设计模式的目的就是遵循开闭原则。

不使用原则

基本图形接口和实现

//Shape类，基类
class Shape {
	int m_type;
}

class Rectangle extends Shape {
	Rectangle() {
		super.m_type = 1;
	}
}

class Circle extends Shape {
	Circle() {
		super.m_type = 2;
	}
}

根据类型，画不同的图形

//这是一个用于绘图的类 [使用方]
class GraphicEditor {
	//接收Shape对象，然后根据type，来绘制不同的图形
	public void drawShape(Shape s) {
		if (s.m_type == 1)
			drawRectangle(s);
		else if (s.m_type == 2)
			drawCircle(s);
	}

	//绘制矩形
	public void drawRectangle(Shape r) {
		System.out.println(" 绘制矩形 ");
	}

	//绘制圆形
	public void drawCircle(Shape r) {
		System.out.println(" 绘制圆形 ");
	}
}

		GraphicEditor graphicEditor = new GraphicEditor();
		graphicEditor.drawShape(new Rectangle());
		graphicEditor.drawShape(new Circle());

方式1的优缺点
1) 优点是比较好理解，简单易操作。
2) 缺点是违反了设计模式的ocp原则，即对扩展开放(提供方)，对修改关闭(使用方)。
即当我们给类增加新功能的时候，尽量不修改代码，或者尽可能少修改代码.
3) 比如我们这时要新增加一个图形种类 三角形，我们需要做如下修改， 修改的地方
较多

使用原则

使用方，无需改变

//这是一个用于绘图的类 [使用方]，扩展的时候，无需修改
class GraphicEditor {
	//接收Shape对象，调用draw方法
	public void drawShape(Shape s) {
		s.draw();
	}
}

接口和实现


//Shape类，基类
abstract class Shape {
    
    int m_type;
    
	public abstract void draw();//抽象方法
}

//可新增
class Rectangle extends Shape {
    
    Rectangle() {
		super.m_type = 1;
	}

	@Override
	public void draw() {
		// TODO Auto-generated method stub
		System.out.println(" 绘制矩形 ");
	}
}


		GraphicEditor g = new GraphicEditor();
		g.drawShape(new Rectangle());

6. 迪米特法则

1) 一个对象应该对其他对象保持最少的了解
2) 类与类关系越密切，耦合度越大

3) 迪米特法则(Demeter Principle)又叫最少知道原则，即一个类对自己依赖的类知道的
越少越好。也就是说，对于被依赖的类不管多么复杂，都尽量将逻辑封装在类的内
部。对外除了提供的public 方法，不对外泄露任何信息

4) 迪米特法则还有个更简单的定义：只与直接的朋友通信

5) 直接的朋友：每个对象都会与其他对象有耦合关系，只要两个对象之间有耦合关系，
我们就说这两个对象之间是朋友关系。耦合的方式很多，依赖，关联，组合，聚合
等。其中，我们称出现成员变量，方法参数，方法返回值中的类为直接的朋友，而
出现在局部变量中的类不是直接的朋友。也就是说，陌生的类最好不要以局部变量
的形式出现在类的内部。

1) 有一个学校， 下属有各个学院和
总部， 
现要求打印出学校总部员
工ID和学院员工的id

打印总部员工和学院员工


		//创建了一个 SchoolManager 对象
		SchoolManager s = new SchoolManager();
		//输出学院的员工id 和  学校总部的员工信息
		s.printAllEmployee(new CollegeManager());

//学校总部员工类
class Employee {
	private String id;

	public void setId(String id) {
		this.id = id;
	}

	public String getId() {
		return id;
	}
}


//学院的员工类
class CollegeEmployee {
	private String id;
	//get set
}


//管理学院员工的管理类
class CollegeManager {
	//返回学院的所有员工
	public List<CollegeEmployee> getAllEmployee() {
		List<CollegeEmployee> list = new ArrayList<CollegeEmployee>();
		for (int i = 0; i < 10; i++) { //这里我们增加了10个员工到 list
			CollegeEmployee emp = new CollegeEmployee();
			emp.setId("学院员工id= " + i);
			list.add(emp);
		}
		return list;
	}
}

//学校管理类

//分析 SchoolManager 类的直接朋友类有哪些 Employee、CollegeManager
//CollegeEmployee 不是 直接朋友 而是一个陌生类，这样违背了 迪米特法则 
class SchoolManager {
	//返回学校总部的员工
	public List<Employee> getAllEmployee() {
		List<Employee> list = new ArrayList<Employee>();
		
		for (int i = 0; i < 5; i++) { //这里我们增加了5个员工到 list
			Employee emp = new Employee();
			emp.setId("学校总部员工id= " + i);
			list.add(emp);
		}
		return list;
	}

	//该方法完成输出学校总部和学院员工信息(id)
	void printAllEmployee(CollegeManager sub) {
		
		//分析问题
		//1. 这里的 CollegeEmployee 不是  SchoolManager的直接朋友
		//2. CollegeEmployee 是以局部变量方式出现在 SchoolManager
		//3. 违反了 迪米特法则 
		
		//获取到学院员工
		List<CollegeEmployee> list1 = sub.getAllEmployee();
		System.out.println("------------学院员工------------");
		for (CollegeEmployee e : list1) {
			System.out.println(e.getId());
		}
		//获取到学校总部员工
		List<Employee> list2 = this.getAllEmployee();
		System.out.println("------------学校总部员工------------");
		for (Employee e : list2) {
			System.out.println(e.getId());
		}
	}
}

------------学院员工------------
学院员工id= 0
...
学院员工id= 9
------------学校总部员工------------
学校总部员工id= 0
...
学校总部员工id= 4

使用法则改进

学院类提供打印的方法
不要把自己的实现方法，写到别人的类里

	//输出学院员工的信息
	public void printEmployee() {
		//获取到学院员工
		List<CollegeEmployee> list1 = getAllEmployee();
		System.out.println("------------学院员工------------");
		for (CollegeEmployee e : list1) {
			System.out.println(e.getId());
		}
	}

学校总部类，打印时，调用方法

	void printAllEmployee(CollegeManager sub) {
		
		//分析问题
		//1. 将输出学院的员工方法，封装到CollegeManager
		sub.printEmployee();
		
		...
		
		}

迪米特法则注意事项和细节
1) 迪米特法则的核心是降低类之间的耦合
2) 但是注意：由于每个类都减少了不必要的依赖，因此迪米特法则只是要求降低
类间(对象间)耦合关系， 并不是要求完全没有依赖关系

6. 合成复用原则

（Composite Reuse Principle）
基本介绍
原则是尽量使用合成/聚合的方式，而不是使用继承

设计原则核心思想

1) 找出应用中可能需要变化之处，把它们独立出来，不要和那些不需要变化的代
码混在一起。
2) 针对接口编程，而不是针对实现编程。
3) 为了交互对象之间的松耦合设计而努力

UML类图元素6个关系

使用了 > ▷+ 虚线实线。
- 实线 + ◇♦
- 6种组合
- 但：最普通的箭头 —>，表示组合，不合适。顾去掉了箭头，用 — 标识。
继承为不好的强依赖。用实线：—▷
- 实现是比较好的弱依赖，用虚线：—▷
依赖，聚合，组合，实质是一个东西。依赖已经用图形表示过。
- 聚合，组合用菱形表示
  - 聚合是与组合相比，耦合性弱：所以是空心的菱形。
  - 组合：耦合性特别强。所以实心的菱形。
  - 注意：聚合组合都是实线。

1. 依赖、----->		虚线
Dependency
方法的参数 （a:A)，构造也是吧

2. 关联、_______		实线   或 ————>
association
一对一，一对n


3. 继承(泛化)、————▷	实线 ＿＿＿▷
Generalization
略
4. 实现、------▷	虚线
implementation 和 realization
略


5. 聚合、——————◇	实线 ＿＿＿＿◇
Aggregation
定义属性 a:A，使用 setA(a:A) 方法赋值
当前类X，聚合了 A类
6. 组合、——————♦	实线 ＿＿＿＿♦
composite
x类里，new A(); 耦合性 比聚合强。