当前位置：首页 > article >正文

设计模式-读书笔记

article 2024/12/23 17:31:28

确认好：

模式名称

问题：在何时使用模式，包含设计中存在的问题以及问题存在的原因

解决方案：设计模式的组成部分，以及这些组成部分之间的相互关系，各自的职责和协作方式，用uml类图和核心代码描述

效果：模式优缺点，使用模式时应权衡的问题

创建型：描述如何创建对象。5个

结构型：如何实现类对象的组合。7个

行为型：类和对象怎么交互，以及怎么分配职责。11个

结合是处理类还是对象，如单例模式是对象创建型模式

类之间的关系：

1、关联。单向关联（顾客和地址），双向关联（顾客与产品，相互绑定），自关联（链表节点），多重性关联（界面上有多个按钮）

聚合（生命周期不同，汽车与轮胎），组合（生命周期相同，脸与鼻子）

菱形箭头，指向轮胎，另一边右箭头

2、依赖。驾驶员与汽车。----->指向汽车

3、泛化。继承，父类与子类。菱形箭头，指向父类，另一边无箭头。在这基础上，改为虚线，就是接口实现，指向接口

面向对象设计原则：

1、单一职责：一个类只负责一个功能领域中的相应职责。

2、开闭原则。实体对扩展开放，对修改关闭。

3、里氏替换原则。所有引用基类对象的地方，能够透明地使用其子类的对象。

4、依赖倒转原则。抽象不应该依赖于细节，而是细节依赖于对象。

换言之，要针对接口编程，而不是针对实现编程。

一个具体类应当实现接口或抽象类中声明过的方法，而不要给出多余的方法，否则将无法调用到在子类中加的新方法。

将具体类的对象通过依赖注入(DI)的方式注入到其他对象：构造注入，设值setter注入，接口注入

5、接口隔离原则。使用多个专门的接口，而不使用单一的总接口。

应当为客户端提供尽可能小的单独的几口，客户端不应该依赖那些它不需要的接口。因为实现一个接口就要实现该接口定义的所有方法。

6、合成复用原则。尽量使用对象组合，而不是继承来达到复用目的。

聚合/组合应优于继承，后者破坏了封装性，前者耦合性低。

7、迪米特原则。一个软件实体应当尽可能少地与其他实体发生相互作用。

通过引入一个合理的第三者来降低现有对象之间的耦合度

创建型模式

单例模式对象创建型模型

问题：windows任务管理器点击多次，只弹出一个页面（！真的）再比如负载均衡器的唯一性

demo1
private static A a = null; 静态变量
public static A getA(){
    if(a == null){  但是这里初始化需要一段时间，仍可能创建了多个loadBalancer
        a = new A();
    }
    return a;
}

为了解决上面的问题，考虑到单例类的两个实现方式：饿汉式和懒汉式。

饿汉式，定义静态变量，直接初始化，见demo2，资源效率不好，可能初始化用不到该类，并且初始化加载时间长

private static A a = new A(); 静态变量
public static A getA(){
    return a;
}

懒汉式就是demo1，在demo1的基础上我们引入线程锁定

demo3
private static A a = null; 
public static A getA(){
    if(a == null){  
        synchronized(LazySingleton.class){
        	 a = new A();
    	}   
    }
	return a;
}

仍有问题，假如两个线程同时判定了为空。引入双重检查锁定

demo4
private static A a = null; 
public static A getA(){
	 if(a == null){
		synchronized(LazySingleton.class)
    		if(a == null){  // 第2重判断
				a = new A();
    		}
     }
	return a;
}

更好的方法 IoDH方法

增加一个静态内部类

demo5
private static Class B(){
	private final static A a = new A();
}
public static A getA(){return B.a;}

简单工厂模式集中式对象创建型静态工厂

Chart类实现柱状图、饼状图等不同图表的实现

创建和使用不应耦合在一起

工厂类！！

//demo1
class Factory{
	public static Chart getChart(String type){  //静态工厂实现
        Chart chart = null;
        if(type.equalsIgnoreCase("h")){
            chart = new HChart();
        }
        else if 。。。。。。  
    }
}

工厂方法多态对象创建型解决静态工厂无法引入新产品

工厂多个具体的

//demo1
interface Logger{public void w();}  //抽象产品
class DLogger implements Logger{public void w(){.....}} //具体产品
interface Factory{public Logger getL();}  //抽象工厂
class DLoggerFactory{
    public Logger getL(){
        DLogger d = new DLogger();
        return d;
    }
}
//使用
Factory f;
Logger l;
f = new DLoggerFactory();
l = f.getL();
l.w();

可以用读取配置文件来获取类字符串，使用java的反射机制，根据类名字符串生成对象

如创建一个字符串类型的对象，通过类名生成实例对象并将其返回

Class c = Class.forName("String");
Object obj = c.newInstance();
return obj;

创建DOM对象

DocumentBuilderFactory dFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = dFactory.newDocumentBuilder();
Document doc;

用xml文件配置

<?xml version = "1.0">
<config>
	<className>FileLoggerFactory></className>
</cofig>

f = new DLoggerFactory();
//改为
f = (DLoggerFactory)XMLUtil.getBean();

缺点：类成对增加，开销大

抽象工厂模式产品族对象创建型比如界面风格

//抽象工厂
interface Factory{
    public Button createButton();   //两个抽象产品
    public TextField createTextField();
}

//具体工厂
class SummerFactory{
    public Button createButton(){
        return new SummerButton;
    };  
    public TextField createTextField(){
        。。。。。
    };
}

同样可以用xml配置文件反射得到java具体工厂

缺点：再增加新的抽象产品很麻烦

P86/396 12.4 22:01留

原型模式对象的克隆对象创建型

//demo1
class ConcretePrototype implements Prototype{
    private String attr;  // 成员变量
    public void setAttr(String attr){
        this.attr = attr;
    }
    public String getAttr(){
        return this.attr;
    }
    // 克隆方法
    public Prototype clone(){
        Prototype prototype = new Prototype();
        prototype.setAttr(this.attr);
        return prototype
    }
}

java中所有类都继承Object 类中的clone()方法，而这个方法来自接口Clonable

浅克隆

主要区别是是否支持引用类型（类、接口、数组）的成员变量的复制。当引用类型时，原型对象和克隆对象的成员变量指向相同的内存地址

深克隆序列化实现：将对象写到流中，写到流中的对象，是原有对象的一个复制品

Serializable接口（两个类均要实现）附件类Attachment 是下面一个类的属性周报类WeeklyLog（使用序列化实现深克隆）

//demo2
public WeeklyLog deepclone(){
    //将对象写入流中
    ByteArrayOutputStream bao = new ByteArrayOutputStream();
    ObjectOutputStream oos = new ObjectOutputStream(bao);
    oos.writeObject(this);
    //将对象从流中读取
    ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
    ObjectInputStream ois = new ObjectInputStream(bis);
    return (WeeklyLog)ois.readObject();
}

建造者模式复杂对象的组装与创建对象创建型

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示

客户端只需实例化指挥者类，指挥者类针对抽象建造者编程，客户端根据需要传入具体的建造者类型

指挥者将指导具体建造者一步一步地构造一个完整的产品

//产品
class Product{
    private String partA;
    private String partB;
}
//抽象建造者类
abstract class Buider{
    protected Product product = new Product();
    public abstract void buildPartA();
    public abstract void buildPartB();
    //返回产品对象
    public Product getResult(){
        return product;
    }
}
//指挥者
class Director{
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder；
    }
    //产品构建与组装方法
    public Product construct(){
        builder.buildPartA();
        builder.buildPartB();//决定次序
    }
}
//实现
Builder builder = new ConcreteBuilder(); //可通过配置文件实现
Director director = new Director(builder);
Product product = director.construct();