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

简介: 其中创建型模式分为: FactoryMethod ( 工厂方法 )、AbstractFactory ( 抽象工厂 )、Singleton ( 单态模式 )、Builder ( 建造者模式 )、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实例。

2345_image_file_copy_389.jpg

例子

// 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类声明的接口

类图

2345_image_file_copy_390.jpg

例子

//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是一个类操作。 可能负责创建它自己的唯一实例。

类图

2345_image_file_copy_391.jpg

例子

//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创建该产品的内部表示并定义它的装配过程。 包含定义组成部件的类,包括将这些部件装配成最终产品的接口。

类图

2345_image_file_copy_392.jpg

例子

//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

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

2345_image_file_copy_393.jpg

例子

//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

目录
相关文章
|
2月前
|
设计模式 Java 程序员
[Java]23种设计模式
本文介绍了设计模式的概念及其七大原则,强调了设计模式在提高代码重用性、可读性、可扩展性和可靠性方面的作用。文章还简要概述了23种设计模式,并提供了进一步学习的资源链接。
46 0
[Java]23种设计模式
|
16天前
|
设计模式 JavaScript Java
Java设计模式:建造者模式详解
建造者模式是一种创建型设计模式,通过将复杂对象的构建过程与表示分离,使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo,帮助读者更好地理解和应用这一模式。
|
2月前
|
设计模式 监控 算法
Java设计模式梳理:行为型模式(策略,观察者等)
本文详细介绍了Java设计模式中的行为型模式,包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码,深入浅出地讲解了每种模式的应用场景与实现方式。例如,策略模式通过定义一系列算法让客户端在运行时选择所需算法;观察者模式则让多个观察者对象同时监听某一个主题对象,实现松耦合的消息传递机制。此外,还探讨了这些模式与实际开发中的联系,帮助读者更好地理解和应用设计模式,提升代码质量。
Java设计模式梳理:行为型模式(策略,观察者等)
|
3月前
|
存储 设计模式 安全
Java设计模式-备忘录模式(23)
Java设计模式-备忘录模式(23)
|
3月前
|
设计模式 存储 缓存
Java设计模式 - 解释器模式(24)
Java设计模式 - 解释器模式(24)
|
2月前
|
设计模式 Java
Java设计模式
Java设计模式
30 0
|
2月前
|
设计模式 Java
Java设计模式之外观模式
这篇文章详细解释了Java设计模式之外观模式的原理及其应用场景,并通过具体代码示例展示了如何通过外观模式简化子系统的使用。
30 0
|
2月前
|
设计模式 Java
Java设计模式之桥接模式
这篇文章介绍了Java设计模式中的桥接模式,包括桥接模式的目的、实现方式,并通过具体代码示例展示了如何分离抽象与实现,使得两者可以独立变化。
44 0
|
2月前
|
设计模式 Java
Java设计模式之适配器模式
这篇文章详细讲解了Java设计模式中的适配器模式,包括其应用场景、实现方式及代码示例。
46 0
|
3月前
|
设计模式 缓存 算法
Java设计模式-访问者模式(22)
Java设计模式-访问者模式(22)

热门文章

最新文章

  • 1
    设计模式转型:从传统同步到Python协程异步编程的实践与思考
    54
  • 2
    C++一分钟之-设计模式:工厂模式与抽象工厂
    46
  • 3
    《手把手教你》系列基础篇(九十四)-java+ selenium自动化测试-框架设计基础-POM设计模式实现-下篇(详解教程)
    52
  • 4
    C++一分钟之-C++中的设计模式:单例模式
    62
  • 5
    《手把手教你》系列基础篇(九十三)-java+ selenium自动化测试-框架设计基础-POM设计模式实现-上篇(详解教程)
    41
  • 6
    《手把手教你》系列基础篇(九十二)-java+ selenium自动化测试-框架设计基础-POM设计模式简介(详解教程)
    65
  • 7
    Java面试题:结合设计模式与并发工具包实现高效缓存;多线程与内存管理优化实践;并发框架与设计模式在复杂系统中的应用
    60
  • 8
    Java面试题:设计模式在并发编程中的创新应用,Java内存管理与多线程工具类的综合应用,Java并发工具包与并发框架的创新应用
    42
  • 9
    Java面试题:如何使用设计模式优化多线程环境下的资源管理?Java内存模型与并发工具类的协同工作,描述ForkJoinPool的工作机制,并解释其在并行计算中的优势。如何根据任务特性调整线程池参数
    51
  • 10
    Java面试题:请列举三种常用的设计模式,并分别给出在Java中的应用场景?请分析Java内存管理中的主要问题,并提出相应的优化策略?请简述Java多线程编程中的常见问题,并给出解决方案
    114
  • 下一篇
    无影云桌面