知道的越多,知道的越少,无限循环,很舒服…

设计模式

1.创建类

1.工厂方法

工厂方法:定义一个创建对象的接口,但让实现这个接口的类来决定实例化哪个类,工厂方法让类的实例化推迟到子类中进行

工厂定义获取对象的方法,子类继承父类或者实现接口,创建真正需要的实例

//步骤1:定义所需类的规范 public abstract class Video { public abstract void produce(); } 步骤2:具体的子类继承Video并重写其方法 public class JavaVideo extends Video { public JavaVideo() { } @Override public void produce() { System.out.println("Java视频"); } } //步骤3:定义工厂的规范 public abstract class VideoFactory { public abstract Video getVideo(); } //步骤4:子类工厂完成生产对象的逻辑 public class JavaVideoFactory extends VideoFactory { @Override public Video getVideo() { return new JavaVideo(); } } 产品就是Video 创建者 VideoFactory 实际的创建者 是其子类 源码中的体现 : Colleciton中的iterator()

2.抽象工厂

定义 :抽象工厂提供一个创建一系列相关或相互依赖对象的接口

产品族: 好比都是由一个工厂生产的各种产品

产品等级:不同厂家生产的相同类型的产品

//步骤1 需要创建的产品 public abstract class Video { public abstract void produce(); } //步骤2:定义工厂的规范 public interface CourseFactory { Video getVideo(); Article getArticle(); } //步骤3: 同一产品族具体生产所需的对象 public class JavaCourseFactory implements CourseFactory { @Override public Video getVideo() { return new JavaVideo(); } @Override public Article getArticle() { return new JavaArticle(); } } 新增产品等级比较的麻烦 ,需要进行修改 源码解析:数据库连接的类Connection sqlSessionFactory

3.单例模式

定义:保证一个类仅有一个实例,并提供一个全局访问点

注意点:

私有构造器 , 线程安全, 延迟加载

懒汉式

public class LazyDoubleCheckSingleton { //volatile序列化 private volatile static LazyDoubleCheckSingleton lazyDoubleCheckSingleton = null; private LazyDoubleCheckSingleton(){ } public static LazyDoubleCheckSingleton getInstance(){ if(lazyDoubleCheckSingleton == null){ synchronized (LazyDoubleCheckSingleton.class){ if(lazyDoubleCheckSingleton == null){ lazyDoubleCheckSingleton = new LazyDoubleCheckSingleton(); //1.分配内存给这个对象 // //3.设置lazyDoubleCheckSingleton 指向刚分配的内存地址 //2.初始化对象 // intra-thread semantics // ---------------//3.设置lazyDoubleCheckSingleton 指向刚分配的内存地址 } } } return lazyDoubleCheckSingleton; } }

饿汉式

public class HungrySingleton { private final static HungrySingleton hungrySingleton; static{ hungrySingleton = new HungrySingleton(); } private HungrySingleton(){ } public static HungrySingleton getInstance(){ return hungrySingleton; } }

枚举式

public enum EnumInstance { INSTANCE; private Object data; public Object getData() { return data; } public void setData(Object data) { this.data = data; } public static EnumInstance getInstance(){ return INSTANCE; } }

2.结构型

1.装饰者模式

定义:在不改变原有对象的基础之上,将功能附加到对象上,扩展原有的对象的功能

使用场景

扩展一个类的功能或者给一个类添加附加职责

动态的给一个对象添加功能,并且可以动态的撤销

版本2 //抽象的实体类 public abstract class ABattercake { protected abstract String getDesc(); protected abstract int cost(); } //实体类煎饼登场 public class Battercake extends ABattercake { @Override protected String getDesc() { return "煎饼"; } @Override protected int cost() { return 8; } } //通过实体入参完成 public abstract class AbstractDecorator extends ABattercake { private ABattercake aBattercake; public AbstractDecorator(ABattercake aBattercake) { this.aBattercake = aBattercake; } protected abstract void doSomething(); @Override protected String getDesc() { return this.aBattercake.getDesc(); } @Override protected int cost() { return this.aBattercake.cost(); } } //具体的装饰,给父类扩展功能 public class EggDecorator extends AbstractDecorator { public EggDecorator(ABattercake aBattercake) { super(aBattercake); } @Override protected void doSomething() { } @Override protected String getDesc() { return super.getDesc()+" 加一个鸡蛋"; } @Override protected int cost() { return super.cost()+1; } } //测试代码 public class Test { public static void main(String[] args) { ABattercake aBattercake; aBattercake = new Battercake(); aBattercake = new EggDecorator(aBattercake); aBattercake = new EggDecorator(aBattercake); aBattercake = new SausageDecorator(aBattercake); System.out.println(aBattercake.getDesc()+" 销售价格:"+aBattercake.cost()); } }

2.适配器模式

定义:将一个类的接口转化为客户期待的另一个接口

使原本接口不兼容的类可以一起工作]

//被适配者 public class AC220 { public int outputAC220V(){ int output = 220; System.out.println("输出交流电"+output+"V"); return output; } } //输出5v直流电,也就是目标抽象类 public interface DC5 { int outputDC5V(); } //电源适配器 把220v转化为 5 v public class PowerAdapter implements DC5{ private AC220 ac220 = new AC220(); @Override public int outputDC5V() { int adapterInput = ac220.outputAC220V(); //变压器... int adapterOutput = adapterInput/44; System.out.println("使用PowerAdapter输入AC:"+adapterInput+"V"+"输出DC:"+adapterOutput+"V"); return adapterOutput; } } //测试 public class Test { public static void main(String[] args) { DC5 dc5 = new PowerAdapter(); dc5.outputDC5V(); } }

3.行为型

1.模板方法

定义:定义了一个算法的骨架,并允许子类为一个或者多个步骤提供实现

模板方法使子类可以在不改变算法结构的情况下,重新定义算法的某些步骤

使用场景

一次性实现一个算法不变的部分,并将可变的行为留给子类来实现

//定义模板不被修改 public abstract class ACourse { //定义模板方法 protected final void makeCourse(){ this.makePPT(); this.makeVideo(); if(needWriteArticle()){ this.writeArticle(); } this.packageCourse(); } final void makePPT(){ System.out.println("制作PPT"); } final void makeVideo(){ System.out.println("制作视频"); } final void writeArticle(){ System.out.println("编写手记"); } //钩子方法,用于子类实现 protected boolean needWriteArticle(){ return false; } //包装课程的方法 abstract void packageCourse(); //具体的课程实现 public class DesignPatternCourse extends ACourse { @Override //子类自己特有的方法 void packageCourse() { System.out.println("提供课程Java源代码"); } //钩子方法用于是否有手记 @Override protected boolean needWriteArticle() { return true; } }

2.策略模式

定义 : 定义了算法家族,分别封装起来,让他们之间可以互相替换,此模式让算法的变化不会影响到使用算法的用户

使用场景

系统有很多的类,而他们仅仅是在于他们的行为不同

一个系统需要动态的在几种算法中选择一种

//促销策略 public interface PromotionStrategy { void doPromotion(); } //策略1 满减策略 public class ManJianPromotionStrategy implements PromotionStrategy{ @Override public void doPromotion() { System.out.println("满减促销,满200-20元"); } } //返现策略 public class FanXianPromotionStrategy implements PromotionStrategy{ @Override public void doPromotion() { System.out.println("返现促销,返回的金额存放到慕课网用户的余额中"); } } //立减策略 public class LiJianPromotionStrategy implements PromotionStrategy { @Override public void doPromotion() { System.out.println("立减促销,课程的价格直接减去配置的价格"); } } //促销活动 public class PromotionActivity { private PromotionStrategy promotionStrategy; public PromotionActivity(PromotionStrategy promotionStrategy) { this.promotionStrategy = promotionStrategy; } //执行促销的策略 public void executePromotionStrategy(){ promotionStrategy.doPromotion(); } } //测试 public class Test { public static void main(String[] args) { PromotionActivity promotionActivity618 = new PromotionActivity(new LiJianPromotionStrategy()); PromotionActivity promotionActivity1111 = new PromotionActivity(new FanXianPromotionStrategy()); //这样就能执行不同的促销策略 promotionActivity618.executePromotionStrategy(); promotionActivity1111.executePromotionStrategy(); } }

3.观察者模式

定义 ; 定义对象之间一对多的关系,多个观察者监听某个主题对象,当对象发生变化时,它的依赖者都会收到通知并更新

使用场景

关联场景,建立触发机制

//被观察者JDK的Observable类 public class Couse extends Observable { private String courseName; public Couse(String courseName) { this.courseName = courseName; } public void setCourseName(String courseName) { this.courseName = courseName; } public String getCourseName() { return courseName; } //产生问题,发生变化 public void produceQuestion(Couse course,Question question) { System.out.println(question.getUsername()+"在"+course.getCourseName()+"提了一个问题"); setChanged(); notifyObservers(question); } } //观察者,注意被观察者的情况,实现Observer接口 public class Teacher implements Observer { private String teacherName; public Teacher(String teacherName) { this.teacherName = teacherName; } //Observable o --> course类 arg--->事件的发生 //接收到变化 @Override public void update(Observable o, Object arg) { Couse couse = (Couse) o ; Question question = (Question) arg; System.out.println(teacherName+"老师的"+couse.getCourseName()+"课程接收到"+question.getUsername() +"提交的"+question.getQuestionContent() ); } } 测试中 course.addObserver(teacher) 放入即可