java 的23中设计模式

50 阅读 0 评论 33 点赞

我是靠谱客的博主英俊小海豚，最近开发中收集的这篇文章主要介绍java 的23中设计模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

java23中设计模式分为三类 1.创建型模式 2.结构型模式 3.行为型模式

创建型模式主要工厂方法模式，抽象工厂模式，单例模式，建造者模式，原型模式。
结构型模式主要有适配器模式，装饰器模式，代理模式，外观模式，桥接模式，组合模式，享元模式。
行为型模式主要有策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
1.工厂方法模式又称为静态工厂模式一般采用static修饰通过类名.方法名调用
2.抽象工厂模式一个基础接口定义了功能，每个实现接口的子类就是产品，然后定义一个工厂接口，实现了工厂接口的就是工厂，这时候，接口编程的优点就出现了，我们可以新增产品类（只需要实现产品接口），只需要同时新增一个工厂类，客户端就可以轻松调用新产品的代码。
　　抽象工厂的灵活性就体现在这里，无需改动原有的代码，毕竟对于客户端来说，静态工厂模式在不改动StaticFactory类的代码时无法新增产品，如果采用了抽象工厂模式，就可以轻松的新增拓展类。

    interface food{}

class A implements food{}
class B implements food{}

interface produce{ food get();}

class FactoryForA implements produce{
    @Override
    public food get() {
        return new A();
    }
}
class FactoryForB implements produce{
    @Override
    public food get() {
        return new B();
    }
}
public class AbstractFactory {
    public void ClientCode(String name){
        food x= new FactoryForA().get();
        x = new FactoryForB().get();
    }
}

3.单例模式
私有化构造方法、私有化并实例化静态对象、提供一个可以对外访问公共方法。
4.建造者模式采用构建器使用构建器作为参数来构建对象
在了解之前，先假设有一个问题，我们需要创建一个学生对象，属性有name,number,class,sex,age,school等属性，如果每一个属性都可以为空，也就是说我们可以只用一个name,也可以用一个school,name,或者一个class,number，或者其他任意的赋值来创建一个学生对象，这时该怎么构造？
难道我们写6个1个输入的构造函数，15个2个输入的构造函数…吗？这个时候就需要用到Builder模式了。给个例子，大家肯定一看就懂：

       public class Builder {

    static class Student{
        String name = null ;
        int number = -1 ;
        String sex = null ;
        int age = -1 ;
        String school = null ;

　　　　　//构建器，利用构建器作为参数来构建Student对象
        static class StudentBuilder{
            String name = null ;
            int number = -1 ;
            String sex = null ;
            int age = -1 ;
            String school = null ;
            public StudentBuilder setName(String name) {
                this.name = name;
                return  this ;
            }

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

            public StudentBuilder setSex(String sex) {
                this.sex = sex;
                return  this ;
            }

            public StudentBuilder setAge(int age) {
                this.age = age;
                return  this ;
            }

            public StudentBuilder setSchool(String school) {
                this.school = school;
                return  this ;
            }
            public Student build() {
                return new Student(this);
            }
        }

        public Student(StudentBuilder builder){
            this.age = builder.age;
            this.name = builder.name;
            this.number = builder.number;
            this.school = builder.school ;
            this.sex = builder.sex ;
        }
    }

    public static void main( String[] args ){
        Student a = new Student.StudentBuilder().setAge(13).setName("LiHua").build();
        Student b = new Student.StudentBuilder().setSchool("sc").setSex("Male").setName("ZhangSan").build();
    }
}

原型模式原型模式就是讲一个对象作为原型，使用clone()方法来创建新的实例。clone ()复制分为浅拷贝和深拷贝
浅拷贝就是只复制实力对象不复制引用对象引用对象还是指向原有的对象
深拷贝就是把所有的对象都复制一遍包括（实力对象和引用对象）

public class Prototype implements Cloneable{

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone()   {
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }finally {
            return null;
        }
    }

    public static void main ( String[] args){
        Prototype pro = new Prototype();
        Prototype pro1 = (Prototype)pro.clone();
    }
}

适配器模式的作用就是在原来的类上提供新功能。主要可分为3种：

类适配：创建新类，继承源类，并实现新接口，例如
class adapter extends oldClass implements newFunc{}
对象适配：创建新类持源类的实例，并实现新接口，例如
class adapter implements newFunc { private oldClass oldInstance ;}
接口适配：创建新的抽象类实现旧接口方法。例如
abstract class adapter implements oldClassFunc { void newFunc();}

.装饰模式（Decorator）
给一类对象增加新的功能，装饰方法与具体的内部逻辑无关。例如：

     interface Source{ void method();}
public class Decorator implements Source{

    private Source source ;
    public void decotate1(){
        System.out.println("decorate");
    }
    @Override
    public void method() {
        decotate1();
        source.method();
    }
}

外观模式（Facade）
为子系统中的一组接口提供一个一致的界面，定义一个高层接口，这个接口使得这一子系统更加容易使用。这句话是百度百科的解释，有点难懂，但是没事，看下面的例子，我们在启动停止所有子系统的时候，为它们设计一个外观类，这样就可以实现统一的接口，这样即使有新增的子系统subSystem4,也可以在不修改客户端代码的情况下轻松完成。

     public class Facade {
    private subSystem1 subSystem1 = new subSystem1();
    private subSystem2 subSystem2 = new subSystem2();
    private subSystem3 subSystem3 = new subSystem3();
    
    public void startSystem(){
        subSystem1.start();
        subSystem2.start();
        subSystem3.start();
    }
    
    public void stopSystem(){
        subSystem1.stop();
        subSystem2.stop();
        subSystem3.stop();
    }
}

权限 https://blog.csdn.net/weixin_39723352/article/details/80866893