java23种设计模式
在Java编程中，有23种常见的设计模式，它们被分为三个不同的分类：创建型模式（Creational Patterns）、结构型模式（Structural Patterns）和行为型模式（Behavioral Patterns）。以下是对每种设计模式的简要介绍以及示例代码：
1. 创建型模式（Creational Patterns）：
a. 单例模式（Singleton Pattern）：确保一个类只有一个实例，并提供全局访问点。
```java
public class Singleton {
private static Singleton instance;
private Singleton() {
// 私有构造函数
}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
```
b. 工厂模式（Factory Pattern）：通过使用工厂方法创建对象，而不直接实例化对象。
```java
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a rectangle.");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a circle.");
}
}
public class ShapeFactory {
public Shape createShape(String shapeType) {
if (shapeType.equalsIgnoreCase("rectangle")) {
return new Rectangle();
} else if (shapeType.equalsIgnoreCase("circle")) {
return new Circle();
}
return null;
}
}
// 使用示例
ShapeFactory factory = new ShapeFactory();
Shape rectangle = factory.createShape("rectangle");
rectangle.draw();
Shape circle = factory.createShape("circle");
circle.draw();
```
c. 抽象工厂模式（Abstract Factory Pattern）：提供一个接口，用于创建相关或依赖对象的家族，而无需指定具体类。
```java
public interface Shape {
void draw();
}
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a rectangle.");
}
}
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Drawing a circle.");
}
}
public interface Color {
void fill();
}
public class Red implements Color {
@Override
public void fill() {
System.out.println("Filling with red color.");
}
}
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Filling with blue color.");
}
}
public interface AbstractFactory {
Shape createShape();
Color createColor();
}
public class ShapeFactory implements AbstractFactory {
@Override
public Shape createShape() {
return new Rectangle();
}
@Override
public Color createColor() {
return new Red();
}
}
public class ColorFactory implements AbstractFactory {
@Override
public Shape createShape() {
return new Circle();
}
@Override
public Color createColor() {
return new Blue();
}
}
// 使用示例
AbstractFactory shapeFactory = new ShapeFactory();
Shape shape = shapeFactory.createShape();
shape.draw();
Color color = shapeFactory.createColor();
color.fill();
AbstractFactory colorFactory = new ColorFactory();
Shape shape = colorFactory.createShape();
shape.draw();
Color color = colorFactory.createColor();
color.fill();
```
d. 建造者模式（Builder Pattern）：将一个复杂对象的构建与其表示分别，以便同样的构建过程可以创建不同的表示。
```java
public class Car {
private String brand;
private String model;
private int year;
private Car(Builder builder) {
this.brand = builder.brand;
this.model = builder.model;
this.year = builder.year;
}
public String getBrand() {
return brand;
}
public String getModel() {
return model;
}
public int getYear() {
return year;
}
public static class Builder {
private String brand;
private String model;
private int year;
public Builder setBrand(String brand) {
this.brand = brand;
return this;
}
public Builder setModel(String model) {
this.model = model;
return this;
}
public Builder setYear(int year) {
this.year = year;
return this;
}
public Car build() {
return new Car(this);
}
}
}
// 使用示例
Car car = new Car.Builder()
.setBrand("Toyota")
.setModel("Camry")
.setYear(2022)
.build();
System.out.println("Brand: " + car.getBrand());
System.out.println("Model: " + car.getModel());
System.out.println("Year: " + car.getYear());
```
2. 结构型模式（Structural Patterns）：
a. 适配器模式（Adapter Pattern）：将一个类的接口转换成客户端期望的另一个接口。
```java
public interface MediaPlayer {
void play(String audioType, String fileName);
}
public interface AdvancedMediaPlayer {
void playVlc(String fileName);
void playMp4(String fileName);
}
public class VlcPlayer implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
System.out.println("Playing vlc file: " + fileName);
}
@Override
public void playMp4(String fileName) {
// 空实现
}
}
public class Mp4Player implements AdvancedMediaPlayer {
@Override
public void playVlc(String fileName) {
// 空实现
}
@Override
public void playMp4(String fileName) {
System.out.println("Playing mp4 file: " + fileName);
}
}
public class MediaAdapter implements MediaPlayer {
private AdvancedMediaPlayer advancedMediaPlayer;
public MediaAdapter(String audioType) {
if (audioType.equalsIgnoreCase("vlc")) {
advancedMediaPlayer = new VlcPlayer();
} else if (audioType.equalsIgnoreCase("mp4")) {
advancedMediaPlayer = new Mp4Player();
}
}
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("vlc")) {
advancedMediaPlayer.playVlc(fileName);
} else if (audioType.equalsIgnoreCase("mp4")) {
advancedMediaPlayer.playMp4(fileName);
}
}
}
public class AudioPlayer implements MediaPlayer {
private MediaAdapter mediaAdapter;
@Override
public void play(String audioType, String fileName) {
if (audioType.equalsIgnoreCase("mp3")) {
System.out.println("Playing mp3 file: " + fileName);
} else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
mediaAdapter = new MediaAdapter(audioType);
mediaAdapter.play(audioType, fileName);
} else {
System.out.println("Invalid media type: " + audioType);
}
}
}
// 使用示例
MediaPlayer audioPlayer = new AudioPlayer();
audioPlayer.play("mp3", "song.mp3");
audioPlayer.play("vlc", "movie.vlc");
audioPlayer.play("mp4", "video.mp4");
audioPlayer.play("avi", "movie.avi");
```
b. 桥接模式（Bridge Pattern）：将抽象部分与其具体实现部分分离，使它们可以独立变化。
```java
public interface Color {
void applyColor();
}
public class Red implements Color {
@Override
public void applyColor() {
System.out.println("Applying red color.");
}
}
public class Blue implements Color {
@Override
public void applyColor() {
System.out.println("Applying blue color.");
}
}
public abstract class Shape {
protected Color color;
public Shape(Color color) {
this.color = color;
}
abstract void applyColor();
}
public class Square extends Shape {
public Square(Color color) {
super(color);
}
@Override
void applyColor() {
System.out.print("Square ");
color.applyColor();
}
}
public class Circle extends Shape {
public Circle(Color color) {
super(color);
}
@Override
void applyColor() {
System.out.print("Circle ");
color.applyColor();
}
}
// 使用示例
Color redColor = new Red();
Shape square = new Square(redColor);
square.applyColor();
Color blueColor = new Blue();
Shape circle = new Circle(blueColor);
circle.applyColor();
```
3. 行为型模式（Behavioral Patterns）：
a. 观察者模式（Observer Pattern）：定义对象之间的一对多依赖关系，当一个对象状态改变时，其所有依赖者都会收到通知并自动更新。
```java
import java.util.ArrayList;
import java.util.List;
public interface Observer {
void update(String message);
}
public class User implements Observer {
private String name;
public User(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + " received a new message: " + message);
}
}
public interface Subject {
void attach(Observer observer);
void detach(Observer observer);
void notifyObservers(String message);
}
public class ChatRoom implements Subject {
private List
