滕州网站制作,免费引流微信推广,什么网站可以做外单,小网站代码本文介绍Java中的代理模式#xff0c;及一些常见的模式应用。
一、Java设计模式
Java中最常见的设计模式主要有23种#xff0c;如表所示#xff1a;
表格#xff1a;Java设计模式分类
类型设计模式创建型模式单例模式#xff08;Singleton Pattern#xff09;工厂方法…本文介绍Java中的代理模式及一些常见的模式应用。
一、Java设计模式
Java中最常见的设计模式主要有23种如表所示
表格Java设计模式分类
类型设计模式创建型模式单例模式Singleton Pattern工厂方法模式Factory Method Pattern抽象工厂模式Abstract Factory Pattern建造者模式Builder Pattern原型模式Prototype Pattern结构型模式适配器模式Adapter Pattern桥接模式Bridge Pattern组合模式Composite Pattern装饰者模式Decorator Pattern外观模式Facade Pattern享元模式Flyweight Pattern代理模式Proxy Pattern行为型模式责任链模式Chain of Responsibility Pattern命令模式Command Pattern解释器模式Interpreter Pattern迭代器模式Iterator Pattern中介者模式Mediator Pattern备忘录模式Memento Pattern观察者模式Observer Pattern状态模式State Pattern策略模式Strategy Pattern模板方法模式Template Method Pattern访问者模式Visitor Pattern
二、单例模式美团面试真题
单例模式是一种创建型设计模式确保一个类只有一个实例并提供一个全局访问点来访问该实例。这种模式通常用于需要全局唯一实例的场景如配置管理、日志记录、数据库连接等。单例模式可分为饿汉式和懒汉式两种。
1. 饿汉式线程安全在类加载时就创建实例但是可能会造成资源浪费。 代码实现
public class Singleton {private static final Singleton instance new Singleton();private Singleton() {}public static Singleton getInstance() {return instance;}
}2. 懒汉式在使用时才创建对象实例因此面对多线程时会产生线程安全问题。 代码
public class Singleton {private static Singleton instance;private Singleton() {}public static Singleton getInstance() {if (instance null) {instance new Singleton();}return instance;}
}3. 线程安全的单例模式使用双重锁
public class Singleton{private static Singleton instance;private Singleton(){}//获取单例的方法public static Singleton getInstance(){//第一重校验if(instance null){synchronized (Singleton.class){//第二重校验if(instance null){instance new Singleton();}}}return instance;}
}三、工厂方法模式 VS 抽象方法模式
1. 工厂方法模式
工厂方法模式为每种产品创建一个具体工厂类然后在使用时根据需要使用相应的具体工厂创建对象优点符合开闭原则可以增加新的产品类而无需修改现有代码缺点需要为每种产品创建一个具体工厂类增加了系统的复杂度和代码量示例
// 产品接口
interface Product {void use();
}// 具体产品A
class ConcreteProductA implements Product {public void use() {System.out.println(Using Product A);}
}// 具体产品B
class ConcreteProductB implements Product {public void use() {System.out.println(Using Product B);}
}// 抽象工厂
abstract class Creator {public abstract Product factoryMethod();
}// 具体工厂A
class ConcreteCreatorA extends Creator {public Product factoryMethod() {return new ConcreteProductA();}
}// 具体工厂B
class ConcreteCreatorB extends Creator {public Product factoryMethod() {return new ConcreteProductB();}
}
public class Client {public static void main(String[] args) {Creator creatorA new ConcreteCreatorA();Product productA creatorA.factoryMethod();productA.use(); // 输出: Using Product ACreator creatorB new ConcreteCreatorB();Product productB creatorB.factoryMethod();productB.use(); // 输出: Using Product B}
}2. 抽象方法模式
抽象工厂模式提供一个创建一系列相关或相互依赖对象的接口而无需指定它们具体的类优点 ① 分离了具体类的生成使得产品之间的依赖关系更加一致。 ② 提供了一个一致的接口可以创建多个产品对象使产品族的更换变得容易缺点新增产品族时需要修改抽象工厂接口违反了开闭原则增加复杂性示例
// 抽象产品A
interface ProductA {void use();
}// 抽象产品B
interface ProductB {void use();
}// 具体产品A1
class ConcreteProductA1 implements ProductA {public void use() {System.out.println(Using Product A1);}
}// 具体产品B1
class ConcreteProductB1 implements ProductB {public void use() {System.out.println(Using Product B1);}
}// 具体产品A2
class ConcreteProductA2 implements ProductA {public void use() {System.out.println(Using Product A2);}
}// 具体产品B2
class ConcreteProductB2 implements ProductB {public void use() {System.out.println(Using Product B2);}
}// 抽象工厂
interface AbstractFactory {ProductA createProductA();ProductB createProductB();
}// 具体工厂1
class ConcreteFactory1 implements AbstractFactory {public ProductA createProductA() {return new ConcreteProductA1();}public ProductB createProductB() {return new ConcreteProductB1();}
}// 具体工厂2
class ConcreteFactory2 implements AbstractFactory {public ProductA createProductA() {return new ConcreteProductA2();}public ProductB createProductB() {return new ConcreteProductB2();}
}
public class Client {public static void main(String[] args) {AbstractFactory factory1 new ConcreteFactory1();ProductA productA1 factory1.createProductA();ProductB productB1 factory1.createProductB();productA1.use(); // 输出: Using Product A1productB1.use(); // 输出: Using Product B1AbstractFactory factory2 new ConcreteFactory2();ProductA productA2 factory2.createProductA();ProductB productB2 factory2.createProductB();productA2.use(); // 输出: Using Product A2productB2.use(); // 输出: Using Product B2}
}3. 二者区别华为面试
特性工厂方法模式 (Factory Method)抽象工厂模式 (Abstract Factory)定义定义一个创建对象的接口但由子类决定实例化哪个类。提供一个创建一系列相关或相互依赖对象的接口而无需指定它们具体的类。使用场景当一个类不知道它所需要的对象的具体类时。当系统要独立于它的产品的创建、组合和表示时。优点1. 符合开闭原则。2. 客户端不需要修改代码就可以使用新创建的对象。1. 分离了具体类的生成。2. 提供了一致的接口便于创建多个相关产品对象。缺点1. 需要为每种产品创建一个具体工厂类。2. 增加了系统的复杂度和代码量。1. 新增产品族时需要修改抽象工厂接口违反开闭原则。2. 增加了系统的复杂度。主要角色1. 抽象产品2. 具体产品3. 抽象工厂4. 具体工厂1. 抽象产品2. 具体产品3. 抽象工厂4. 具体工厂产品创建的粒度只创建单一产品对象。创建一系列相关或依赖的产品对象。
四、策略模式
1. 定义 定义一系列算法把它们一个个封装起来并且使它们可以相互替换。本模式使得算法可以独立于使用它的客户而变化。 2. 示例
interface Strategy {void execute();
}class ConcreteStrategyA implements Strategy {Overridepublic void execute() {System.out.println(Strategy A executed.);}
}class ConcreteStrategyB implements Strategy {Overridepublic void execute() {System.out.println(Strategy B executed.);}
}class Context {private Strategy strategy;public Context(Strategy strategy) {this.strategy strategy;}public void setStrategy(Strategy strategy) {this.strategy strategy;}public void executeStrategy() {strategy.execute();}
}常见应用
五、观察者模式
1. 定义 定义对象间的一种一对多的依赖关系当一个对象的状态发生改变时所有依赖于它的对象都得到通知并被自动更新。 2. 示例海康威视笔试楼层着火通知
// 观察者接口
interface Observer {void update(int floor); // 更新方法传入楼层信息
}
// 具体的观察者类保安类
class SecurityGuard implements Observer {private String name;public SecurityGuard(String name) {this.name name;}Overridepublic void update(int floor) {System.out.println(Security Guard name received fire alert from floor floor);if (floor Integer.parseInt(name)) {System.out.println(Security Guard name is handling the fire.);} else {System.out.println(Security Guard name is not responsible for this floor.);}}
}
// 被观察者接口
interface Subject{void registerObserver(Observer observer); // 注册观察者void removeObserver(Observer observer); // 移除观察者void notifyObservers(int floor); // 通知观察者
}// 具体主题类楼层类
class Floor implements Subject {private ListObserver observers; // 观察者列表public Floor() {this.observers new ArrayList();}Overridepublic void registerObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers(int floor) {for (Observer observer : observers) {observer.update(floor);}}// 模拟楼层着火public void fireAlert(int floor) {System.out.println(Fire alert on floor floor);notifyObservers(floor);}
}六、外观模式
定义 为子系统中的一组接口提供一个一致的界面外观模式定义了一个高层接口这一接口使得这一子系统更加容易使用示例海康笔试以电脑启动为例
// CPU 类
class CPU {public void start() {System.out.println(CPU is starting...);}
}// Disk 类
class Disk {public void start() {System.out.println(Disk is starting...);}
}// Memory 类
class Memory {public void start() {System.out.println(Memory is starting...);}
}// 外观类
class ComputerFacade {private CPU cpu;private Disk disk;private Memory memory;public ComputerFacade() {this.cpu new CPU();this.disk new Disk();this.memory new Memory();}public void startComputer() {System.out.println(Starting computer...);disk.start();cpu.start();memory.start();System.out.println(Computer started successfully.);}
}
七、责任链模式
1. 定义 使多个对象都有机会处理请求从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链并沿着这条链传递请求直到有一个对象处理它为止。 2. 示例
在这里插入代码片abstract class Handler {protected Handler successor;public void setSuccessor(Handler successor) {this.successor successor;}public abstract void handleRequest(int request);
}
class ConcreteHandler1 extends Handler {Overridepublic void handleRequest(int request) {if (request 10) {System.out.println(Handler1 handled request request);} else if (successor ! null) {successor.handleRequest(request);}}
}
class ConcreteHandler2 extends Handler {Overridepublic void handleRequest(int request) {if (request 10) {System.out.println(Handler2 handled request request);} else if (successor ! null) {successor.handleRequest(request);}}
}八、Java IO中设计模式
装饰者模式 装饰者模式允许动态地将职责添加到对象中通过将对象封装在装饰对象中来增强对象的功能。InputStream 和 OutputStream 及其子类 2. 适配器模式 适配器模式允许将一个类的接口转换为另一个接口以便不同接口的类可以一起工作。InputStreamReader 和 OutputStreamWriter 类 3. 桥接模式 桥接模式用于将抽象部分与它的实现部分分离使它们可以独立变化。Reader 和 Writer 抽象类及其具体实现类 4. 迭代器模式 迭代器模式用于提供一种方法来顺序访问集合中的每个元素而不暴露其底层表示。Scanner 类用于逐行读取输入 5. 责任链模式 FilterInputStream 和 FilterOutputStream 类 6. 工厂方法模式 FileReader 和 FileWriter 类
