Java中常见的设计模式_java设计模式

目录

一、什么是设计模式 

二、设计模式的类型

        1、创建型模式

        2、结构型模式

        3、行为型模式

三、单例模式

        1、代码示例

        2、优点

        3、缺点

        4、使用场景

四、工厂模式

        1、代码示例

        2、优点

        3、缺点

五、装饰模式

        1、代码示例

        2、优点

        3、缺点

六、代理模式

        1、代码示例

        2、优点

        3、缺点

七、观察者模式

        1、代码示例

        2、优点

        3、缺点

八、尾注

一、什么是设计模式 

public class UserMassage {
    //创建静态对象
    public static UserMassage umsg = new UserMassage();
    //对外部提供一个公共的访问方法
    public static UserMassage getUserMassage(){
        return umsg;
    }
    //一个普通方法
    public void show(){
        System.out.println("我是单例模式");
    }
 
    //测试
   public static void main(String[] args) {
        UserMassage msg1 = UserMassage.getUserMassage();
        msg1.show();
        UserMassage msg2 = UserMassage.getUserMassage();
        msg2.show();
        System.out.println(msg1.equals(msg2));
        //输出结果为true 表示只创建了一次对象
    }
}

//面条接口类  MianTiao.java
public interface MianTiao {
    //面条描述
    public abstract void desc();
}
 
 
//兰州拉面类实现面条接口类  LzNoodles.java
public class LzNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是兰州拉面");
    }
}
 
 
//泡面类实现面条接口类  PaoNoodles.java
public class PaoNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是泡面");
    }
}
 
//烩面类实现面条接口类  HuiNoodles.java
public class HuiNoodles implements MianTiao {
    public void desc() {
        System.out.println("这是烩面");
    }
}

//面馆工厂类 SimpleNoodlesFactory.java
public class SimpleNoodlesFactory {
    public static final int TYPE_LZ = 1;//兰州拉面
    public static final int TYPE_PM = 2;//泡面
    public static final int TYPE_HM = 3;//烩面
 
    //根据用户的选择 创建不同的面
    public static MianTiao createNoodles(int type) {
        switch (type) {
            case TYPE_LZ:
                return new LzNoodles();
            case TYPE_PM:
                return new PaoNoodles();
            case TYPE_HM:
            default:
                return new HuiNoodles();
        }
    }
 
    //测试
    public static void main(String[] args) {
        //调用面馆工厂,传入需要生产面
        MianTiao mian = SimpleNoodlesFactory.createNoodles(SimpleNoodlesFactory.TYPE_HM);
        mian.desc();
    }
}

//展示自己的接口类 Showable.java
public interface Showable {
     //定义展示行为
	public abstract void show();
}
 
//女友类实现展示自己的接口类 Girl.java
public class Girl implements Showable {
	public void show() {
		System.out.print("女友的素颜");
	} 
}
 
//抽象装饰器类 Decorator.java
public abstract class Decorator implements Showable{
    //持有一个善于展示自己某个家伙
	Showable showable;
    //构造时注入这个家伙
	public Decorator(Showable showable){
		this.showable = showable; 
	}
    //无须实现
	public abstract void show();
}
 
//描眉类继承装饰器类 MiaoMei.java
public class MiaoMei extends Decorator{
	public MiaoMei(Showable showable) {
		super(showable);
	}
    //重写接口化妆后展示
	public void show(){
		System.out.print("描眉(");
		showable.show();
		System.out.print(")");
	}
}
 
//涂口红继承装饰器类 TuKouHong.java
public class TuKouHong extends Decorator{
	public MiaoMei(Showable showable) {
		super(showable);
	}
    //重写接口化妆后展示
	public void show(){
		System.out.print("涂口红(");
		showable.show();
		System.out.print(")");
	}
}

//测试类 Main.java
public class Main {
    public static void main(String[] args) {
        //创建女友
        Girl girl = new Girl();
        //将女友放入描眉类
        MiaoMei hzp = new MiaoMei(girl);
        //将描眉后的女友放入涂口红类
        TuKouHong tkh = new TuKouHong(hzp);
        tkh.show();
    }
}
//输出结果：涂口红(描眉(女友的素颜))

        2、优点

        ①对于扩张一个对象的功能，装饰模式比继承模式更加灵活，不会导致类的数量急剧增加。

        ②可以通过一种动态的方式扩张一个类的功能，同过配置文件可以在运行时进行选择，不同的装饰类。

        ③ 可以对一个对象进行多次装饰，通过使用不同的具体装饰类以及这些装饰类的排列组合可以创造不同的行为的组合。

        3、缺点

        ① 在使用装饰模式的时候进行系统设计时会产生很多小对象，这些对象的区别在于他们之间相互连接 的方式有所不同，而不是他们的类或者属性值有所不同，大量小对象势必产生一大部分的系统资源开销，影响系统性能。

        ②装饰模式是一种比继承更加灵活的解决方案。但同时，也意味着比继承更加容易出错，更加难排长。对于多层装饰的对象，需要逐级排查，较为繁琐。

六、代理模式

        代理模式指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如生活中的通过代理访问网络，客户通过网络代理连接网络（具体业务），由代理服务器完成用户权限和访问限制等与上网相关的其他操作（相关业务）。

        1、代码示例

//定义Network接口类 Network.java
public interface Network {
    // 定义浏览的抽象方法
    public void browse();
}
 
//真实的上网操作类实现Network接口类 Real.java
public class Real implements Network{
    @Override
    //重写抽象方法
    public void browse(){
        System.out.println("上网浏览信息........");
    }
}
 
//代理上网类实现Network接口类 Proxy.java
public class Proxy implements Network{
    private Network network;//上网接口
    //设置代理的真实操作
    public Proxy(Network network){
         // 设置代理的子类
        this.network=network;
    }
    //身份验证操作 其他操作
    public void check(){
        System.out.println("验证账号密码是否合法");
    }
    @Override
    //代码实现上网
    public void browse(){
        //调用具体的代理业务操作
        this.check();
        //调用真实的上网操作
        this.network.browse();
    }
}
 
//测试类 Main.java
public class Main {
    public static void main(String[] args){
        //定义接口对象
        Network network=null;
        //实例化代理，同时传入代理的真实操作
        network=new Proxy(new Real());
        //调用代理的上网操作
        network.browse();
    }
}

        2、优点

        ①代理模式能将代理对象与真实被调用的目标对象隔离

        ②一定程度上降低了系统的耦合度，扩展性好

        ③可以起到保护目标对象的作用

        ④可以对目标对象的功能增强

        3、缺点

        ① 代理模式会造成系统设计中类的数量增加

        ②在客户端与目标对象之间增加一个代理对象，会造成请求处理速度变慢

        ③增加了系统的复杂度

七、观察者模式

        观察者模式定义了对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都将得到通知，并自动更新。观察者模式属于行为型模式，行为型模式关注的是对象之间的通讯，观察者模式就是观察者和被观察者之间的通讯。

        观察者模式有一个别名叫“发布-订阅模式”，或者说是“订阅-发布模式”，订阅者和订阅目标是联系在一起的，当订阅目标发生改变时，逐个通知订阅者。我们可以用报纸期刊的订阅来形象的说明，当你订阅了一份报纸，每天都会有一份最新的报纸送到你手上，有多少人订阅报纸，报社就会发多少份报纸，报社和订报纸的客户就是上面开头所说的“一对多”的依赖关系。

        1、代码示例

//观察者主题对象  Subject.java
//Subject 接口类
public interface Subject {
    //订阅操作
    void attach(Observer observer);
    //取消订阅操作
    void detach(Observer observer);
    //通知变动
    void notifyChanged();
}
 
//观察者订阅人对象 Observer.java
//Observer 接口类
public interface Observer {
    //接收变动通知
    void update();
}
 
//具体订阅人 RealObject.java
//RealObject 类实现 Observer 接口类
public class RealObject implements Observer {
    @Override
    public void update() {
        System.out.println("接收到了通知");
    }
}
 
//具体的某家奶厂 Subject.java
//RealSubject 类实现 Subject 接口类
public class RealSubject implements Subject{
    //本奶厂下订奶的人集合
    private List<Observer> observerList = new ArrayList<Observer>();
    //添加订阅者
    @Override
    public void attach(Observer observer) {
        observerList.add(observer);
    }
    //删除订阅者
    @Override
    public void detach(Observer observer) {
        observerList.remove(observer);
    }
    //消息通知订阅者
    @Override
    public void notifyChanged() {
        for (Observer observer : observerList) {
            observer.update();
        }
    }
}
 
//测试类 Main.java
public class Main {
    public static void main(String[] args) {
        //创建奶厂
        Subject subject = new RealSubject();
        Observer observer = new RealObject();
        subject.attach(observer);
        subject.notifyChanged();
    }
}

        2、优点

        ①观察者和被观察者是抽象耦合的

        ②建立了一套触发机制

        3、缺点

        ①如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。

        ②如果观察者和观察目标间有循环依赖，可能导致系统崩溃。

        ③没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的。

八、尾注

        希望这篇文章对你有所帮助，记得转载、点赞、收藏，支持一下，小编将会持续更新哦