Java编程学习：100个常见代码示例

一、基础语法（1-20）

Hello World

打印“Hello, World!”。

public class HelloWorld {
  public static void main(String[] args) {
      System.out.println("Hello, World!");
  }
}

变量声明与赋值

声明并赋值基本数据类型变量。

int a = 100;
float b = 5.25f;
double c = 5.25;
boolean d = true;
char e = 'A';
String f = "Hello";

条件判断（if-else）

使用if-else判断条件。

int x = 10;
if (x > 5) {
  System.out.println("x is greater than 5");
} else {
  System.out.println("x is less than or equal to 5");
}

条件判断（switch-case）

使用switch-case进行多条件判断。

int day = 3;
switch (day) {
  case 1:
      System.out.println("Monday");
      break;
  case 2:
      System.out.println("Tuesday");
      break;
  default:
      System.out.println("Invalid day");
}

for循环

使用for循环遍历数字。

for (int i = 0; i < 5; i++) {
  System.out.println("i: " + i);
}

while循环

使用while循环。

int i = 0;
while (i < 5) {
  System.out.println("i: " + i);
  i++;
}

do-while循环

使用do-while循环。

int j = 0;
do {
  System.out.println("j: " + j);
  j++;
} while (j < 5);

数组声明与初始化

声明并初始化数组。

int[] arr = new int[5];
arr[0] = 1;
arr[1] = 2;

数组遍历

使用for循环遍历数组。

int[] arr = {1, 2, 3, 4, 5};
for (int i = 0; i < arr.length; i++) {
  System.out.println(arr[i]);
}

方法定义与调用

定义并调用方法。

public static int add(int a, int b) {
  return a + b;
}
int sum = add(5, 3);

方法重载

方法重载示例。

public static int add(int a, int b) {
  return a + b;
}
public static double add(double a, double b) {
  return a + b;
}

字符串操作

字符串拼接和比较。

String str1 = "Hello";
String str2 = "World";
String str3 = str1 + " " + str2;
System.out.println(str3);

字符串长度

获取字符串长度。

String str = "Hello";
int length = str.length();
System.out.println("Length: " + length);

字符串查找

查找字符串中的字符。

String str = "Hello";
int index = str.indexOf('e');
System.out.println("Index: " + index);

字符串替换

替换字符串中的字符。

String str = "Hello";
String newStr = str.replace('e', 'a');
System.out.println(newStr);

字符串分割

分割字符串。

String str = "Hello,World,Java";
String[] parts = str.split(",");
for (String part : parts) {
  System.out.println(part);
}

字符串大小写转换

转换字符串大小写。

String str = "Hello";
String lower = str.toLowerCase();
String upper = str.toUpperCase();
System.out.println(lower + " " + upper);

字符串比较

比较字符串内容。

String str1 = "Hello";
String str2 = "hello";
boolean isEqual = str1.equalsIgnoreCase(str2);
System.out.println(isEqual);

字符串截取

截取字符串。

String str = "Hello";
String sub = str.substring(1, 3);
System.out.println(sub);

字符串格式化

格式化字符串。

String name = "Alice";
int age = 25;
String formatted = String.format("Name: %s, Age: %d", name, age);
System.out.println(formatted);

二、面向对象编程（21-40）

类与对象

定义类并创建对象。

public class Dog {
  String name;

  public void bark() {
      System.out.println(name + " says: Bark!");
  }
}
Dog myDog = new Dog();
myDog.name = "Rex";
myDog.bark();

构造方法

使用构造方法初始化对象。

public class User {
  String name;

  public User(String newName) {
      name = newName;
  }
}
User user = new User("Alice");

继承

类的继承和方法覆盖。

public class Animal {
  void eat() {
      System.out.println("This animal eats food.");
  }
}
public class Dog extends Animal {
  void bark() {
      System.out.println("The dog barks.");
  }
}
Dog dog = new Dog();
dog.eat();
dog.bark();

接口

定义和实现接口。

public interface Animal {
  void eat();
}
public class Dog implements Animal {
  public void eat() {
      System.out.println("The dog eats.");
  }
}
Dog dog = new Dog();
dog.eat();

抽象类

定义和使用抽象类。

public abstract class Animal {
  abstract void eat();
}
public class Dog extends Animal {
  void eat() {
      System.out.println("The dog eats.");
  }
}
Animal dog = new Dog();
dog.eat();

封装

使用private修饰符封装类成员。

public class User {
  private String name;

  public String getName() {
      return name;
  }

  public void setName(String newName) {
      name = newName;
  }
}
User user = new User();
user.setName("Alice");
System.out.println(user.getName());

多态

多态的实现。

public class Animal {
  void makeSound() {
      System.out.println("Some sound");
  }
}
public class Dog extends Animal {
  void makeSound() {
      System.out.println("Bark");
  }
}
Animal myAnimal = new Dog();
myAnimal.makeSound(); // 输出 "Bark"

静态变量和方法

静态变量和静态方法的使用。

public class MathUtils {
  public static final double PI = 3.14159;

  public static double add(double a, double b) {
      return a + b;
  }
}
double circumference = MathUtils.PI * 2 * 5;
System.out.println(circumference);

内部类

内部类的定义和使用。

public class OuterClass {
  private String msg = "Hello";

  class InnerClass {
      void display() {
          System.out.println(msg);
      }
  }

  public void printMessage() {
      InnerClass inner = new InnerClass();
      inner.display();
  }
}
OuterClass outer = new OuterClass();
outer.printMessage();

匿名类

匿名类的使用。

abstract class SaleTodayOnly {
  abstract int dollarsOff();
}
public class Store {
  public SaleTodayOnly sale = new SaleTodayOnly() {
      int dollarsOff() {
          return 3;
      }
  };
}
Store store = new Store();
System.out.println(store.sale.dollarsOff());

枚举类型

定义和使用枚举类型。

public enum Day {
  MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Day day = Day.MONDAY;
System.out.println(day);

枚举方法

枚举类中的方法。

public enum Day {
  MONDAY("Start of the week"),
  TUESDAY("Second day"),
  WEDNESDAY("Middle of the week"),
  THURSDAY("Fourth day"),
  FRIDAY("End of the week"),
  SATURDAY("Weekend"),
  SUNDAY("Weekend");

  private String description;

  Day(String description) {
      this.description = description;
  }

  public String getDescription() {
      return description;
  }
}
Day day = Day.MONDAY;
System.out.println(day.getDescription());

枚举的遍历

遍历枚举类型。

for (Day day : Day.values()) {
  System.out.println(day + ": " + day.getDescription());
}

类的静态初始化块

静态初始化块的使用。

public class MyClass {
  static {
      System.out.println("Static block executed");
  }

  public MyClass() {
      System.out.println("Constructor executed");
  }
}
new MyClass();

类的实例初始化块

实例初始化块的使用。

public class MyClass {
  {
      System.out.println("Instance block executed");
  }

  public MyClass() {
      System.out.println("Constructor executed");
  }
}
new MyClass();

类的静态方法调用

调用静态方法。

public class MyClass {
  public static void myStaticMethod() {
      System.out.println("Static method called");
  }
}
MyClass.myStaticMethod();

类的实例方法调用

调用实例方法。

public class MyClass {
  public void myInstanceMethod() {
      System.out.println("Instance method called");
  }
}
MyClass obj = new MyClass();
obj.myInstanceMethod();

类的继承与方法覆盖

子类覆盖父类方法。

public class Parent {
  void show() {
      System.out.println("Parent's show()");
  }
}
public class Child extends Parent {
  void show() {
      System.out.println("Child's show()");
  }
}
Parent obj = new Child();
obj.show(); // 输出 "Child's show()"

类的继承与方法重写

子类重写父类方法。

public class Parent {
  void show() {
      System.out.println("Parent's show()");
  }
}
public class Child extends Parent {
  @Override
  void show() {
      System.out.println("Child's show()");
  }
}
Child obj = new Child();
obj.show(); // 输出 "Child's show()"

类的继承与方法隐藏

子类隐藏父类的静态方法。

public class Parent {
  static void show() {
      System.out.println("Parent's show()");
  }
}
public class Child extends Parent {
  static void show() {
      System.out.println("Child's show()");
  }
}
Parent obj = new Child();
obj.show(); // 输出 "Parent's show()"

三、高级特性（41-60）

异常处理（try-catch）

使用try-catch捕获异常。

try {
  int result = 10 / 0;
} catch (ArithmeticException e) {
  System.out.println("Error: " + e.getMessage());
}

自定义异常

定义并抛出自定义异常。

public class MyException extends Exception {
  public MyException(String message) {
      super(message);
  }
}
public class Test {
  public static void main(String[] args) {
      try {
          throw new MyException("Custom Exception");
      } catch (MyException e) {
          System.out.println(e.getMessage());
      }
  }
}

异常链

使用异常链传递异常信息。

try {
  throw new Exception("Original Exception");
} catch (Exception e) {
  throw new RuntimeException("New Exception", e);
}

try-with-resources

使用try-with-resources自动关闭资源。

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();
}

泛型类

定义和使用泛型类。

public class Box<T> {
  private T t;

  public void set(T t) {
      this.t = t;
  }

  public T get() {
      return t;
  }
}
Box<String> box = new Box<>();
box.set("Hello");
System.out.println(box.get());

泛型方法

定义和使用泛型方法。

public static <T> void printArray(T[] array) {
  for (T element : array) {
      System.out.println(element);
  }
}
String[] strArray = {"Hello", "World"};
Integer[] intArray = {1, 2, 3};
printArray(strArray);
printArray(intArray);

泛型接口

定义和实现泛型接口。

public interface MyInterface<T> {
  T getValue();
}
public class MyClass implements MyInterface<String> {
  public String getValue() {
      return "Hello";
  }
}
MyClass obj = new MyClass();
System.out.println(obj.getValue());

泛型通配符（上界）

使用泛型通配符（上界）。

public static void printNumbers(List<? extends Number> list) {
  for (Number n : list) {
      System.out.println(n);
  }
}
List<Integer> intList = Arrays.asList(1, 2, 3);
printNumbers(intList);

泛型通配符（下界）

使用泛型通配符（下界）。

public static void addNumbers(List<? super Integer> list) {
  list.add(1);
  list.add(2);
  list.add(3);
}
List<Number> numList = new ArrayList<>();
addNumbers(numList);

Lambda表达式

使用Lambda表达式。

Runnable r = () -> System.out.println("Hello, Lambda!");
r.run();

Lambda表达式与函数式接口

使用Lambda表达式实现函数式接口。

public interface MyFunctionalInterface {
  void execute();
}
MyFunctionalInterface fi = () -> System.out.println("Hello, Functional Interface!");
fi.execute();

Lambda表达式与方法引用

使用方法引用。

public class MyClass {
  public static void printMessage() {
      System.out.println("Hello, Method Reference!");
  }
}
MyFunctionalInterface fi = MyClass::printMessage;
fi.execute();

Lambda表达式与构造器引用

使用构造器引用。

public class MyClass {
  private String message;

  public MyClass(String message) {
      this.message = message;
  }

  public void printMessage() {
      System.out.println(message);
  }
}
Supplier<MyClass> supplier = MyClass::new;
MyClass obj = supplier.get();
obj.printMessage();

Stream API

使用Stream API处理集合。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
numbers.stream()
     .filter(n -> n % 2 == 0)
     .map(n -> n * 2)
     .forEach(System.out::println);

Stream API的排序

使用Stream API对集合排序。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");
names.stream()
   .sorted()
   .forEach(System.out::println);

Stream API的收集

使用Stream API收集结果。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> evenNumbers = numbers.stream()
                                 .filter(n -> n % 2 == 0)
                                 .collect(Collectors.toList());
System.out.println(evenNumbers);

Stream API的归并

使用Stream API进行归并操作。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
int sum = numbers.stream()
               .reduce(0, (a, b) -> a + b);
System.out.println(sum);

Stream API的分组

使用Stream API对集合进行分组。

List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");
Map<Integer, List<String>> groupedByLength = names.stream()
                                               .collect(Collectors.groupingBy(String::length));
System.out.println(groupedByLength);

Stream API的分区

使用Stream API对集合进行分区。

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
Map<Boolean, List<Integer>> partitioned = numbers.stream()
                                               .collect(Collectors.partitioningBy(n -> n % 2 == 0));
System.out.println(partitioned);

Stream API的去重

使用Stream API去除重复元素。

List<Integer> numbers = Arrays.asList(1, 2, 2, 3, 4, 4, 5);
List<Integer> distinctNumbers = numbers.stream()
                                     .distinct()
                                     .collect(Collectors.toList());
System.out.println(distinctNumbers);

四、常用类库（61-80）

ArrayList的使用

使用ArrayList存储和操作数据。

List<String> list = new ArrayList<>();
list.add("Alice");
list.add("Bob");
System.out.println(list);

LinkedList的使用

使用LinkedList存储和操作数据。

List<String> list = new LinkedList<>();
list.add("Alice");
list.add("Bob");
System.out.println(list);

HashMap的使用

使用HashMap存储键值对。

Map<String, Integer> map = new HashMap<>();
map.put("Alice", 25);
map.put("Bob", 30);
System.out.println(map.get("Alice"));

HashSet的使用

使用HashSet存储唯一元素。

Set<String> set = new HashSet<>();
set.add("Alice");
set.add("Bob");
System.out.println(set);

TreeSet的使用

使用TreeSet存储有序元素。

Set<String> set = new TreeSet<>();
set.add("Alice");
set.add("Bob");
System.out.println(set);

PriorityQueue的使用

使用PriorityQueue存储优先级队列。

PriorityQueue<String> queue = new PriorityQueue<>();
queue.add("Alice");
queue.add("Bob");
System.out.println(queue.poll());

Stack的使用

使用Stack实现栈操作。

Stack<String> stack = new Stack<>();
stack.push("Alice");
stack.push("Bob");
System.out.println(stack.pop());

Queue的使用

使用Queue实现队列操作。

Queue<String> queue = new LinkedList<>();
queue.add("Alice");
queue.add("Bob");
System.out.println(queue.poll());

日期和时间（LocalDate）

使用LocalDate表示日期。

LocalDate date = LocalDate.now();
System.out.println(date);

日期和时间（LocalTime）

使用LocalTime表示时间。

LocalTime time = LocalTime.now();
System.out.println(time);

日期和时间（LocalDateTime）

使用LocalDateTime表示日期和时间。

LocalDateTime dateTime = LocalDateTime.now();
System.out.println(dateTime);

日期和时间（格式化）

格式化日期和时间。

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String formatted = LocalDateTime.now().format(formatter);
System.out.println(formatted);

日期和时间（解析）

解析日期和时间字符串。

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime dateTime = LocalDateTime.parse("2025-03-27 12:00:00", formatter);
System.out.println(dateTime);

文件操作（File类）

使用File类操作文件和目录。

File file = new File("example.txt");
if (file.exists()) {
  System.out.println("File exists");
}

文件操作（FileReader和FileWriter）

使用FileReader和FileWriter读写文件。

try (FileWriter writer = new FileWriter("example.txt")) {
  writer.write("Hello, File!");
} catch (IOException e) {
  e.printStackTrace();
}
try (FileReader reader = new FileReader("example.txt")) {
  int ch;
  while ((ch = reader.read()) != -1) {
      System.out.print((char) ch);
  }
} catch (IOException e) {
  e.printStackTrace();
}

文件操作（BufferedReader和BufferedWriter）

使用BufferedReader和BufferedWriter高效读写文件。

try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
  writer.write("Hello, Buffered File!");
} catch (IOException e) {
  e.printStackTrace();
}
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
  String line;
  while ((line = reader.readLine()) != null) {
      System.out.println(line);
  }
} catch (IOException e) {
  e.printStackTrace();
}

文件操作（FileInputStream和FileOutputStream）

使用FileInputStream和FileOutputStream读写二进制文件。

try (FileOutputStream fos = new FileOutputStream("example.bin")) {
  fos.write("Hello, Binary File!".getBytes());
} catch (IOException e) {
  e.printStackTrace();
}
try (FileInputStream fis = new FileInputStream("example.bin")) {
  byte[] data = fis.readAllBytes();
  System.out.println(new String(data));
} catch (IOException e) {
  e.printStackTrace();
}

文件操作（BufferedInputStream和BufferedOutputStream）

使用BufferedInputStream和BufferedOutputStream高效读写二进制文件。

try (BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("example.bin"))) {
  bos.write("Hello, Buffered Binary File!".getBytes());
} catch (IOException e) {
  e.printStackTrace();
}
try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("example.bin"))) {
  byte[] data = bis.readAllBytes();
  System.out.println(new String(data));
} catch (IOException e) {
  e.printStackTrace();
}

文件操作（FileChannel）

使用FileChannel直接操作文件。

try (RandomAccessFile file = new RandomAccessFile("example.txt", "rw");
   FileChannel channel = file.getChannel()) {
  ByteBuffer buffer = ByteBuffer.wrap("Hello, Channel!".getBytes());
  channel.write(buffer);
} catch (IOException e) {
  e.printStackTrace();
}

文件操作（Files类）

使用Files类操作文件和目录。

Path path = Paths.get("example.txt");
try {
  List<String> lines = Files.readAllLines(path);
  lines.forEach(System.out::println);
} catch (IOException e) {
  e.printStackTrace();
}

五、设计模式（81-100）

单例模式

实现单例模式。

public class Singleton {
  private static Singleton instance;

  private Singleton() {}

  public static Singleton getInstance() {
      if (instance == null) {
          instance = new Singleton();
      }
      return instance;
  }
}
Singleton obj = Singleton.getInstance();

工厂模式

实现简单工厂模式。

public interface Shape {
  void draw();
}
public class Circle implements Shape {
  public void draw() {
      System.out.println("Drawing Circle");
  }
}
public class ShapeFactory {
  public Shape getShape(String shapeType) {
      if (shapeType == null) {
          return null;
      }
      if (shapeType.equalsIgnoreCase("CIRCLE")) {
          return new Circle();
      }
      return null;
  }
}
ShapeFactory factory = new ShapeFactory();
Shape shape = factory.getShape("CIRCLE");
shape.draw();

抽象工厂模式

实现抽象工厂模式。

public interface Shape {
  void draw();
}
public interface Color {
  void fill();
}
public class Circle implements Shape {
  public void draw() {
      System.out.println("Drawing Circle");
  }
}
public class RedColor implements Color {
  public void fill() {
      System.out.println("Filling Red Color");
  }
}
public abstract class AbstractFactory {
  abstract Shape getShape(String shapeType);
  abstract Color getColor(String colorType);
}
public class ShapeFactory extends AbstractFactory {
  public Shape getShape(String shapeType) {
      if (shapeType == null) {
          return null;
      }
      if (shapeType.equalsIgnoreCase("CIRCLE")) {
          return new Circle();
      }
      return null;
  }

  public Color getColor(String colorType) {
      return null;
  }
}
AbstractFactory factory = new ShapeFactory();
Shape shape = factory.getShape("CIRCLE");
shape.draw();

建造者模式

实现建造者模式。

public class Computer {
  private String cpu;
  private String ram;
  private String hdd;

  public Computer(String cpu, String ram, String hdd) {
      this.cpu = cpu;
      this.ram = ram;
      this.hdd = hdd;
  }

  public static class Builder {
      private String cpu;
      private String ram;
      private String hdd;

      public Builder setCpu(String cpu) {
          this.cpu = cpu;
          return this;
      }

      public Builder setRam(String ram) {
          this.ram = ram;
          return this;
      }

      public Builder setHdd(String hdd) {
          this.hdd = hdd;
          return this;
      }

      public Computer build() {
          return new Computer(cpu, ram, hdd);
      }
  }
}
Computer computer = new Computer.Builder()
                               .setCpu("Intel i7")
                               .setRam("16GB")
                               .setHdd("1TB")
                               .build();

原型模式

实现原型模式。

public class Prototype implements Cloneable {
  private String field;

  public Prototype(String field) {
      this.field = field;
  }

  public Object clone() throws CloneNotSupportedException {
      return super.clone();
  }

  public String getField() {
      return field;
  }
}
Prototype prototype = new Prototype("Original");
try {
  Prototype cloned = (Prototype) prototype.clone();
  System.out.println(cloned.getField());
} catch (CloneNotSupportedException e) {
  e.printStackTrace();
}

适配器模式

实现适配器模式。

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 {
  public void playVlc(String fileName) {
      System.out.println("Playing VLC file: " + fileName);
  }

  public void playMp4(String fileName) {
      // Do nothing
  }
}
public class MediaAdapter implements MediaPlayer {
  private AdvancedMediaPlayer advancedMediaPlayer;

  public MediaAdapter(String audioType) {
      if (audioType.equalsIgnoreCase("vlc")) {
          advancedMediaPlayer = new VlcPlayer();
      }
  }

  public void play(String audioType, String fileName) {
      if (audioType.equalsIgnoreCase("vlc")) {
          advancedMediaPlayer.playVlc(fileName);
      }
  }
}
MediaPlayer player = new MediaAdapter("vlc");
player.play("vlc", "example.vlc");

桥接模式

实现桥接模式。

public interface DrawingAPI {
  void drawCircle(double x, double y, double radius);
}
public class DrawingAPI1 implements DrawingAPI {
  public void drawCircle(double x, double y, double radius) {
      System.out.println("API1: Drawing Circle at " + x + "," + y + " with radius " + radius);
  }
}
public abstract class Shape {
  protected DrawingAPI drawingAPI;

  protected Shape(DrawingAPI drawingAPI) {
      this.drawingAPI = drawingAPI;
  }

  public abstract void draw();
}
public class CircleShape extends Shape {
  private double x, y, radius;

  public CircleShape(double x, double y, double radius, DrawingAPI drawingAPI) {
      super(drawingAPI);
      this.x = x;
      this.y = y;
      this.radius = radius;
  }

  public void draw() {
      drawingAPI.drawCircle(x, y, radius);
  }
}
Shape circle = new CircleShape(1, 2, 3, new DrawingAPI1());
circle.draw();

装饰器模式

实现装饰器模式。

public interface Component {
  void operation();
}
public class ConcreteComponent implements Component {
  public void operation() {
      System.out.println("ConcreteComponent Operation");
  }
}
public abstract class Decorator implements Component {
  protected Component component;

  public Decorator(Component component) {
      this.component = component;
  }

  public void operation() {
      component.operation();
  }
}
public class ConcreteDecoratorA extends Decorator {
  public ConcreteDecoratorA(Component component) {
      super(component);
  }

  public void operation() {
      super.operation();
      addedBehavior();
  }

  private void addedBehavior() {
      System.out.println("Added Behavior A");
  }
}
Component component = new ConcreteComponent();
Component decoratedComponent = new ConcreteDecoratorA(component);
decoratedComponent.operation();

代理模式

实现代理模式。

public interface Subject {
  void request();
}
public class RealSubject implements Subject {
  public void request() {
      System.out.println("RealSubject: Handling request.");
  }
}
public class Proxy implements Subject {
  private RealSubject realSubject;

  public void request() {
      if (realSubject == null) {
          realSubject = new RealSubject();
      }
      preRequest();
      realSubject.request();
      postRequest();
  }

  private void preRequest() {
      System.out.println("Proxy: Logging request.");
  }

  private void postRequest() {
      System.out.println("Proxy: Logging request complete.");
  }
}
Subject proxy = new Proxy();
proxy.request();

外观模式

实现外观模式。

public class SubsystemA {
  public void operationA() {
      System.out.println("SubsystemA: Operation A");
  }
}
public class SubsystemB {
  public void operationB() {
      System.out.println("SubsystemB: Operation B");
  }
}
public class Facade {
  private SubsystemA subsystemA;
  private SubsystemB subsystemB;

  public Facade() {
      subsystemA = new SubsystemA();
      subsystemB = new SubsystemB();
  }

  public void operation() {
      subsystemA.operationA();
      subsystemB.operationB();
  }
}
Facade facade = new Facade();
facade.operation();

享元模式

实现享元模式。

public class Flyweight {
  private String intrinsicState;

  public Flyweight(String intrinsicState) {
      this.intrinsicState = intrinsicState;
  }

  public void operation(String extrinsicState) {
      System.out.println("Intrinsic State: " + intrinsicState + ", Extrinsic State: " + extrinsicState);
  }
}
public class FlyweightFactory {
  private Map<String, Flyweight> flyweights = new HashMap<>();

  public Flyweight getFlyweight(String intrinsicState) {
      if (!flyweights.containsKey(intrinsicState)) {
          flyweights.put(intrinsicState, new Flyweight(intrinsicState));
      }
      return flyweights.get(intrinsicState);
  }
}
FlyweightFactory factory = new FlyweightFactory();
Flyweight flyweight1 = factory.getFlyweight("A");
Flyweight flyweight2 = factory.getFlyweight("A");
flyweight1.operation("Extrinsic State");
flyweight2.operation("Extrinsic State");

组合模式

实现组合模式。

public interface Component {
  void operation();
}
public class Leaf implements Component {
  public void operation() {
      System.out.println("Leaf: Operation");
  }
}
public class Composite implements Component {
  private List<Component> children = new ArrayList<>();

  public void add(Component component) {
      children.add(component);
  }

  public void remove(Component component) {
      children.remove(component);
  }

  public void operation() {
      for (Component child : children) {
          child.operation();
      }
  }
}
Composite composite = new Composite();
composite.add(new Leaf());
composite.add(new Leaf());
composite.operation();

命令模式

实现命令模式。

public interface Command {
  void execute();
}
public class ConcreteCommand implements Command {
  private Receiver receiver;

  public ConcreteCommand(Receiver receiver) {
      this.receiver = receiver;
  }

  public void execute() {
      receiver.action();
  }
}
public class Receiver {
  public void action() {
      System.out.println("Receiver: Action");
  }
}
Receiver receiver = new Receiver();
Command command = new ConcreteCommand(receiver);
command.execute();

责任链模式

实现责任链模式。

public abstract class Handler {
  protected Handler successor;

  public void setSuccessor(Handler successor) {
      this.successor = successor;
  }

  public abstract void handleRequest();
}
public class ConcreteHandlerA extends Handler {
  public void handleRequest() {
      System.out.println("ConcreteHandlerA: Handling request");
      if (successor != null) {
          successor.handleRequest();
      }
  }
}
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerA();
handlerA.setSuccessor(handlerB);
handlerA.handleRequest();

观察者模式

实现观察者模式。

public interface Observer {
  void update(String message);
}
public interface Subject {
  void register(Observer obj);
  void unregister(Observer obj);
  void notifyObservers();
}
public class ConcreteSubject implements Subject {
  private List<Observer> observers = new ArrayList<>();

  public void register(Observer obj) {
      observers.add(obj);
  }

  public void unregister(Observer obj) {
      observers.remove(obj);
  }

  public void notifyObservers() {
      for (Observer observer : observers) {
          observer.update("Notification");
      }
  }
}
public class ConcreteObserver implements Observer {
  public void update(String message) {
      System.out.println("Observer: Received message - " + message);
  }
}
ConcreteSubject subject = new ConcreteSubject();
Observer observer1 = new ConcreteObserver();
Observer observer2 = new ConcreteObserver();
subject.register(observer1);
subject.register(observer2);
subject.notifyObservers();

状态模式

实现状态模式。

public interface State {
  void handle(Context context);
}
public class ConcreteStateA implements State {
  public void handle(Context context) {
      System.out.println("ConcreteStateA: Handling request");
      context.setState(new ConcreteStateB());
  }
}
public class Context {
  private State currentState;

  public Context(State state) {
      this.currentState = state;
  }

  public void setState(State state) {
      this.currentState = state;
  }

  public void request() {
      currentState.handle(this);
  }
}
Context context = new Context(new ConcreteStateA());
context.request();

策略模式

实现策略模式。

public interface Strategy {
  void execute();
}
public class ConcreteStrategyA implements Strategy {
  public void execute() {
      System.out.println("ConcreteStrategyA: Executing");
  }
}
public class Context {
  private Strategy strategy;

  public Context(Strategy strategy) {
      this.strategy = strategy;
  }

  public void executeStrategy() {
      strategy.execute();
  }
}
Context context = new Context(new ConcreteStrategyA());
context.executeStrategy();

模板方法模式

实现模板方法模式。

public abstract class Template {
  public final void templateMethod() {
      step1();
      step2();
  }

  protected abstract void step1();
  protected abstract void step2();
}
public class ConcreteTemplate extends Template {
  protected void step1() {
      System.out.println("ConcreteTemplate: Step 1");
  }

  protected void step2() {
      System.out.println("ConcreteTemplate: Step 2");
  }
}
Template template = new ConcreteTemplate();
template.templateMethod();

访问者模式

实现访问者模式。

public interface Visitor {
  void visit(Element element);
}
public interface Element {
  void accept(Visitor visitor);
}
public class ConcreteElementA implements Element {
  public void accept(Visitor visitor) {
      visitor.visit(this);
  }
}
public class ConcreteVisitor implements Visitor {
  public void visit(Element element) {
      System.out.println("ConcreteVisitor: Visiting " + element.getClass().getSimpleName());
  }
}
Element element = new ConcreteElementA();
Visitor visitor = new ConcreteVisitor();
element.accept(visitor);

备忘录模式

实现备忘录模式。

public class Memento {
 private String state;

 public Memento(String state) {
     this.state = state;
 }

 public String getState() {
     return state;
 }
}
public class Originator {
 private String state;

 public void setState(String state) {
     this.state = state;
 }

 public Memento saveStateToMemento() {
     return new Memento(state);
 }

 public void getStateFromMemento(Memento memento) {
     state = memento.getState();
 }
}
Originator originator = new Originator();
originator.setState("State1");
Memento memento = originator.saveStateToMemento();
originator.setState("State2");
originator.getStateFromMemento(memento);
System.out.println(originator.getState());

posted @ 2025-03-27 13:17 软件职业规划阅读(15) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

昵称：软件职业规划
园龄： 2年4个月
粉丝： 4
关注： 0

+加关注

2025年4月

日

一

二

三

四

五

六

Java编程学习：100个常见代码示例

一、基础语法（1-20）

二、面向对象编程（21-40）

三、高级特性（41-60）

四、常用类库（61-80）

五、设计模式（81-100）

公告

搜索

常用链接

随笔分类

随笔档案

阅读排行榜

推荐排行榜