java常见设计模式
时间: 2023-11-05 13:05:52 浏览: 53
Java 常见的设计模式有以下几种:
1. 工厂模式(Factory Pattern)
2. 单例模式(Singleton Pattern)
3. 建造者模式(Builder Pattern)
4. 原型模式(Prototype Pattern)
5. 适配器模式(Adapter Pattern)
6. 桥接模式(Bridge Pattern)
7. 装饰器模式(Decorator Pattern)
8. 组合模式(Composite Pattern)
9. 外观模式(Facade Pattern)
10. 享元模式(Flyweight Pattern)
11. 代理模式(Proxy Pattern)
12. 观察者模式(Observer Pattern)
13. 迭代器模式(Iterator Pattern)
14. 模板方法模式(Template Method Pattern)
15. 策略模式(Strategy Pattern)
16. 命令模式(Command Pattern)
17. 职责链模式(Chain of Responsibility Pattern)
18. 状态模式(State Pattern)
19. 访问者模式(Visitor Pattern)
20. 中介者模式(Mediator Pattern)
21. 解释器模式(Interpreter Pattern)
相关问题:
1. 这些设计模式的应用场景是什么?
2. 如何在 Java 中实现这些设计模式?
3. 这些设计模式有哪些优缺点?
相关问题
java常见设计模式面试
回答: Java中常见的设计模式有很多种,其中一些常见的设计模式包括单例模式、观察者模式、工厂模式、装饰模式等。单例模式是一种常用的设计模式,它保证一个类只有一个实例,并提供全局访问点。在Java中实现线程安全的单例模式可以使用双重检查锁定的方式来实现,如下所示:
```java
public class Singleton {
private static volatile Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
```
观察者模式是一种行为型设计模式,它定义了一种一对多的依赖关系,当被观察对象的状态发生变化时,所有依赖于它的观察者都会得到通知并自动更新。在Java中可以通过使用内置的`Observable`类和`Observer`接口来实现观察者模式。
工厂模式是一种创建型设计模式,它提供了一种将对象的创建和使用分离的方式。使用工厂模式可以将对象的创建过程封装起来,使得代码更加灵活、可维护和可扩展。工厂模式的应用场景包括对象的创建过程比较复杂、需要根据不同的条件创建不同的对象等情况。
装饰模式是一种结构型设计模式,它允许通过将对象包装在装饰器对象中来动态地扩展对象的功能。装饰模式可以在不修改原始对象的情况下,通过添加一些装饰器对象来给对象添加新的功能。在Java中可以使用装饰器模式来扩展类的功能,例如在IO流中的应用。
在Java中,重载是指在同一个类中声明多个方法,它们具有相同的方法名但参数类型或参数个数不同。重载主要用于实现方法的多态性和代码的复用。而重写是指在子类中重新定义父类中已经存在的方法,方法名、参数列表和返回类型必须与父类中的方法相同。重写主要用于实现方法的多态性和实现特定的功能。
Java是可以从静态方法中访问非静态变量的。静态方法可以访问类的静态成员变量和静态方法,但不能访问非静态成员变量和非静态方法。这是因为静态方法在类加载的时候就已经存在,而非静态变量和方法是需要实例化对象后才能访问的。
在选择使用抽象类还是接口时,应该根据具体的需求和设计目标来决定。一般情况下,当多个类需要共享一些通用的代码或属性时,可以使用抽象类。而当多个类需要实现相同的方法或行为时,可以使用接口。抽象类可以提供一些默认的实现,而接口则只能定义方法签名。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* *2* [Java常见设计模式面试题及答案](https://blog.csdn.net/m0_67403076/article/details/126032841)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"]
- *3* [JAVA常见设计模式面试题](https://blog.csdn.net/lzqiang2011/article/details/113251495)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v92^chatsearchT3_1"}}] [.reference_item style="max-width: 50%"]
[ .reference_list ]
Java常见设计模式代码
Java常见的设计模式代码有以下几种:
1. 单例模式:
```java
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;
}
}
```
2. 工厂模式:
```java
public interface Shape {
void draw();
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}
public class ShapeFactory {
public Shape getShape(String shapeType) {
if (shapeType == null) {
return null;
}
if (shapeType.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if (shapeType.equalsIgnoreCase("SQUARE")) {
return new Square();
}
return null;
}
}
// 使用工厂模式获取对象
public class FactoryPatternDemo {
public static void main(String[] args) {
ShapeFactory shapeFactory = new ShapeFactory();
Shape shape1 = shapeFactory.getShape("CIRCLE");
shape1.draw();
Shape shape2 = shapeFactory.getShape("SQUARE");
shape2.draw();
}
}
```
3. 装饰器模式:
```java
public interface Shape {
void draw();
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Shape: Circle");
}
}
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);
}
@Override
public 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();
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();
}
}
```
4. 观察者模式:
```java
public interface Observer {
void update();
}
public class BinaryObserver implements Observer {
@Override
public void update() {
System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
}
}
public class OctalObserver implements Observer {
@Override
public void update() {
System.out.println("Octal String: " + Integer.toOctalString(subject.getState()));
}
}
public class HexaObserver implements Observer {
@Override
public void update() {
System.out.println("Hex String: " + Integer.toHexString(subject.getState()).toUpperCase());
}
}
public class Subject {
private List<Observer> observers = new ArrayList<>();
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();
}
}
}
// 使用观察者模式
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);
}
}
```