Java开发中常用的设计模式汇总！！！

努力的晓颀

已于 2022-10-18 18:11:17 修改

阅读量650

点赞数

文章标签： java 设计模式单例模式

于 2022-10-18 18:03:10 首次发布

本文链接：https://blog.csdn.net/m0_61296341/article/details/127359282

版权

单例模式

就是一个应用程序中，某个类的实例对象只有一个，不能被new，因为它被private修饰，一般通过getInstance()方法来获取它的实例

而getInstance()方法返回的是对象的引用，并不是一个新的实例，不要理解成多个对象

例：

懒汉式写法(线程不安全)

public class Single{
    private static Single single;
    private Single(){}
    public static Single getInstance(){
    if(single == null){
        single = new Single();
    }
    return single;
    }
}

懒汉式写法(线程安全)

public class Single{
    private static Single single;
    private Single(){}
    public static synchronized Single getInstance(){
    if(single == null){
        single = new Single();
    }
    return single;
    }
}

饿汉式写法

public class Single{
    private static Single single = new Single;
    private Single(){}
    public static Single getInstance(){
        return single;
    }
}

静态内部类

public class Single{
    private static class SingleTest(){
        private static final Single SINGLE = new Single(); 
    }
    private Single(){}
    public static final Single getInstance(){
        return SingleTest.SINGLE;
    }
}

工厂模式

实例化对象不用new，用工厂方法替代，创建对象时统一管理和控制。

简单工厂模式

用来生产同一等级架构中的任意产品（如需增加新的产品需要修改已有代码）

在该模式下，可以根据参数不同返回不同的实例，专门定义一个类来创建其它类的实例

//创建水果接口
public interface Fruit{
    void name();
}

//创建苹果实现类
public class Apple implements Fruit{
    @Override
    public void name() {
        System.out.println("苹果");
    }
}

//创建香蕉实现类
public class Banana implements Fruit{
    @Override
    public void name() {
        System.out.println("香蕉");
    }
}

//创建水果工厂
public class FruitFactory(){
    public static Fruit getFactory(String fruit){
        if(fruit.equals("苹果")){
            retrun new Apple();
        }else if(fruit.equals("香蕉")){
            retrun new Banana();
        }else{
            retrun null;
        }
    }
}

//测试类
public class Test(){
    public static void main(String[] args){
        Fruit f1 = FruitFactory.getFactory("苹果");
        Fruit f2 = FruitFactory.getFactory("香蕉");
        f1.name();
        f2.name();
    }
}

工厂方法模式

用来生产同一等级架构中的固定产品，一个工厂等级架构可以负责多个不同等级架构中产品对象的创建

//创建水果接口
public interface Fruit{
    void name();
}

//创建苹果实现类
public class Apple implements Fruit{
    @Override
    public void name() {
        System.out.println("苹果");
    }
}

//创建水果工厂接口
public interface FruitFactory(){
    Fruit getFruti();
}

//创建苹果工厂
public class AppleFactroy implements FruitFactory{
    @Override
    public Fruit getFruti() {
        retrun new Apple();
    }
}

//测试类
public class Test(){
    public static void main(String[] args){
        Fruit f1 = new AppleFactroy.getFruti();
        f1.name();
    }
}

抽象工厂模式

提供了一个可以创建一系列相关依赖对象的接口，无需指定具体的类，与工厂方法模式不同，它可以生产多个产品

//抽象工厂类
public abstract class AbstractFactory {
   public abstract Apple createApple();
   public abstract Banana createBanana();
   public abstract Orange createOrange();
}

//具体工厂类，其中Apple,Banana,Orange是抽象类，
public class FruitFactory extends AbstractFactory{
   @Override
   public Apple createApple() {
       return new Apple();
   }
   @Override
   public Banana createBanana() {
       return new Banana();
   }
   @Override
   public Orange createOrange() {
       return new Orange();
   }
}

//测试类
public class Test {
   public static void main(String[] args) {
       FruitFactory f = new FruitFactory();
       Apple a = f.createApple();
       a.a();
       Banana b = f.createBanana();
       b.b();
       Orange o = f.createOrange();
       o.o();
   }
}

代理模式

给某一个对象提供一个代理用来控制该对象的访问。访问对象时，不能直接引用对象目标，代理对象可作为目标对象和代理对象的中介

静态代理模式

虽然可以解决开闭原则但现在只是固定的功能，如果想要增加业务或有一个新的真实角色，需增加新的代理，会增加代码量，导致开发效率低。这个时候就可以用动态代理模式来解决这个问题

//租房
public interface Rent {
    void rent();
}

//房东
public class Master implements Rent{
    @Override
    public void rent() {
        System.out.println("Master rent");
    }
}

//中介
public class Proxy implements Rent{

    private Master master;
 
    public Proxy() {}
 
    public Proxy(Master master) {
        this.master = master;
    }
 
    @Override
    public void rent() {
        see();
        master.rent();
    }

    //看房
    public void look(){
        System.out.println("look");
    }
}
//测试类
public class Consumer {
    public static void main(String[] args) {
        Master master = new Master();
        //进行代理
        Proxy proxy = new Proxy(master);
        //不需要通过对象，直接通过代理完成响应业务
        proxy.rent();
    }
}

动态代理模式

如果想要增加其它功能的话，就可以直接在模板中添加，方便很多。

//接口
public interface IUserService {
    void add();
    void delete();
    void update();
    void query();
 
}
//实现类
public class UserServiceImpl implements IUserService {
    @Override
    public void add() {
        System.out.println("add");
    }
 
    @Override
    public void delete() {
        System.out.println("delete");
    }
 
    @Override
    public void update() {
        System.out.println("update");
    }
 
    @Override
    public void query() {
        System.out.println("query");
    }
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//自动生成动态代理类模板
public class ProxyInvocationHandler implements InvocationHandler {
    //被代理接口
    private Object target;
   
    public void setTarget(Object target) {
        this.target = target;
    }
     //得到代理类
    public Object getProxy() {
        return Proxy.newProxyInstance(getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
    public void log(String s) {
        System.out.println("[debug]:" + s);
    }
    //得到代理类
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }
}
//测试类
public class Consumer {
    public static void main(String[] args) {
        UserServiceImpl userService = new UserServiceImpl();
        ProxyInvocationHandler handler = new ProxyInvocationHandler();
        //设置代理对象
        handler.setTarget(userService);
        //生成代理类
        IUserService proxy = (IUserService)handler.getProxy();
        proxy.add();
        proxy.query();
    }
}