二十三种设计模式-----归纳篇(JAVA)

小灰灰 2023-09-28 15:43 94阅读 0赞

**目录**

一、设计模式

1.创建型模式

1.1、FactoryMethod ( 工厂方法 )

1.2、AbstractFactory ( 抽象工厂 )

1.3 Singleton ( 单态模式 )

1.4 Builder ( 建造者模式 )

1.5、Prototype ( 原型模式 )

--------------------

## 一、设计模式 ##

### 1.创建型模式 ###

其中创建型模式分为: **FactoryMethod ( 工厂方法 )、AbstractFactory ( 抽象工厂 )、Singleton ( 单态模式 )、Builder ( 建造者模式 )、Prototype ( 原型模式 )**

#### **1.1、**FactoryMethod ( 工厂方法 ) ####

**概述**

定义一个用于创建对象的接口，让子类决定实例化哪一个类。FactoryMethod使一个类的实例化延迟到其子类。

**适用性**

**1.当一个类不知道它所必须创建的对象的类的时候**。

2.当一个类希望由它的子类来指定它所创建的对象的时候。

3.当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

**参与者**

**1.Product**

定义工厂方法所创建的对象的接口。

**2.ConcreteProduct**

实现Product接口。

**3.Creator**

声明工厂方法，该方法返回一个Product类型的对象。 Creator也可以定义一个工厂方法的缺省实现，它返回一个缺省的ConcreteProduct对象。 可以调用工厂方法以创建一个Product对象。

**4.ConcreteCreator**

重定义工厂方法以返回一个ConcreteProduct实例。

![c8581fb07500453e9240ab120161edb6.png][]

例子

// Product
     public interface Work {
    
        void doWork();
    }
    
    //ConcreteProduct 
    
    public class StudentWork implements Work {
    
        public void doWork() {
            System.out.println("学生做作业!");
        }
    
    }
    
    public class TeacherWork implements Work {
    
        public void doWork() {
            System.out.println("老师审批作业!");
        }
    
    }
    
    //Creator 
    
    public interface IWorkFactory {
    
        Work getWork();
    }
    
    
    //ConcreteCreator
    
    public class StudentWorkFactory implements IWorkFactory {
    
        public Work getWork() {
            return new StudentWork();
        }
    
    }
    
    public class TeacherWorkFactory implements IWorkFactory {
    
        public Work getWork() {
            return new TeacherWork();
        }
    
    }
    
    //Test
    public class Test {
    
        public static void main(String[] args) {
            IWorkFactory studentWorkFactory = new StudentWorkFactory();
            studentWorkFactory.getWork().doWork();
            
            IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
            teacherWorkFactory.getWork().doWork();
        }
    
    }
    
    //result 
    
        学生做作业!
        老师审批作业!

#### **1.2、AbstractFactory ( 抽象工厂 )** ####

**概述**

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

**适用性**

1.一个系统要独立于它的产品的创建、组合和表示时。

2.一个系统要由多个产品系列中的一个来配置时。

3.当你要强调一系列相关的产品对象的设计以便进行联合使用时。

4.当你提供一个产品类库，而只想显示它们的接口而不是实现时。

**参与者**

**1.AbstractFactory**

声明一个创建抽象产品对象的操作接口。

**2.ConcreteFactory**

实现创建具体产品对象的操作。

**3.AbstractProduct**

为一类产品对象声明一个接口。

**4.ConcreteProduct**

定义一个将被相应的具体工厂创建的产品对象。 实现AbstractProduct接口。

**5.Client**  
仅使用由AbstractFactory和AbstractProduct类声明的接口

**类图**

**![ebd88c301e5d44fcb3555ebcade91395.png][]**

**例子**

//AbstractFactory 
    
    public interface IAnimalFactory {
    
        ICat createCat();
    	
        IDog createDog();
    }
    
    // ConcreteFactory 
    
    public class BlackAnimalFactory implements IAnimalFactory {
    
        public ICat createCat() {
            return new BlackCat();
        }
    
        public IDog createDog() {
            return new BlackDog();
        }
    
    }
    
    public class WhiteAnimalFactory implements IAnimalFactory {
    
        public ICat createCat() {
            return new WhiteCat();
        }
    
        public IDog createDog() {
            return new WhiteDog();
        }
    
    }
    
    //AbstractProduct 
    
    public interface ICat {
    
        void eat();
    }
    
    public interface IDog {
    
        void eat();
    }
    
    //ConcreteProduct 
    
    public class BlackCat implements ICat {
    
        public void eat() {
            System.out.println("The black cat is eating!");
        }
    
    }
    
    public class WhiteCat implements ICat {
    
        public void eat() {
            System.out.println("The white cat is eating!");
        }
    
    }
    
    
    public class BlackDog implements IDog {
    
        public void eat() {
            System.out.println("The black dog is eating");
        }
    
    }
    
    public class WhiteDog implements IDog {
    
        public void eat() {
            System.out.println("The white dog is eating!");
        }
    
    }
    
    //Client 
    
    public static void main(String[] args) {
        IAnimalFactory blackAnimalFactory = new BlackAnimalFactory();
        ICat blackCat = blackAnimalFactory.createCat();
        blackCat.eat();
        IDog blackDog = blackAnimalFactory.createDog();
        blackDog.eat();
        
        IAnimalFactory whiteAnimalFactory = new WhiteAnimalFactory();
        ICat whiteCat = whiteAnimalFactory.createCat();
        whiteCat.eat();
        IDog whiteDog = whiteAnimalFactory.createDog();
        whiteDog.eat();
    }
    
    //result 
    
    The black cat is eating!
    The black dog is eating!
    The white cat is eating!
    The white dog is eating!

#### 1.3 **Singleton ( 单态模式 )** ####

**概述**

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

**适用性**

1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。 2.当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

**参与者**

Singleton 定义一个Instance操作，允许客户访问它的唯一实例。Instance是一个类操作。 可能负责创建它自己的唯一实例。

**类图**

**![0fdf85da9d794942a8264291caa3f9ee.png][]**

**例子**

//Singleton 
    
    public class Singleton {
        
        private static Singleton sing;
    
        private Singleton() {
            
        }
        
        public static Singleton getInstance() {
            if (sing == null) {
                sing = new Singleton();
            }
            return sing;
        }
    }
    
    //Test 
    
    public class Test {
        
        public static void main(String[] args) {
            Singleton sing = Singleton.getInstance();
            Singleton sing2 = Singleton.getInstance();
            
            System.out.println(sing);
            System.out.println(sing2);
        }
    }
    
    //result 
    
    singleton.Singleton@1c78e57
    singleton.Singleton@1c78e57

#### **1.4 Builder ( 建造者模式 )** ####

**概述**

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

**适用性**

1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

2.当构造过程必须允许被构造的对象有不同的表示时。

**参与者**

**1.Builder**

为创建一个Product对象的各个部件指定抽象接口。

**2.ConcreteBuilder**

实现Builder的接口以构造和装配该产品的各个部件。 定义并明确它所创建的表示。 提供一个检索产品的接口。

**3.Director**

构造一个使用Builder接口的对象。

**4.Product**

表示被构造的复杂对象。ConcreteBuilder创建该产品的内部表示并定义它的装配过程。 包含定义组成部件的类，包括将这些部件装配成最终产品的接口。

**类图**

**![e44046166d434ddb80bce4d87e0001a4.png][]**

**例子**

//Builder 
    
    public interface PersonBuilder {
    
        void buildHead();
        
        void buildBody();
        
        void buildFoot();
    
        Person buildPerson();
    }
    
    //ConcreteBuilder 
    
    public class ManBuilder implements PersonBuilder {
    
        Person person;
        
        public ManBuilder() {
            person = new Man();
        }
        
        public void buildBody() {
            person.setBody("建造男人的身体");
        }
    
        public void buildFoot() {
            person.setFoot("建造男人的脚");
        }
    
        public void buildHead() {
            person.setHead("建造男人的头");
        }
    
        public Person buildPerson() {
            return person;
        }
    }
    
    //Director 
    
    public class PersonDirector {
    
        public Person constructPerson(PersonBuilder pb) {
            pb.buildHead();
            pb.buildBody();
            pb.buildFoot();
            return pb.buildPerson();
        }
    }
    
    //Product 
    
    public class Person {
    
        private String head;
        
        private String body;
        
        private String foot;
    
        public String getHead() {
            return head;
        }
    
        public void setHead(String head) {
            this.head = head;
        }
    
        public String getBody() {
            return body;
        }
    
        public void setBody(String body) {
            this.body = body;
        }
    
        public String getFoot() {
            return foot;
        }
    
        public void setFoot(String foot) {
            this.foot = foot;
        }
    }
    
    public class Man extends Person {
    
    }
    
    //Test 
    
    public class Test{
        
        public static void main(String[] args) {
            PersonDirector pd = new PersonDirector();
            Person person = pd.constructPerson(new ManBuilder());
            System.out.println(person.getBody());
            System.out.println(person.getFoot());
            System.out.println(person.getHead());
        }
    }
    
    //result 
    
    建造男人的身体
    建造男人的脚
    建造男人的头

#### **1.5、Prototype ( 原型模式 )** ####

**概述**

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

**适用性**

1.当一个系统应该独立于它的产品创建、构成和表示时。

2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。

3.为了避免创建一个与产品类层次平行的工厂类层次时。

4.当一个类的实例只能有几个不同状态组合中的一种时。

建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

**参与者**

**1. Prototype**

声明一个克隆自身的接口。

**2. ConcretePrototype**

实现一个克隆自身的操作。

**3. Client**

让一个原型克隆自身从而创建一个新的对象。

![07efbb853d3d4d1892ed800011e4a968.png][]

**例子**

//Prototype 
    
    public class Prototype implements Cloneable {
    
        private String name;
        
        public void setName(String name) {
            this.name = name;
        }
        
        public String getName() {
            return this.name;
        }
    
        public Object clone(){
            try {
                return super.clone();
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
    }
    
    
    //ConcretePrototype 
    
    public class ConcretePrototype extends Prototype {
    
        public ConcretePrototype(String name) {
            setName(name);
        }
    }
    
    //Client 
    
    public class Test {
    
        public static void main(String[] args) {
            Prototype pro = new ConcretePrototype("prototype");
            Prototype pro2 = (Prototype)pro.clone();
            System.out.println(pro.getName());
            System.out.println(pro2.getName());
        }
    }
    
    //result 
     
    prototype
    prototype

[c8581fb07500453e9240ab120161edb6.png]: https://img-blog.csdnimg.cn/c8581fb07500453e9240ab120161edb6.png
[ebd88c301e5d44fcb3555ebcade91395.png]: https://img-blog.csdnimg.cn/ebd88c301e5d44fcb3555ebcade91395.png
[0fdf85da9d794942a8264291caa3f9ee.png]: https://img-blog.csdnimg.cn/0fdf85da9d794942a8264291caa3f9ee.png
[e44046166d434ddb80bce4d87e0001a4.png]: https://img-blog.csdnimg.cn/e44046166d434ddb80bce4d87e0001a4.png
[07efbb853d3d4d1892ed800011e4a968.png]: https://img-blog.csdnimg.cn/07efbb853d3d4d1892ed800011e4a968.png