设计一个扩展自抽象类geometricobject的新的triangle类_设计模式个人浅显理解

六大原则：

单一职责原则：

定义：一个接口只做一个职责的事情，接口的变化只应该由一种原因引起。

例子：一个用户，有基本信息，有角色信息，这种对象应该由2个接口定义，基本信息接口和角色信息接口

好处：易扩展，相互影响较小

接口隔离原则：

定义： 接口只应该做跟自己相关的事情，做到尽量小，跟单一职责的区别是，单一职责对同一相关的功能放到同一接口，接口隔离更细化了这一原则，就算是同一类相关的功能，还可以根据实际业务去拆分。

例子：一个用户，已经按照基本信息和角色信息分成2个接口，但是基本信息还可以分成家庭信息，工作信息等。

好处：隔离性好，易复用

迪米特原则：（最少知识原则）

定义：对象需要尽可能的隐藏自己的实现细节，只对外提供必要方法。2.对象中只依赖跟自己相关的其他对象。

例子：有接口A,B,C A中只跟B交互，B跟C交互，那么A接口中只应该依赖B，而不应该去依赖C。前提是接口都满足单一职责原则。

好处：解耦，易扩展，易复用

里氏替换原则：

定义：父类出现的地方子类都可以替换，就是说子类要实现父类的所有公共方法。不管任何地方都都是可以用子类去替换父类的

例子：多态的体现。 父类定义了3个方法，子类同样拥有相同签名的3个方法。

好处：易扩展，调用简单，解耦

依赖倒置原则：

定义：上层模板不应该依赖底层模块的具体实现。应该去依赖底层模块的抽象接口。接口不依赖细节，细节只依赖接口。

例子：DAO 应该有接口，Service只依赖DAO的接口，不去依赖他的具体实现。

好处：解耦，易扩展

开闭原则：

定义：对修改关闭，对扩展开放。如果要变更一个已经上线的程序，我们最好是通过扩展的方式来对这个对象变更。

例子，比如产品价格，一开始我们定义好了价格，后面需要打折出售，那我们不要去修改之前的价格，应该去定义一个打折类来扩展，获取到价格，然后打折，给出最终价格。

好处：不会影响之前的代码，比如打折只是针对vip，那么普通用户还是可以调用之前的方法，而vip可用调用打折方法获取最终定价

设计模式理解：

创建型模式（5个）

单例模式：

定义：确保一个类只有一个实例，并且自己初始化这个实例

好处：一个实例比创建多个实例节约内存空间，单例的对象后面获取可直接用，节约创建时间

工厂方法模式：

定义：一个对象的创建用工厂类来做。

实例：我需要一辆汽车，那么去工厂提供车辆名称，交钱就可以拥有了。对应的车及车的生产流程交给工厂。

实现：

1.定义汽车抽象类，

2.若干汽车实现类，

3.工厂类。

工厂类提供一个公共方法，根据产品名称创建具体产品，还可以默认初始化对象的信息。在客户端自己调用工厂类的公共方法传入产品名称就可以获取产品了。

好处：可以隐藏对象创建的细节。易扩展，新增产品时，只需要修改工厂类，对于客户端调用可以无感知。符合迪米特法则，依赖倒置法则，里氏替换法则。

抽象工厂模式：

定义：有多个相同步骤的产品。提供统一的接口来创建。

实例：一个汽车工厂，需要生产不同配置的汽车。那一个配置的汽车所有配件就是一个抽象工厂

实现：

1.定义一个汽车配件抽象类定义配件名称，成本等，

2.多个配件的实现类。

3.再定义一个抽象工厂，提供所有配件的生产方法。

4.不同配置的配件整合成一个抽象工厂实现类。

一个抽象工厂的实现类就可以生产一个汽车的同一配置的所有配件。

好处：可以隐藏对象创建的细节。易扩展。另外还可以约束产品的创建步骤。新增配置只需要新增抽象工厂就可以了，客户端不需要太多修改。符合迪米特法则，依赖倒置法则，里氏替换法则。

建造者模式：

定义：产品的创建过程和产品的细节可以分离，同样的创建过程可以创建细节不同的产品。

实例：有一个汽车DIV工厂，只要告诉他汽车的各个配件的型号，他就可以组装一辆新汽车。

实现：

1.一个汽车抽象类和实现类，描述汽车需要的配件，如，发动机，轮胎，车架等；

2.一个建造抽象类，定义汽车，汽车的配件表，汽车的构建过程

3.建造实现类，根据传入的配件表创建出汽车。

4.导演类，定义不同的配件表，传给建造类，得到汽车。

导演类定义一组常用的汽车配件表，传入到建造实现类中就可以生产出满足配件表的汽车了。

好处：封装性，解耦，调用简单，如果需要创建一个全新的汽车，导演类新增一个方法，更新配件表就可以了。

原型模式：

定义：创建对象通过拷贝定义好的原型。

实例：工厂方法中创建对象可以结合原型模式，通过clone的方式可以更快的创建出一个新的对象。

实现：java语言只要实现了Cloneable接口，复写clone方法就可以了

//原型模式通用源码
public class PrototypeClass implements Cloneable{
//覆写父类Object方法
@Override
public PrototypeClass clone(){
    PrototypeClass prototypeClass = null;
    try {
        prototypeClass = (PrototypeClass)super.clone();
    } catch (CloneNotSupportedException e) {
        //异常处理
    }
    return prototypeClass;
    }
}

好处：可以更快的创建一个新的对象。

注意事项：

1.拷贝不会执行对象的构造方法

2.只是浅拷贝了对象中的基本类型变量，对象中的引用变量需要再复写的clone方发中再拷贝

结构型模式（7个）

代理模式：

定义：为对象提供代理，以达到对对象访问的控制。

实例：我要买车，我自己不会直接去工厂买,也不用去办理相关手续，4s店作为代理，我只跟4s点交互，我出钱拿车。车的相关手续都由4s店去处理。

实现：

1.汽车类

2. 代理类4s店，里面有汽车类

我直接去4s店代理类中获取到汽车，4s点会去工厂获取车后帮我办理手续再给我

好处：易扩展，代码复用,解耦合

动态代理：

动态代理就是写一个可以代理所有接口的代理类。代理的对象是动态创建的，AOP的实现原理

1.实现JDK提供的InvocationHandler接口，实现invoke方法，

2.再通过JDK提供的代理类Proxy来动态创建被代理的对象。

3.动态创建出来的代理类实际上会实现被代理的接口，并且继承Proxy类。

4.当调用被代理类的时候会通过写的动态代理类中的invoke方法去调用，那么我们就可以在invoke方法中实现方法调用前后的操作了。

动态代理类的实现代码：

未完待续，我会陆陆续续用自己的理解写完所有的设计模式。
不想续了。。。。。

参考：设计模式之禅