义乌国贸学校网站建设,企业网站 费用,西安旅游服务网站建设,温州品牌设计公司文章目录设计原则1 单一职责原则2 开闭原则3 Liskov 替换原则4 依赖倒置原则5 接口隔离原则6 迪米特法则设计模式#xff1a;创建型模式1 工厂模式2 抽象工厂模式3 单例模式设计模式#xff1a;行为型模式1 观察者模式2 模板模式3 备忘录模式设计模式#xff1a;结构型模式1…
文章目录设计原则1 单一职责原则2 开闭原则3 Liskov 替换原则4 依赖倒置原则5 接口隔离原则6 迪米特法则设计模式创建型模式1 工厂模式2 抽象工厂模式3 单例模式设计模式行为型模式1 观察者模式2 模板模式3 备忘录模式设计模式结构型模式1 代理模式2 装饰器模式3 适配器模式设计原则
六大设计原则详解
1 单一职责原则
一个类只专注于做一件事
2 开闭原则
开闭原则是 OOP 中最基础的设计原则对拓展开放对修改关闭尽可能在不改变原有代码的情况下进行拓展要实现开闭原则首先实现面向接口编程依赖倒置原则
3 Liskov 替换原则
子类必须能够替换它们的基类型“父类能做的事子类必须能做要做到相等或更好”
4 依赖倒置原则
核心思想是面向接口编程依赖于抽象而不依赖于具体写代码时用到具体类时不与具体类交互而与具体类的上层接口交互使用接口或者抽象类的目的是制定好规范和契约而不去涉及任何具体的操作把展现细节的任务交给他们的实现类完成
5 接口隔离原则
使用多个隔离的接口比使用单个臃肿庞大接口要好尽量细化接口接口中的方法尽量少如果接口过于臃肿只要接口中出现的方法不管对依赖于它的类有没有用处实现类中都必须去实现这些方法
6 迪米特法则
一个实体应当尽量少的与其他实体之间发生相互作用使得系统功能模块相对独立 设计模式创建型模式
1 工厂模式
主要解决接口选择的问题将同一类对象的创建过程转移到一个工厂类实现在创建对象时不会对客户端暴露创建逻辑并且是通过使用一个共同的接口来指向新创建的对象
// 1.创建接口
public interface Shape {void draw();
}// 2.创建接口的实现类
public class Rectangle implements Shape {Overridepublic void draw() {System.out.println(Inside Rectangle::draw() method.);}
}public class Square implements Shape {Overridepublic void draw() {System.out.println(Inside Square::draw() method.);}
}// 3.创建工厂
public class ShapeFactory {public Shape getShape(String shapeType){if(shapeType null){return null;} if(shapeType.equalsIgnoreCase(CIRCLE)){return new Circle();} else if(shapeType.equalsIgnoreCase(RECTANGLE)){return new Rectangle();} else if(shapeType.equalsIgnoreCase(SQUARE)){return new Square();}return null;}
}public class FactoryPatternDemo {public static void main(String[] args) {ShapeFactory shapeFactory new ShapeFactory();//获取 Circle 的对象并调用它的 draw 方法Shape shape1 shapeFactory.getShape(CIRCLE);//调用 Circle 的 draw 方法shape1.draw();//...}
}2 抽象工厂模式
生产工厂的工厂将属于同一类型的工厂聚合在一起从工厂生产器中获取的工厂也用共用的接口指向同一对象
// 1.创建形状和颜色的接口及其实现类略// 2.设置形状和颜色的抽象工厂
public abstract class AbstractFactory {public abstract Color getColor(String color);public abstract Shape getShape(String shape);
}// 3.继承抽象工厂实现各自对应的方法
public class ShapeFactory extends AbstractFactory {Overridepublic Shape getShape(String shapeType){if(shapeType null){return null;}if(shapeType.equalsIgnoreCase(CIRCLE)){return new Circle();} else if(shapeType.equalsIgnoreCase(RECTANGLE)){return new Rectangle();} else if(shapeType.equalsIgnoreCase(SQUARE)){return new Square();}return null;}Overridepublic Color getColor(String color) {return null;}
}public class ColorFactory extends AbstractFactory {Overridepublic Shape getShape(String shapeType){return null;}Overridepublic Color getColor(String color) {if(color null){return null;} if(color.equalsIgnoreCase(RED)){return new Red();} else if(color.equalsIgnoreCase(GREEN)){return new Green();} else if(color.equalsIgnoreCase(BLUE)){return new Blue();}return null;}
}// 4.工厂生产器——工厂的工厂
public class FactoryProducer {public static AbstractFactory getFactory(String choice){if(choice.equalsIgnoreCase(SHAPE)){return new ShapeFactory();} else if(choice.equalsIgnoreCase(COLOR)){return new ColorFactory();}return null;}
}public class AbstractFactoryPatternDemo {public static void main(String[] args) {//获取形状工厂AbstractFactory shapeFactory FactoryProducer.getFactory(SHAPE);//获取形状为 Circle 的对象Shape shape1 shapeFactory.getShape(CIRCLE);//调用 Circle 的 draw 方法shape1.draw();//获取颜色工厂AbstractFactory colorFactory FactoryProducer.getFactory(COLOR);//获取颜色为 Red 的对象Color color1 colorFactory.getColor(RED);//调用 Red 的 fill 方法color1.fill();}
}3 单例模式 一个单一的类该类负责创建自己的对象同时确保只有单个对象被创建 可以直接访问不需要实例化该类的对象 最常用的 DCL (double-checked locking) 实现 构造方法使用 private 修饰保证该类只有自己能实例化自己 使用 volatile 修饰属性指示 JVM变量是共享且不稳定的每次使用它都到主存中进行读取并禁止指令重排
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; }
}设计模式行为型模式
1 观察者模式
定义对象间的一种一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都得到通知并被自动更新
// 1.被观察者类
public class Subject {private ListObserver observers new ArrayListObserver(); // 用List存放所有观察者private int state;public int getState() {return state;}public void setState(int state) {this.state state;notifyAllObservers();}public void attach(Observer observer){ // 添加观察者observers.add(observer); }public void notifyAllObservers(){ // 通知观察者自己的状态变化for (Observer observer : observers) {observer.update();}}
}// 2.观察者抽象类及其实现
public abstract class Observer {protected Subject subject;public abstract void update();
}public class BinaryObserver extends Observer{public BinaryObserver(Subject subject){this.subject subject;this.subject.attach(this); // 调用被观察者的attch方法将自己注册为它的观察者}Overridepublic void update() {System.out.println( Binary String: Integer.toBinaryString( subject.getState() ) ); }
}
......public class ObserverPatternDemo {public static void main(String[] args) {Subject subject new Subject();new HexaObserver(subject);new OctalObserver(subject);new BinaryObserver(subject);System.out.println(First state change: 15); subject.setState(15);System.out.println(Second state change: 10); subject.setState(10);}
}2 模板模式
一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现但调用将以抽象类中定义的方式进行模板方法被声明为 final因为执行它的流程是固定的
// 1.模板类
public abstract class Game {abstract void initialize();abstract void startPlay();abstract void endPlay();// 模板方法它规定了其他方法的执行流程是固定的public final void play(){//初始化游戏initialize();//开始游戏startPlay();//结束游戏endPlay();}
}// 2.模板类的不同实现
public class Football extends Game {Overridevoid endPlay() {System.out.println(Football Game Finished!);}Overridevoid initialize() {System.out.println(Football Game Initialized! Start playing.);}Overridevoid startPlay() {System.out.println(Football Game Started. Enjoy the game!);}
}public class Cricket extends Game {Overridevoid endPlay() {System.out.println(Cricket Game Finished!);}Overridevoid initialize() {System.out.println(Cricket Game Initialized! Start playing.);}Overridevoid startPlay() {System.out.println(Cricket Game Started. Enjoy the game!);}
}public class TemplatePatternDemo {public static void main(String[] args) {// 不同的实现使用相同的模板Game game new Cricket();game.play();game new Football();game.play(); }
}3 备忘录模式
在不破坏封装性的前提下捕获一个对象的内部状态并在该对象之外保存这个状态备忘录模式使用三个类 Memento、Originator 和 CareTaker Memento 包含了要被恢复的对象的状态相当于每一个存档 Originator 创建并在 Memento 对象中存储状态是要被存储的对象 Caretaker 对象负责从 Memento 中恢复对象的状态相当于存档的集合
// 1.Memento 类包含了要被恢复的对象的状态
public class Memento {private String state;public Memento(String state){this.state state;}public String getState(){return state;}
}// 2.Originator 类要被记录的类
public class Originator {private String state;public void setState(String state){this.state state;}public String getState(){return state;}public Memento saveStateToMemento(){return new Memento(state);}public void getStateFromMemento(Memento Memento){state Memento.getState();}
}// 3.CareTaker 类负责从 Memento 中恢复对象的状态
public class CareTaker {private ListMemento mementoList new ArrayListMemento();public void add(Memento state){mementoList.add(state);}public Memento get(int index){return mementoList.get(index);}
}public class MementoPatternDemo {public static void main(String[] args) {Originator originator new Originator();CareTaker careTaker new CareTaker();originator.setState(State #1);originator.setState(State #2);careTaker.add(originator.saveStateToMemento());originator.setState(State #3);careTaker.add(originator.saveStateToMemento());originator.setState(State #4);System.out.println(Current State: originator.getState()); originator.getStateFromMemento(careTaker.get(0));System.out.println(First saved State: originator.getState());originator.getStateFromMemento(careTaker.get(1));System.out.println(Second saved State: originator.getState());}
}Current State: State #4
First saved State: State #2
Second saved State: State #3设计模式结构型模式
1 代理模式
直接访问会给使用者或者系统结构带来很多麻烦时为其他对象提供一种代理以控制对这个对象的访问示例图像首次显示时需要先加载再次访问不需要通过代理自动化地完成这一过程 // 1.创建接口及其实现类
public interface Image {void display();
}public class RealImage implements Image {private String fileName;public RealImage(String fileName){this.fileName fileName;loadFromDisk(fileName);}Overridepublic void display() {System.out.println(Displaying fileName);}private void loadFromDisk(String fileName){System.out.println(Loading fileName);}
}// 2.创建代理
public class ProxyImage implements Image {private RealImage realImage;private String fileName;public ProxyImage(String fileName){this.fileName fileName;}Overridepublic void display() { // 代理的功能if(realImage null){realImage new RealImage(fileName);}realImage.display();}
}public class ProxyPatternDemo {public static void main(String[] args) {Image image new ProxyImage(test_10mb.jpg);// 图像将从磁盘加载image.display(); // 图像不需要从磁盘加载image.display(); }
}2 装饰器模式
动态地给一个对象添加一些额外的职责将其包装成功能更强大的类效果类似于继承作为继承的一种替代方式就增加功能来说装饰器模式相比生成子类更为灵活
// 1.创建形状接口及其实现类
public interface Shape {void draw();
}public class Rectangle implements Shape {Overridepublic void draw() {System.out.println(Shape: Rectangle);}
}// 2.抽象装饰类及其实现
public abstract class ShapeDecorator implements Shape {protected Shape decoratedShape;public ShapeDecorator(Shape decoratedShape){this.decoratedShape decoratedShape;}public void draw(){decoratedShape.draw();}
}public class RedShapeDecorator extends ShapeDecorator {public RedShapeDecorator(Shape decoratedShape) {super(decoratedShape); }Overridepublic void draw() {decoratedShape.draw(); setRedBorder(decoratedShape);}private void setRedBorder(Shape decoratedShape){System.out.println(Border Color: Red);}
}public class DecoratorPatternDemo {public static void main(String[] args) {Shape circle new Circle();ShapeDecorator redCircle new RedShapeDecorator(new Circle());ShapeDecorator redRectangle new RedShapeDecorator(new Rectangle());//Shape redCircle new RedShapeDecorator(new Circle());//Shape redRectangle new RedShapeDecorator(new Rectangle());System.out.println(Circle with normal border);circle.draw();System.out.println(\nCircle of red border);redCircle.draw();System.out.println(\nRectangle of red border);redRectangle.draw();}
}3 适配器模式
适配器模式Adapter Pattern是作为两个不兼容的接口之间的桥梁结合了两个独立接口的功能
// 1.创建要捏合的两个接口
public interface MediaPlayer {public void play(String audioType, String fileName);
}public interface AdvancedMediaPlayer { public void playVlc(String fileName);public void playMp4(String fileName);
}// 2.创建加强播放器的实现类
public class VlcPlayer implements AdvancedMediaPlayer{Overridepublic void playVlc(String fileName) {System.out.println(Playing vlc file. Name: fileName); }Overridepublic void playMp4(String fileName) {//什么也不做}
}public class Mp4Player implements AdvancedMediaPlayer{Overridepublic void playVlc(String fileName) {//什么也不做}Overridepublic void playMp4(String fileName) {System.out.println(Playing mp4 file. Name: fileName); }
}// 3.创建 实现加强播放器方法的 适配器类
public class MediaAdapter implements MediaPlayer {AdvancedMediaPlayer advancedMusicPlayer;public MediaAdapter(String audioType){if(audioType.equalsIgnoreCase(vlc) ){advancedMusicPlayer new VlcPlayer(); } else if (audioType.equalsIgnoreCase(mp4)){advancedMusicPlayer new Mp4Player();} }Overridepublic void play(String audioType, String fileName) {if(audioType.equalsIgnoreCase(vlc)){advancedMusicPlayer.playVlc(fileName);}else if(audioType.equalsIgnoreCase(mp4)){advancedMusicPlayer.playMp4(fileName);}}
}// 4.创建未增强的播放器注入适配器
public class AudioPlayer implements MediaPlayer {MediaAdapter mediaAdapter; Overridepublic void play(String audioType, String fileName) { //播放 mp3 音乐文件的内置支持if(audioType.equalsIgnoreCase(mp3)){System.out.println(Playing mp3 file. Name: fileName); } //mediaAdapter 提供了播放其他文件格式的支持else if(audioType.equalsIgnoreCase(vlc) || audioType.equalsIgnoreCase(mp4)){mediaAdapter new MediaAdapter(audioType);mediaAdapter.play(audioType, fileName);}else{System.out.println(Invalid media. audioType format not supported);}}
}public class AdapterPatternDemo {public static void main(String[] args) {AudioPlayer audioPlayer new AudioPlayer();audioPlayer.play(mp3, beyond the horizon.mp3);audioPlayer.play(mp4, alone.mp4);audioPlayer.play(vlc, far far away.vlc);}
}
