目录
一、基础语法
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("example@alipay.com"));
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<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. 完整实现与解析
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. 使用内部类的优化实现
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);
}
});
- 核心思想：定义对象间一对多的依赖关系，当一个对象状态改变时，所有依赖它的对象都得到通知
四、设计模式综合应用示例
电商系统折扣策略案例
// 策略模式：折扣策略
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基本操作
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");
2. 集合遍历
// for-each循环
for(String item : list) {
System.out.println(item);
}
// 迭代器
Iterator<String> 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<String> list = new ArrayList<String>();
// Java 7+：使用<>自动推断
List<String> list = new ArrayList<>(); // 编译器推断为ArrayList<String>
五、设计题高频语法要点
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<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");
六、例题
阅读以下函数说明和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 <iostream>
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 <shape_type>" << 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。此位置是返回实例的引用。
扫一扫
1009
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
