设计模式

最新推荐文章于 2025-02-10 18:50:48 发布

江雪中的簔笠儿

最新推荐文章于 2025-02-10 18:50:48 发布

阅读量224

点赞数

CC 4.0 BY-SA版权

文章标签： java基础

本文链接：https://blog.youkuaiyun.com/luoran415610/article/details/77138608

Java设计模式的六大原则：

１、开闭原则：对扩展开放，对修改关闭。程序在扩展功能的时候，不能修改原有代码，实现一种热插拔效果。查看更多

２、里氏代换原则：任何基类出现的地方，子类一定可以出现。即子类可以扩展父类的功能，但不能修改父类的功能。查看更多

３、依赖倒转原则：核心思想是面向接口编程，依赖于抽象而不依赖于具体。查看更多

４、接口隔离原则：使用多个隔离的接口，比使用单个接口要好。防止实现不必要的方法。查看更多

５、迪米特法则：一个对象应该对另一个对象保持最少的了解。查看更多

６、单一职责原则：一个类只负责一项职责。查看更多

一、单例模式

是一种创建型模式。一个类只能创建一个实例，可以节约内存空间。分为饿汉式和懒汉式两种。饿汉式在类加载的时候就实例化对象，懒汉式在调用方法的时候实例化对象。由于饿汉式和懒汉式单例构造方法是私有的，因此单例是不可继承的。

适用场景：

1、需要频繁实例化然后销毁的对象。

2、创建对象时耗时过多或者耗费资源过多，但又频繁使用的对象，比如创建SqlSessionFactory对象的时候。

在多个类加载器以及序列化、反序列化时，会产生多个单例。、

二、工厂模式

包含以下三种形态：简单工厂模式、工厂方法模式、抽象工厂模式

１、简单工厂模式：工厂类根据传递给它的参数，创建类的实例。

２、工厂方法模式：与简单工厂模式的不同之处在于，定义一个工厂接口，将创建实例的工作推迟到工厂类的实现类中。

interface IFactory {

public ICar createCar();

}

class Factory implements IFactory {

public ICar createCar() {

Engine engine = new Engine();

Underpan underpan = new Underpan();

Wheel wheel = new Wheel();

ICar car = new Car(underpan, wheel, engine);

return car;

}

public class Client {

public static void main(String[] args) {

IFactory factory = new Factory();

ICar car = factory.createCar();

car.show();

}

３、抽象工厂模式：定义不同的产品接口，这些接口的实现类代表具体的产品。同时定义生产这些产品的工厂接口，工厂接口的实现类提供具体的生产方式。

interface IProduct1 {

public void show();

}

interface IProduct2 {

public void show();

}

class Product1 implements IProduct1 {

public void show() {

System.out.println("这是1型产品");

}

class Product2 implements IProduct2 {

public void show() {

System.out.println("这是2型产品");

}

interface IFactory {

public IProduct1 createProduct1();

public IProduct2 createProduct2();

}

class Factory implements IFactory{

public IProduct1 createProduct1() {

return new Product1();

}

public IProduct2 createProduct2() {

return new Product2();

}

public class Client {

public static void main(String[] args){

IFactory factory = new Factory();

factory.createProduct1().show();

factory.createProduct2().show();

}

三、模板方法模式

定义一个抽象父类，提供多个子类的通用方法，并把一个或者多个方法留给其子类实现（实现的是抽象方法，模板方法只能继承，不能重写）。

四、适配器模式

把一个类的接口转换成客户端所期望的另一种接口，使得原本因接口不匹配而无法一起工作的两个类能够一起工作。

类适配器模式

[java]view plaincopy
print?
// 已存在的、具有特殊功能、但不符合我们既有的标准接口的类   
class Adaptee {   
    public void specificRequest() {   
        System.out.println("被适配类具有特殊功能...");   
    }   
}   

[java]view plaincopy
print?
// 目标接口，或称为标准接口   
interface Target {   
    public void request();   
}   

[java]view plaincopy
print?
// 具体目标类，只提供普通功能   
class ConcreteTarget implements Target {   
    public void request() {   
        System.out.println("普通类 具有 普通功能...");   
    }   
}   

[java]view plaincopy
print?
// 适配器类，继承了被适配类，同时实现标准接口   
class Adapter extends Adaptee implements Target{   
    public void request() {   
        super.specificRequest();   
    }   
}  

[java]view plaincopy
print?
// 测试类  
public class Client {   
public static void main(String[] args) {   
        // 使用普通功能类   
        Target concreteTarget = new ConcreteTarget();   
        concreteTarget.request();   
           
        // 使用特殊功能类，即适配类   
        Target adapter = new Adapter();   
        adapter.request();   
    }   
}   

对象适配器模式

[java]view plaincopy
print?
// 适配器类，直接关联被适配类，同时实现标准接口   
class Adapter implements Target{   
    // 直接关联被适配类   
    private Adaptee adaptee;   
       
    // 可以通过构造函数传入具体需要适配的被适配类对象   
    public Adapter (Adaptee adaptee) {   
        this.adaptee = adaptee;   
    }   
       
    public void request() {   
        // 这里是使用委托的方式完成特殊功能   
        this.adaptee.specificRequest();   
    }   
}  

[html]view plaincopy
print?
// 测试类   
public class Client {   
    public static void main(String[] args) {   
        // 使用普通功能类   
        Target concreteTarget = new ConcreteTarget();   
        concreteTarget.request();   
           
        // 使用特殊功能类，即适配器类   
        // 需要先创建一个被适配类的对象作为参数   
        Target adapter = new Adapter(new Adaptee());   
        adapter.request();   
    }   
}   

五、命令模式

一个方法需要实现某项功能，但这个功能必须等到执行该方法时才可以确定，这时可以定义一个命令接口，并把该接口作为方法的形参，这样就可以根据不同的接口实现完成相应的功能。

这里写图片描述

六、观察者模式

 abstract class Subject {
        private Vector obs = new Vector();

        public void addObserver(Observer obs){
            this.obs.add(obs);
        }
        public void delObserver(Observer obs){
            this.obs.remove(obs);
        }
        protected void notifyObserver(){
            for(Observer o: obs){
                o.update();
            }
        }
        public abstract void doSomething();
    }

    class ConcreteSubject extends Subject {
        public void doSomething(){
            System.out.println("被观察者事件反生");
            this.notifyObserver();
        }
    }
    interface Observer {
        public void update();
    }
    class ConcreteObserver1 implements Observer {
        public void update() {
            System.out.println("观察者1收到信息，并进行处理。");
        }
    }
    class ConcreteObserver2 implements Observer {
        public void update() {
            System.out.println("观察者2收到信息，并进行处理。");
        }
    }

    public class Client {
        public static void main(String[] args){
            Subject sub = new ConcreteSubject();
            sub.addObserver(new ConcreteObserver1()); //添加观察者1
            sub.addObserver(new ConcreteObserver2()); //添加观察者2
            sub.doSomething();
        }
    }

运行结果：

被观察者事件反生

观察者1收到信息，并进行处理。

观察者2收到信息，并进行处理。