面向对象设计模式课程小结

 关注
发布于: 2020 年 06 月 25 日
课程回顾设计模式的作用用来解决我们软件开发和设计中出现的问题。
设计模式的定义一种可重复使用的解决方案。
设计模式的分类﻿
﻿
常用设计模式工厂模式简单工厂定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
﻿
﻿
public class ShapeFactroy{
  public Shape getShpe(String shpae){
    if(shape == "circle"){
      return new Circle();
    }
    if(shape == "square"){
      return new Square();
    }
  }
}
public class Demo{
  public static void main(String[] args){
    ShapeFactory shapeFactory = new ShapeFactory();
    shapeFactory.getShape("circle").doSomething();
  }
}
抽象工厂提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
﻿
﻿
单例模式保证一个类仅有一个实例，并提供一个访问它的全局访问点。
﻿
﻿
public class SingleObject{
  private SingleObject instance;
  private SingleObject(){}
  public syschronized static SingleObject getInstance(){
    if(null == instance){
      return new SingleObject();
    }
  }  
}
适配器模式将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
﻿
public interface MediaPlayer{
   void play(String autoType,String fileName);
}
﻿
public class AutoMediaPlayer implements MediaPlayer{
  	
    private MediaAdpater mediaApater;	
  
    @Override
    public void play(String autoType,String fileName){
      if("mp3".equales(autoType)){
        log.info("play mp3 with {}",fileName);
      }else if("mp4".equales(autoType) || "vlc".equales(autoType)){
        MediaApater mediaApater = new MediaApater(autoType);
        mediaApater.play(autoType,fileName);
      }else{
      	log.info("can not support this autoType");
      }
    }
}
﻿
public interface AdvanceMediaPlayer{
  void playMp4(String fileName);
  void playVlc(String fileName);
}
﻿
public class Mp4MediaPlayer implements AdvanceMediaPlayer{
	
  @Override
  public void playMp4(String fileName){
      log.info("play mp4 with {}",fileName);
  }
  
  @Override
  public void playVlc(String fileName){}
}
﻿
public class VlcMediaPlayer implements AdvanceMediaPlayer{
	
  @Override
  public void playMp4(String fileName){}
  
  @Override
  public void playVlc(String fileName){
      log.info("play mp4 with {}",fileName);
  }
}
﻿
public class MediaAdapter implements MediaPlayer{
  
  private AdvanceMediaPlayer advanceMediaPlayer;
  
  public MediaAdapter(String autoType){
    if("mp4".equales(autoType)){
      advanceMediaPlayer = new Mp4MediaPlayer();
    }
    if("vlc".equales(autoType)){
     advanceMediaPlayer = new VlcMediaPlayer();
    }
  }
  
	@Override
  public void play(String autoType,String fileName){
    if("mp4".equales(autoType)){
      advanceMediaPlayer.playMp4(fileName);
    }
    if("vlc".equales(autoType)){
    	advanceMediaPlayer.playVlc(fileName);
    }
  }
}
﻿
模板模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
package com.qiangjun;
public abstract class GameAbstract {
    abstract void init();
    abstract void startPlay();
    abstract void endPlay();
    public final void play(){
        init();
        startPlay();
        endPlay();
    }
}
﻿
package com.qiangjun;
public class Football extends GameAbstract {
    @Override
    void init() {
        System.out.println("init football");
    }
    @Override
    void startPlay() {
        System.out.println("start play football");
    }
    @Override
    void endPlay() {
        System.out.println("end play football");
    }
}
﻿
package com.qiangjun;
public class Cricket extends GameAbstract {
    @Override
    void init() {
        System.out.println("init Cricket");
    }
    @Override
    void startPlay() {
        System.out.println("start play Cricket");
    }
    @Override
    void endPlay() {
        System.out.println("end play Cricket");
    }
}
﻿
策略模式定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。
﻿
组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
﻿
装饰器模式动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式相比生成子类更为灵活。
﻿
package com.qiangjun;
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        ShapeDecorator circleDecorator = new RedShapDecorator(circle);
        circleDecorator.draw();
    }
}
﻿
package com.qiangjun;
public interface Shape {
    void draw();
}
﻿
package com.qiangjun;
public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("draw rectangle......");
    }
}
﻿
package com.qiangjun;
public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("draw circle......");
    }
}
﻿
package com.qiangjun;
public abstract class ShapeDecorator implements Shape{
    protected Shape shape;
    public ShapeDecorator(Shape shape){
        this.shape = shape;
    }
    @Override
    public void draw() {
        shape.draw();
    }
}
﻿
package com.qiangjun;
public class RedShapDecorator extends ShapeDecorator{
    public RedShapDecorator(Shape shape) {
        super(shape);
    }
    @Override
    public void draw() {
        shape.draw();
        setRedBorder(shape);
    }
    private void setRedBorder(Shape shape){
        System.out.println("do something with this shape");
    }
}
﻿