23种设计模式（java代码实现案例）

最新推荐文章于 2024-06-21 10:17:59 发布

羊羊羊的能量站

最新推荐文章于 2024-06-21 10:17:59 发布

阅读量2.3k

点赞数 2

文章标签： java 设计模式开发语言

本文链接：https://blog.csdn.net/m0_55651862/article/details/127283962

版权

设计模式

创造型、结构型、行为型

创建型：

1、（类）工厂方法（Factory Method）

意图

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

适用性

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

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

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

实现代码

package com.yhw.factoryPattern;
//工厂方法模式
public class FactoryMethod {
   
    public static void main(String[] args){
   
    Factory factoryA = new FactoryA();
    //类名 对象名 = new 子类（）；
    Factory factoryB = new FactoryB();

    Product productA = factoryA.createProduct();
    productA.info();

    Product productB = factoryB.createProduct();
    productB.info();
    }
}
interface Factory {
   

    public Product createProduct();
}

class FactoryA implements Factory{
   
    public Product createProduct(){
   
        return new ProductA();
    }
}

class FactoryB implements Factory{
   

     @Override
     public Product createProduct() {
   
         return new ProductB();
     }
 }

 interface Product{
   
    public void info();
}

class ProductA implements Product{
   
    public void info(){
   
        System.out.println("商品信息：A");
    }
}

class ProductB implements Product{
   

    @Override
    public void info(){
   
        System.out.println("商品信息：B");
    }
}

简单工厂模式实现代码

package com.yhw.simpleFactory;
//简单工厂模式
public class SimpleFactory {
   
    public static void main(String[] args) {
   
       Product productA = Factory.CreateProduct("A");
       Product productB = Factory.CreateProduct("B");
       productA.info();
       productB.info();
    }
}
    class Factory {
   
        public static Product CreateProduct(String type){
   
            Product product = null;
            switch(type){
   
                case "A":
                    product = new ProductA();
                    break;
                case "B":
                    product = new ProductB();
                    break;
                default:
                    System.out.println("本店没有此类产品");
            }
            return product;
        }
    }
    abstract class Product{
   
        public abstract void info();
    }

    class ProductA extends Product{
   

        @Override
        public void info() {
   
            System.out.println("产品信息为：A");
        }
    }
    class ProductB extends Product{
   

        @Override
        public void info() {
   
            System.out.println("产品信息为：B");
        }
    }

2、抽象工厂（Abstract Factory）

意图

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

适用性

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

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

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

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

实现代码

package com.yhw.AbstractFactory;

public class Factory {
   

    public static void main (String[] args ){
   

        abstractFactory Factory1 = new Factory1();
        abstractFactory Factory2 = new Factory2();

        ProductA productA = Factory1.CreateProductA();
        productA.info();
        ProductB productB = Factory1.CreateProductB();
        productB.info();

    }
}//抽象工厂模式
interface abstractFactory{
   
    public ProductA CreateProductA();
    public ProductB CreateProductB();
}

class Factory1 implements abstractFactory{
   

    @Override
    public ProductA CreateProductA() {
   
        return new ProductA1();
    }

    @Override
    public ProductB CreateProductB() {
   
        return new ProductB1();
    }
}
class Factory2 implements abstractFactory{
   

    @Override
    public ProductA CreateProductA() {
   
        return new ProductA2();
    }

    @Override
    public ProductB CreateProductB() {
   
        return new ProductB2();
    }
}

interface ProductA{
   
    public void info();
}
class ProductA1 implements ProductA{
   

    @Override
    public void info() {
   
        System.out.println("产品信息：A2");
    }
}
class ProductA2 implements ProductA{
   

    @Override
    public void info() {
   
        System.out.println("产品信息：A2");
    }
}
interface ProductB{
   
    public void info();
}
class ProductB1 implements ProductB{
   
    @Override
    public void info() {
   
        System.out.println("产品信息：B1");
    }
}
class ProductB2 implements ProductB{
   

    @Override
    public void info() {
   
        System.out.println("产品信息：B2");
    }
}

3、生成器（Builder）

意图

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

适用性

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

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

实现代码

package com.yhw.builder;
//生成器模式
public class Builder {
   
    public static void main(String[] args) {
   
        Waiter waiter = new Waiter();
        PizzaBuilder hawaiian_pizzaBuilder = new HawaiianPizzaBuilder();
        waiter.setPizzaBuilder(hawaiian_pizzaBuilder);
        waiter.construct();

        System.out.println("pizza："+waiter.getPizza());

        PizzaBuilder spicy_pizzaBuilder = new SpicyPizzaBuilder();
        waiter.setPizzaBuilder(spicy_pizzaBuilder);
        waiter.construct();

        System.out.println("pizza："+waiter.getPizza());
    }
}

class Pizza{
   
    private String parts;
    public void setParts(String parts){
   this.parts = parts;}
    public String toString(){
   return this.parts;}
}

abstract class PizzaBuilder{
   
    protected Pizza pizza;
    public Pizza getPizza(){
   return pizza;}
    public void createNewPizza(){
   pizza = new Pizza();}

    public abstract void buildParts();
}
class HawaiianPizzaBuilder extends PizzaBuilder{
   
    public void buildParts(){
   pizza.setParts("cross + mild + ham&pineapple");}
}
class SpicyPizzaBuilder extends PizzaBuilder{
   
    public void buildParts(){
   pizza.setParts("panbaked + hot + pepperoni&salami");}
}
class Waiter{
   
    private PizzaBuilder pizzaBuilder;
    public void setPizzaBuilder(PizzaBuilder pizzaBuilder){
   //设置构建器
        this.pizzaBuilder = pizzaBuilder;
    }
    public Pizza getPizza(){
   return pizzaBuilder.getPizza();}
    public void construct(){
   //生成pizza
        pizzaBuilder.createNewPizza();
        pizzaBuilder.buildParts();
    }

}

4、原型（Prototype）

意图

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

适用性

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

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

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

4.当一个类的实例化只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便

实现代码

package com.yhw.prototype;
//原型模式
public class Prototype {
   
    public static void main(String[] args) {
   
        Resume a = new Resume("张三");
        a.SetPersonInfo("男","29");
        a.SetWorkExperience("1999 - 2006","xxx");
        Resume b = (Resume) a.Clone();
//        b.SetWorkExperience("2006 - 2010","yyy");

        System.out.println(a.getWork().getWorkDate()+" "+a.getWork().getCompany());
        System.out.println(b.getWork().getWorkDate()+" "+b.getWork().getCompany());

    }
}
interface Cloneable{
   
    Object Clone ();
}
class WorkExperience implements Cloneable{
   
    private String workDate;
    private String company;

   void SetWorkDate (String workDate){
   this.workDate = workDate;}
   void SetCompany (String company){
   this.company = company;}

    public String getWorkDate() {
   
        return workDate;
    }

    public String getCompany() {
   
        return company;
    }

    @Override
    public Object Clone(){
   
        WorkExperience obj = new WorkExperience();
        obj.company = this.company;
        obj.workDate = this.workDate;
        return obj;
    }
}
class Resume implements Cloneable{
   
    private String name;
    private String sex;
    private String age;
    private WorkExperience work;

    public WorkExperience getWork() {
   
        return work;
    }

    public Resume(String name) {
   
        this.name = name;
        work = new WorkExperience();
    }
    private Resume(WorkExperience work){
   
        this.work = (WorkExperience) work.Clone();
    }

    public void SetPersonInfo(String sex,String age){
   
        this.sex = sex;
        this.age = age;
    }

    public void SetWorkExperience(String workDate , String company){
   
        this.work.SetWorkDate(workDate);
        this.work.SetCompany(company);
    }

    public Object Clone(){
   
        Resume obj = new Resume(this.work);
        return obj;
    }
}

5、单例（Singleton）

意图

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

适用性

1.当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时

2.当这个唯一实例应该时通过子类化可扩展的，并且客户无须更改代码就能使用一个扩展的实例时

实现代码

package com.yhw.singletonPattern;
//单例模式
public class SingletonPattern {
   
    public static void main (String[] args){
   
        Singleton instance = Singleton.getInstance();
        instance.setNumber(2022);
        System.out.println(instance.getNumber());
    }
}
class Singleton{
   
    private int number ;

    public void setNumber(int number) {
   
        this.number = number;
    }

    public int getNumber() {
   
        return number;
    }

    private static Singleton instance = new Singleton();
    private Singleton(){
   }

    public static Singleton getInstance(){
   
        return instance;
    }
}

结构型

1、适配器（Adapter）

意图

将一个类的接口转换成客户希望的另外一个接口。使得原本由于接口不兼容而不能一起工作的那些类可以一起工作

适用性

1.想使用一个已经存在的类，而它的接口不符合要求

2.想创建一个可以服用的类，该类可以与其他不相关的类或者不可预见的类（即那些接口可能不一定兼容的类）协同工作

3.想使用一个已经存在的子类，但是不可能对每一个都进行子类化以匹配他们的接口。对象适配器可以适配它的父类接口

实现代码

package com.yhw.adapterPattern;
//适配器模式
public class AdapterPattern {
   
    public static void main (String[] args){
   
        USB usb = new Adapter();
        usb.Request();
    }
}

class USB {
   
    public void Request(){
   
        System.out.println("USB数据线");
    }
}
class Adapter extends USB{
   
    private TypeC typeC = new TypeC();
    @Override
    public void Request() {
   
        typeC.SpecificRequest();
    }
}

class TypeC{
   
    public void SpecificRequest(){
   
        System.out.println("Tape-C数据线");
    }
}

2、桥接（Bridge）

意图

将抽象部分与其实现部分分离，使它们都可以独立变化

适用性

1.不希望在抽象和它的实现部分之间有一个固定的关系

2.类的抽象以及它的实现都应该可以通过生成子类的方法加以扩充

3.对一个抽象的实现部分修改应对客户不产生影响，即客户代码不必重新编译

4.有许多类要生成的类层次结构

实现代码

最低0.47元/天解锁文章

羊羊羊的能量站

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
1
评论
23种设计模式（java代码实现案例）

23种设计模式（java代码实现案例）
复制链接

扫一扫

23种设计模式（java代码实现案例）

设计模式

创建型：

1、（类）工厂方法（Factory Method）

意图

适用性

实现代码

2、抽象工厂（Abstract Factory）

意图

适用性

实现代码

3、生成器（Builder）

意图

适用性

实现代码

4、原型（Prototype）

意图

适用性

实现代码

5、单例（Singleton）

意图

适用性

实现代码

结构型

1、适配器（Adapter）

意图

适用性

实现代码

2、桥接（Bridge）

意图

适用性

实现代码

“相关推荐”对你有帮助么？