Java设计模式相关知识

1.java设计模式分类

模式	模型
创建型模式	工厂方法，抽象工厂，单列，建造者，原型
结构型模式	适配器，装饰器，代理，外观，桥接，组合，享元
行为型模式	策略，模板方法，观察者，迭代，责任链，命令...

2.设计模式遵循的6条原则

1.开闭原则

对扩展开发，对修改关闭

2.里氏替换原则

只有当衍生类可以替换掉基类，软件单位功能不受到影响时，基类才能真正复用

3.依赖倒转原则

对接口编程，依赖于抽象而不依赖于具体

4.接口隔离原则

使用多个隔离的接口来降低耦合度

5.迪米特法则（最少知道原则）

一个实体尽量少与其他实体发生相互作用。

6.合成复用原则

原则是尽量使用合成/聚合方式，而不是使用继承。

3.常用的几种设计模式

3.1单例模式

3.1.1 懒汉式写法

public class Singleton {
    private static Singleton singleton = null;
    private Singleton(){
    }
    public static Singleton getSingleton(){
        if(singleton==null){
            singleton = new Singleton();
        }
        return singleton;
    }
}

3.1.2 饿汉式写法

public class Singleton {

    //开始的时候就创建final类型的实例对象
    private static final Singleton singleton = new Singleton();
    private Singleton(){

    }
    public static Singleton getSingleton(){
        return singleton;
    }
}

 3.1.3 线程安全写法

public class Singleton {

    //用volatile 修饰变量,在多线程的环境下对象发生改变立即通知其他线程
    private static volatile Singleton singleton;
    private Singleton(){ }
    public static Singleton getSingleton(){
        if(singleton==null){
            synchronized (Singleton.class){
                if(singleton==null){
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

3.2 工厂模式

//1.先创建一个发送接口
public interface Sender {
     void send();
}

//2.创建两个实现类

public class SMSSender implements Sender{
    @Override
    public void send() {
        System.out.println(" SMSSender ");
    }
}

public class MailSender implements Sender {
    @Override
    public void send() {
        System.out.println(" sendMail ");
    }
}

3.创建一个发送工厂
public class SendFactory {

    public Sender produce(String type){
        if("mail".equals(type)){
            return new MailSender();
        }else if("sms".equals(type)){
            return new SMSSender();
        }
        return null;
    }
}

4.测试
 public static void testFactory(){
        SendFactory sendFactory = new SendFactory();
        Sender sender = sendFactory.produce("mail");
        sender.send();
 }

3.2.2 抽象工厂模式

//1.创建发送的接口    
public interface Sender {  
        public void Send();  
}  


//2.创建发送接口的实现类

public class MailSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is mailsender!");  
    }  
}

public class SmsSender implements Sender {  
    @Override  
    public void Send() {  
        System.out.println("this is sms sender!");  
    }  
}

//3.创建一个提供者的接口
public interface Provider {  
     public Sender produce();  
 } 

//4.创建连个提供者的实现类
public class SendMailFactory implements Provider {  
      
    @Override  
    public Sender produce(){  
        return new MailSender();  
    }  
}

public class SendSmsFactory implements Provider{  
  
    @Override  
    public Sender produce() {  
        return new SmsSender();  
    }  
}

//5.测试

public class Test {  
    public static void main(String[] args) {  
        Provider provider = new SendMailFactory();  
        Sender sender = provider.produce();  
        sender.Send();  
    }  
}

 3.3 Builder模式（适用于构造方法过多的对象）

public class Person {
    private String name;
    private int age;
    private String phone;
    private String city;

    private Person(Builder builder){
        this.name = builder.name;
        this.age = builder.age;
        this.phone = builder.phone;
        this.city =builder.city;

    }
    
    public static class Builder{
        private String name;
        private int age;
        private String phone;
        private String city;

        //构建时必须要传的参数,
        public Builder(String name,int age){
            this.name = name;
            this.age = age;
        }

        public Builder phone(String phone){
            this.phone = phone;
            return this;
        }

        public Builder city(String city){
            this.city = city;
            return this;
        }

        public Person builder(){
            return new Person(this);
        }

    }


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", phone='" + phone + '\'' +
                ", city='" + city + '\'' +
                '}';
    }

    public static void testBuilder(){
        Person person = new Person.Builder("张三",25).city("北京").builder();
        System.out.println(person.toString());
    }