class ProductFactory {
public static Product createProduct(String type) {
switch(type) {
case "A": return new ProductA();
case "B": return new ProductB();
default: throw new IllegalArgumentException();
}
}
}
1. 完整实现与解析
java复制代码
// 产品接口
interface Shape {
void draw();
}
// 具体产品类
class Circle implements Shape {
@Override
public void draw() {
System.out.println("绘制圆形");
}
}
class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("绘制矩形");
}
}
// 工厂类
class ShapeFactory {
// 静态工厂方法
public static Shape createShape(String type) {
if(type == null) {
return null;
}
if(type.equalsIgnoreCase("CIRCLE")) {
return new Circle();
} else if(type.equalsIgnoreCase("RECTANGLE")) {
return new Rectangle();
}
throw new IllegalArgumentException("不支持的形状类型");
}
}
// 使用示例
public class FactoryDemo {
public static void main(String[] args) {
// 使用工厂创建对象
Shape circle = ShapeFactory.createShape("circle");
circle.draw();
Shape rectangle = ShapeFactory.createShape("rectangle");
rectangle.draw();
}
}
2. 模式变体
(1) 简单工厂模式（如上例）
(2) 工厂方法模式
java复制代码
interface ShapeFactory {
Shape createShape();
}
class CircleFactory implements ShapeFactory {
public Shape createShape() {
return new Circle();
}
}
class RectangleFactory implements ShapeFactory {
public Shape createShape() {
return new Rectangle();
}
}
核心思想：将对象的创建与使用分离
三、观察者模式（内部类实现）
java复制代码
class Subject {
private List<Observer> observers = new ArrayList<>();
public void addObserver(Observer o) {
observers.add(o);
}
public void notifyObservers() {
for(Observer o : observers) {
o.update();
}
}
// 观察者接口
interface Observer {
void update();
}
}
1. 完整实现与解析
java复制代码
import java.util.ArrayList;
import java.util.List;
// 主题接口
interface Subject {
void registerObserver(Observer o);
void removeObserver(Observer o);
void notifyObservers();
}
// 具体主题类
class WeatherData implements Subject {
private List<Observer> observers;
private float temperature;
public WeatherData() {
observers = new ArrayList<>();
}
@Override
public void registerObserver(Observer o) {
observers.add(o);
}
@Override
public void removeObserver(Observer o) {
observers.remove(o);
}
@Override
public void notifyObservers() {
for(Observer observer : observers) {
observer.update(temperature);
}
}
// 业务方法：当气象站数据更新时调用
public void measurementsChanged(float newTemp) {
this.temperature = newTemp;
notifyObservers();
}
}
// 观察者接口
interface Observer {
void update(float temperature);
}
// 具体观察者类
class CurrentConditionsDisplay implements Observer {
@Override
public void update(float temperature) {
System.out.println("当前温度: " + temperature + "℃");
}
}
// 使用示例
public class ObserverDemo {
public static void main(String[] args) {
WeatherData weatherData = new WeatherData();
CurrentConditionsDisplay display = new CurrentConditionsDisplay();
// 注册观察者
weatherData.registerObserver(display);
// 模拟数据变化
weatherData.measurementsChanged(25.5f);
weatherData.measurementsChanged(26.0f);
}
}
2. 使用内部类的优化实现
java复制代码
class WeatherData {
private List<Observer> observers = new ArrayList<>();
private float temperature;
// 内部接口
public interface Observer {
void update(float temp);
}
public void addObserver(Observer o) {
observers.add(o);
}
public void setMeasurements(float temp) {
this.temperature = temp;
notifyObservers();
}
private void notifyObservers() {
for(Observer o : observers) {
o.update(temperature);
}
}
}
// 使用匿名内部类
WeatherData weather = new WeatherData();
weather.addObserver(new WeatherData.Observer() {
@Override
public void update(float temp) {
System.out.println("温度更新: " + temp);
}
});
核心思想：定义对象间一对多的依赖关系，当一个对象状态改变时，所有依赖它的对象都得到通知
四、设计模式综合应用示例
电商系统折扣策略案例
java复制代码
// 策略模式：折扣策略
interface DiscountStrategy {
double applyDiscount(double originalPrice);
}
class NoDiscount implements DiscountStrategy {
public double applyDiscount(double price) {
return price;
}
}
class PercentageDiscount implements DiscountStrategy {
private double percentage;
public PercentageDiscount(double percentage) {
this.percentage = percentage;
}
public double applyDiscount(double price) {
return price * (1 - percentage/100);
}
}
// 工厂模式：创建折扣策略
class DiscountStrategyFactory {
public static DiscountStrategy createStrategy(String type, double param) {
switch(type) {
case "NONE": return new NoDiscount();
case "PERCENT": return new PercentageDiscount(param);
default: throw new IllegalArgumentException();
}
}
}
// 观察者模式：订单状态通知
class Order {
private List<OrderObserver> observers = new ArrayList<>();
private String status;
public interface OrderObserver {
void update(String orderStatus);
}
public void addObserver(OrderObserver o) {
observers.add(o);
}
public void setStatus(String status) {
this.status = status;
notifyObservers();
}
private void notifyObservers() {
for(OrderObserver o : observers) {
o.update(status);
}
}
}
模式识别：快速判断题目要求使用的设计模式
类图转换：能够将UML类图转换为Java代码
模式组合：注意多种设计模式的组合使用
代码规范 ：
类名使用大驼峰
方法名使用小驼峰
设计原则 ：
单一职责原则
接口隔离原则
四、其他核心语法
1. List/Set/Map基本操作
java复制代码
List<String> list = new ArrayList<>();
list.add("Java");
list.get(0);
Set<Integer> set = new HashSet<>();
set.add(1);
set.contains(1);
Map<String, Integer> map = new HashMap<>();
map.put("age", 25);
map.get("age");
// Java 5/6：需重复声明类型
List<String> list = new ArrayList<String>();
// Java 7+：使用<>自动推断
List<String> list = new ArrayList<>(); // 编译器推断为ArrayList<String>
五、设计题高频语法要点
1. 枚举类型(状态模式常用)
java复制代码
enum State {
START, RUNNING, STOPPED
}
public class StateMachine {
private State current = State.START;
public void changeState(State newState) {
this.current = newState;
}
}
2. 泛型(提高代码复用性)
java复制代码
class Box<T> {
private T content;
public void set(T content) {
this.content = content;
}
public T get() {
return content;
}
}
// 使用
Box<String> stringBox = new Box<>();
stringBox.set("Hello");
//Shape.java文件
public interface Shape {
public (1) abstract void display();
}
//XXCircle.java文件
public class XXCircle {
public void displayIt() {
//省略具体实现
}
}
//Circle.java文件
public class Circle (2) implements Shape {
private XXCircle pcx = (3) new XXCircle();
public void display() {
pcx.displayIt();
}
}
//Factory.java文件
public class Factory {
public (4) static Shape getShapeInstance(int type) {
switch (type) {
case 1: return new Line();//Line类未定义，假设存在
case 2: return new Square();//Square类未定义，假设存在
case 3: return new Circle();
default: return null;
}
}
}
//Main.java文件
public class Main {
public static void main(String[] args) {
int type = 1;
Factory factory = new Factory();
Shape s;
s = factory.(5) getShapeInstance(type);
if (s == null) {
System.out.println("Error get the instance!");
return;
}
s.display();
return;
}
}
