设计模式
1.单例模式
单例模式特点:1.单例类只能有一个实例(单例模式的构造方法是修饰符是private)
2.单例类必须自己创建自己唯一的实例
3.单例类必须给所有其他对象提供这一个实例
单例模式有多种写法
懒汉式:在第一次调用的时候,实例化自己
public class Singleton { //懒汉写法 private static Singleton singleton; private Singleton(){ } //线程不安全的写法 /* public static Singleton getInstance(){ if(singleton==null){ Singleton singleton = new Singleton(); } return singleton; }*/ //线程安全的写法 public static synchronized Singleton getInstance(){ if(singleton==null){ Singleton singleton = new Singleton(); } return singleton; } }
饿汉式:对象创建的时候就被实例化,
public class SingleTonE { private static SingleTonE single = new SingleTonE(); private SingleTonE(){ } public static SingleTonE getInstance(){ return single; } }
饿汉式在类创建的同时就已经创建好一个静态的对象供系统使用,以后不再改变,所以是线程安全的。
静态内部类写法
public class Singleton { private static class LazyHolder{ private static final Singleton INSTANCE = new Singleton(); } private Singleton(){ } public static final Singleton getInstance(){ return LazyHolder.INSTANCE; } }
双重检查锁定
public class Singleton { private volatile static Singleton singleton; private Singleton (){} public static Singleton getSingleton() { if (singleton == null) { synchronized (Singleton.class) { if (singleton == null) { singleton = new Singleton(); } } } return singleton; } }
单例参考:https://blog.csdn.net/jason0539/article/details/23297037
2.观察者模式
例子:瘦下来有俩个好朋友,一个是垒哥,一个是秋天,他俩时刻关注着瘦下来的状态,想要一起出去玩,瘦下来想要玩的时候,就发消息通知他们俩,通过这个接口,垒哥和秋天来接收小可爱的消息
public interface Person { void getMessage(String s); }
垒哥和秋天来具体实现这个接口,垒哥的
public class WangLei implements Person { String name = "垒哥"; public WangLei() { super(); } @Override public void getMessage(String s) { System.out.println(name+"接到了瘦下来电话,内容是"+s); } }
秋天的
public class QiuTian implements Person { String name = "秋天"; @Override public void getMessage(String s) { System.out.println(name+"接到了瘦下来的电话,内容是"+s); } }
瘦下来想出去玩,给好朋友发下消息
public class YaoHong {
//这个是我的好朋友合集 List<Person> peoples = new ArrayList<>();
//拿个小本本把好朋友都存起来 public void addPerson(Person p){ peoples.add(p); } //挨个通知他们,一起出去玩 public void getNotifyPerson() { for (Person p:peoples){ p.getMessage("我们一起去玩吧"); } } }
测试类
public class ViewTest { public static void main(String[] args) { QiuTian tian = new QiuTian(); WangLei wangLei = new WangLei(); YaoHong yaoHong = new YaoHong(); yaoHong.addPerson(tian); yaoHong.addPerson(wangLei); yaoHong.getNotifyPerson(); } }
输出的结果为
通过上面栗子的介绍,来理解一下下面这段话。
观察者模式:一个被观察者管理所有相依与它的观察者物件,并且在本身的状态改变时主动发出通知,这通常通过呼叫各观察者所提供的方法来实现,此种模式通常被用来实现事件处理系统
角色:
抽象被观察者角色:被观察者提供一个接口,可以增加修改,删除观察者角色,一般用一个接口实现
抽象观察者角色:为所有具体的观察者定义一个接口,在得到主题时通知更新自己
具体被观察者角色:在被观察者内部状态发生改变时,给所有登记过的观察者发出通知,具体被观察者通过一个子类来实现。
具体观察者角色:该角色实现抽象观察者角色所需要的更新接口,以便使本身的状态与主题的状态相协调,通常用一个子类实现。如果需要,具体观察者角色可以保存一个指向具体主题的角色
在举个例子:珠宝商运送一批钻石,有黄金强盗准备抢劫,珠宝商雇佣了私人保镖,警察局也派人护送,于是当运输车上路的时候,强盗保镖警察都要观察运输车一举一动
抽象观察者:
public interface Watcher { public void update(); }
抽象被观察者:
public interface Watched { public void addWatcher(Watcher watcher); public void removeWatcher(Watcher watcher); public void notifyWatcher(); }
具体的观察者警察:
public class Police implements Watcher { @Override public void update() { System.out.println("运输车有行动,警察保护安全"); } }
具体的观察者强盗:
public class Thief implements Watcher { @Override public void update() { System.out.println("运输车有行动,强盗准备动手"); } }
具体的观察者保镖:
public class Security implements Watcher{ @Override public void update() { System.out.println("运输车有行动,保镖保护安全"); } }
具体的被观察者钱:
public class Money implements Watched { List<Watcher> watcherList = new ArrayList<Watcher>(); @Override public void addWatcher(Watcher watcher) { watcherList.add(watcher); } @Override public void removeWatcher(Watcher watcher) { watcherList.remove(watcher); } @Override public void notifyWatcher() { for (Watcher watcher:watcherList){ watcher.update(); } } }
测试类:
public class test { public static void main(String[] args) { Money money = new Money(); Police p = new Police(); Security s = new Security(); Thief t = new Thief(); money.addWatcher(p); money.addWatcher(s); money.addWatcher(t); money.notifyWatcher(); } }
参考链接:https://blog.csdn.net/jason0539/article/details/45055233
3.工厂模式
(1)工厂模式主要是为创建对象提供过渡接口,以便将创建对象的具体过程屏蔽隔离起来,达到提高灵活性的目的
工厂模式可以分为三类:
(1)简单工厂模式(Simple Factory)
(2)工厂方法模式(Factory Method)
(3)抽象工厂模式(Abstract Factory)
这三种模式从上到下逐步抽象,并且更具有一般性
(2)引言
1.还没有工厂时代:假如还没有工业革命,如果一个客户要一款宝马车,一般的做法是客户去创建一款宝马车,然后拿来用
2.简单工厂模式:后来出现了工业革命,用户不用去创建宝马车了,因为客户有一个工厂来帮他创建宝马,想要什么车,这个工厂就可以建。比如想要320i系列车,工厂就创建这个系列的车,即工厂可以创建产品。
3.工厂方法模式时代:为了满足客户,宝马系列越来越多,比如320i,523i,301i等系列一个工厂无法创建所有的宝马系列,于是由单独分出来多个具体的工厂,每个具体工厂创建一种系列。即具体工厂类只能创建一个具体产品。但是宝马工厂还是个抽象。你需要具体指定某个具体的工厂才能生产车出来
4.抽象工厂模式时代:随着客户的要求越来越高,宝马车必须配置空调,于是这个工厂开始生产宝马车和需要的空调
最终客户只要对宝马的销售人员说:我要523i空调车,销售人员就直接给他523i空调车了,而不用自己去创建523i空调宝马车了。
简单工厂模式又称为静态工厂模式。重命名上就可以看出这个模式一定很简单,它存在的目的很简单:定义一个用于创建对象的接口
参考链接:https://blog.csdn.net/jason0539/article/details/23020989
4.代理模式
5.策略模式
6.模板方法模式
(1)AbstractClass抽象类,类中实现了模板方法,定义了算法的骨架,聚体子类需要去实现其他的抽象方法。
(2)ConcreteClass实现抽象方法,以完成算法中特点子类的步骤
以顾客需要喝到不同口味的豆浆为例
抽象类
public abstract class soya { //模板方法 public void make(){ select(); if (customWant()){ addCondition(); } solk(); beat(); } //选材 public void select(){ System.out.println("选择新鲜的黄豆"); } public abstract void addCondition(); public void solk(){ System.out.println("开始浸泡"); } public void beat(){ System.out.println("开始打磨"); } public boolean customWant(){ return true; } }
喝红豆味的豆浆
public class RedSoya extends soya { @Override public void addCondition() { System.out.println("添加红豆"); } }
花生味豆浆
public class PeanuaSoya extends soya { @Override public void addCondition() { System.out.println("添加花生"); } }
纯豆浆
public class onlySoya extends soya{ @Override public void addCondition() { return; } @Override public boolean customWant() { return false; } }
测试
public class test { public static void main(String[] args) { soya redsoya = new RedSoya(); redsoya.make(); soya PeaunaSoya = new PeanuaSoya(); PeaunaSoya.make(); soya only = new onlySoya(); only.make(); } }
测试结果
选择新鲜的黄豆 添加红豆 开始浸泡 开始打磨 选择新鲜的黄豆 添加花生 开始浸泡 开始打磨 选择新鲜的黄豆 开始浸泡 开始打磨
7.装饰者模式
对已有的业务逻辑的封装,增加额外的属性和功能,装饰者与被装饰者拥有共同的超类,继承的目的是继承类型而不是行为
//定义被装饰者 public interface Human { public void wearClothes(); public void walkToWhere(); } //定义装饰者 public abstract class Decorator implements Human { private Human human; public Decorator(Human human) { this.human = human; } public void wearClothes() { human.wearClothes(); } public void walkToWhere() { human.walkToWhere(); } } //下面定义三种装饰,这是第一个,第二个第三个功能依次细化,即装饰者的功能越来越多 public class Decorator_zero extends Decorator { public Decorator_zero(Human human) { super(human); } public void goHome() { System.out.println("进房子。。"); } public void findMap() { System.out.println("书房找找Map。。"); } @Override public void wearClothes() { // TODO Auto-generated method stub super.wearClothes(); goHome(); } @Override public void walkToWhere() { // TODO Auto-generated method stub super.walkToWhere(); findMap(); } } public class Decorator_first extends Decorator { public Decorator_first(Human human) { super(human); } public void goClothespress() { System.out.println("去衣柜找找看。。"); } public void findPlaceOnMap() { System.out.println("在Map上找找。。"); } @Override public void wearClothes() { // TODO Auto-generated method stub super.wearClothes(); goClothespress(); } @Override public void walkToWhere() { // TODO Auto-generated method stub super.walkToWhere(); findPlaceOnMap(); } } public class Decorator_two extends Decorator { public Decorator_two(Human human) { super(human); } public void findClothes() { System.out.println("找到一件D&G。。"); } public void findTheTarget() { System.out.println("在Map上找到神秘花园和城堡。。"); } @Override public void wearClothes() { // TODO Auto-generated method stub super.wearClothes(); findClothes(); } @Override public void walkToWhere() { // TODO Auto-generated method stub super.walkToWhere(); findTheTarget(); } } //定义被装饰者,被装饰者初始状态有些自己的装饰 public class Person implements Human { @Override public void wearClothes() { // TODO Auto-generated method stub System.out.println("穿什么呢。。"); } @Override public void walkToWhere() { // TODO Auto-generated method stub System.out.println("去哪里呢。。"); } } //测试类,看一下你就会发现,跟java的I/O操作有多么相似 public class Test { public static void main(String[] args) { Human person = new Person(); Decorator decorator = new Decorator_two(new Decorator_first( new Decorator_zero(person))); decorator.wearClothes(); decorator.walkToWhere(); } }
运行结果
參考:https://blog.csdn.net/jason0539/article/details/22713711
8.适配器模式
9.生产者消费者模式