Java程序题案例分析
目录
一、基础语法
1. 类与对象
2. 接口与抽象类
二、面向对象语法
1. 继承与多态
2. 四种访问修饰符
三、设计模式相关语法
一、策略模式（接口回调实现）
1. 完整实现与解析
二、工厂模式（静态工厂方法实现）
1. 完整实现与解析
2. 模式变体
(1) 简单工厂模式（如上例）
(2) 工厂方法模式
三、观察者模式（内部类实现）
1. 完整实现与解析
2. 使用内部类的优化实现
四、设计模式综合应用示例
电商系统折扣策略案例
四、其他核心语法
1. List/Set/Map基本操作
2. 集合遍历
3.异常处理语法
4.IO基础语法
5.泛型类型推断
五、设计题高频语法要点
1. 枚举类型(状态模式常用)
2. 泛型(提高代码复用性)
六、例题
一、基础语法
1. 类与对象
// 类定义
public class ClassName {
// 字段(成员变量)
private int field;
// 构造方法
public ClassName(int param) {
this.field = param;
}
// 方法
public void methodName() {
// 方法体
}
}
// 对象创建与使用
ClassName obj = new ClassName(10);
obj.methodName();
2. 接口与抽象类
// 接口定义
public interface InterfaceName {
void abstractMethod();
// Java8+默认方法
default void defaultMethod() {
// 实现
}
}
// 抽象类定义
public abstract class AbstractClass {
public abstract void abstractMethod();
public void concreteMethod() {
// 实现
}
}
二、面向对象语法
1. 继承与多态
class Parent {
public void show() {
System.out.println("Parent");
}
}
class Child extends Parent {
@Override
public void show() {
System.out.println("Child");
}
}
// 多态示例
Parent obj = new Child();
obj.show(); // 输出"Child"
2. 四种访问修饰符
public- 所有类可见protected- 同包及子类可见默认(无修饰符)- 同包可见private- 仅本类可见
三、设计模式相关语法
一、策略模式（接口回调实现）
interface Strategy {
void execute();
}
class Context {
private Strategy strategy;
public void setStrategy(Strategy s) {
this.strategy = s;
}
public void executeStrategy() {
strategy.execute();
}
}
1. 完整实现与解析
// 策略接口
interface PaymentStrategy {
void pay(double amount);
}
// 具体策略类
class CreditCardPayment implements PaymentStrategy {
private String cardNumber;
public CreditCardPayment(String cardNumber) {
this.cardNumber = cardNumber;
}
@Override
public void pay(double amount) {
System.out.println("使用信用卡" + cardNumber + "支付" + amount + "元");
}
}
class AlipayPayment implements PaymentStrategy {
private String account;
public AlipayPayment(String account) {
this.account = account;
}
@Override
public void pay(double amount) {
System.out.println("使用支付宝账户" + account + "支付" + amount + "元");
}
}
// 上下文类
class PaymentContext {
private PaymentStrategy strategy;
public void setStrategy(PaymentStrategy strategy) {
this.strategy = strategy;
}
public void executePayment(double amount) {
strategy.pay(amount);
}
}
// 使用示例
public class StrategyDemo {
public static void main(String[] args) {
PaymentContext context = new PaymentContext();
// 使用信用卡支付
context.setStrategy(new CreditCardPayment("1234-5678-9012-3456"));
context.executePayment(100.0);
// 切换为支付宝支付
context.setStrategy(new AlipayPayment("[email protected]"));
context.executePayment(200.0);
}
}
- 核心思想：定义算法族，分别封装起来，使它们可以互相替换
二、工厂模式（静态工厂方法实现）
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. 完整实现与解析
// 产品接口
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) 工厂方法模式
interface ShapeFactory {
Shape createShape();
}
class CircleFactory implements ShapeFactory {
public Shape createShape() {
return new Circle();
}
}
class RectangleFactory implements ShapeFactory {
public Shape createShape() {
return new Rectangle();
}
}
- 核心思想：将对象的创建与使用分离
三、观察者模式（内部类实现）
class Subject {
private List 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. 完整实现与解析
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 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. 使用内部类的优化实现
class WeatherData {
private List 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);
}
});
- 核心思想：定义对象间一对多的依赖关系，当一个对象状态改变时，所有依赖它的对象都得到通知
四、设计模式综合应用示例
电商系统折扣策略案例
// 策略模式：折扣策略
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 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基本操作
List list = new ArrayList<>();
list.add("Java");
list.get(0);
Set set = new HashSet<>();
set.add(1);
set.contains(1);
Map map = new HashMap<>();
map.put("age", 25);
map.get("age");
2. 集合遍历
// for-each循环
for(String item : list) {
System.out.println(item);
}
// 迭代器
Iterator it = list.iterator();
while(it.hasNext()) {
System.out.println(it.next());
}
// Lambda表达式(Java8+)
list.forEach(item -> System.out.println(item));
3.异常处理语法
try {
// 可能抛出异常的代码
int result = 10 / 0;
} catch (ArithmeticException e) {
System.err.println("除零错误: " + e.getMessage());
} finally {
System.out.println("总会执行的代码");
}
4.IO基础语法
// 文件读取
try (BufferedReader br = new BufferedReader(new FileReader("file.txt"))) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
5.泛型类型推断
通过泛型指定集合只能存储String类型，避免运行时ClassCastException：
// Java 5/6：需重复声明类型
List list = new ArrayList();
// Java 7+：使用<>自动推断
List list = new ArrayList<>(); // 编译器推断为ArrayList
五、设计题高频语法要点
1. 枚举类型(状态模式常用)
enum State {
START, RUNNING, STOPPED
}
public class StateMachine {
private State current = State.START;
public void changeState(State newState) {
this.current = newState;
}
}
2. 泛型(提高代码复用性)
class Box {
private T content;
public void set(T content) {
this.content = content;
}
public T get() {
return content;
}
}
// 使用
Box stringBox = new Box<>();
stringBox.set("Hello");
六、例题
阅读以下函数说明和Java代码，将应填入(n)处的子句写在答题纸的对应栏内。
【说明】
现有一个显示系统，要显示的图形有线Line、矩形Square，抽象出一个Shape类(接口)，有方法显示display()。
需要新增图形Circle，又已知有类XXCircle实现了所需要实现的功能：显示displayIt()。为了继承自Shape以提供统一接口，又不希望从头开发代码，希望使用XXCircle。这样将XXCircle作为Circle的一个属性，即Circle的对象包含一个XXCircle对象。当一个Circle对象被实例化时，它必须实例化一个相应的XXCircle对象；Circle对象收到的做任何事的请求都将转发给这个XXCircle对象。通过这种被称为Adapter的模式，Circle对象就可以通过“让XXCircle做实际工作”来表现自己的行为了。图7 - 52显示了各个类间的关系。以下是Java语言实现，能够正确编译通过。
图7 - 52 各个类之间的关系
【Java程序】
//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; } }
- (1) abstract：表示接口
Shape中display方法的抽象性质。在Java接口里，方法默认是public和abstract的，写abstract明确该方法需由实现类去具体实现。 - (2) implements：用于
Circle类声明实现Shape接口。在Java中，类通过implements关键字来表明遵循某个接口的契约，要实现接口里的抽象方法。 - (3) new XXCircle()：用于在
Circle类中实例化XXCircle对象pcx，创建一个XXCircle类的实例供后续使用。 - (4) Shape：这是
Factory类中getShapeInstance方法的返回类型。因为该方法返回的可能是Line、Square或Circle等不同形状类的实例，而这些类都实现了Shape接口，所以返回类型是Shape接口类型，以实现多态。 - (5) getShapeInstance(type)：在
Main类中，通过Factory类的实例factory调用getShapeInstance方法，并传入参数type，以此获取对应的形状实例。
#include
using namespace std;
class Shape {
public:
virtual void display() = 0; // (1) 纯虚函数声明
};
class Line : public Shape {
public:
void display() override {
cout << "Displaying Line" << endl;
}
};
class Square : public Shape {
public:
void display() override {
cout << "Displaying Square" << endl;
}
};
class XXCircle {
public:
void displayIt() {
cout << "Displaying XXCircle" << endl;
}
};
class Circle : public Shape {
private:
XXCircle *pxc;
public:
Circle();
void display() override;
};
Circle::Circle() {
pxc = new XXCircle(); // (2) 创建XXCircle对象
}
void Circle::display() {
pxc->displayIt(); // (3) 调用XXCircle的显示方法
}
class Factory {
public:
Shape* getShapeInstance(int type) { // (4) 返回Shape指针类型
switch(type) {
case 1: return new Square();
case 2: return new Line();
case 3: return new Circle();
default: return nullptr;
}
}
};
int main(int argc, char *argv[]) {
if(argc != 2) {
cout << "Usage: program " << endl;
cout << "Shape types: 1=Square, 2=Line, 3=Circle" << endl;
return 1;
}
int type = atoi(argv[1]);
Factory factory;
Shape *s = factory.getShapeInstance(type); // (5) 获取形状实例
if(s == nullptr) {
cout << "Error: Invalid shape type!" << endl;
return 1;
}
s->display();
delete s;
return 0;
}
virtual void display() = 0;- 声明纯虚函数，使Shape成为抽象类new XXCircle()- 创建XXCircle对象实例displayIt()- 调用XXCircle的显示方法Shape*- 工厂方法返回Shape基类指针getShapeInstance(type)- 调用工厂方法获取形状实例
阅读以下函数说明和Java代码，将应填入(n)处的子句写在答题纸的对应栏内。
【说明】 很多时候，希望某些类只有一个或有限的几个实例，典型解决方案是所谓单身(Singleton)模式。但在多线程情况下，Singleton模式有可能出现问题，需要进行同步检查。如果对“检查Singleton对象是否已经创建”进行同步，则存在严重的瓶颈，所有的线程都必须等待检查对象是否存在。解决方式是一种称为Double-Checked-Locking的模式，其意图是将非必需的锁定优化掉，同步检查最多只发生一次，因此不会成为瓶颈。以下是Java语言实现，能够正确编译通过。
【Java程序】
public class USTax { private static USTax instance = null; (1) USTax() {} private (2) static void doSync() { if(instance == null) { System.out.println("实例不存在，创建实例..."); instance = (3); System.out.println("实例创建成功"); }else{ System.out.println("实例已被创建"); } } public static USTax getInstance() { if(instance == null) { System.out.println("实例暂时不存在"); (4); //同步控制 }else{ System.out.println("实例已经存在"); } return (5); } }
- (1)：答案为
private。因为希望USTax类只有一个实例，将构造函数设为private可防止外部直接实例化。 - (2)：答案是
synchronized。doSync方法用于同步控制，所以要声明为synchronized。 - (3)：应填
new USTax()。此处是创建USTax实例。 - (4)：答案是
doSync()。进行同步控制需调用同步函数doSync。 - (5)：应填
instance。此位置是返回实例的引用。