共计 3301 个字符，预计需要花费 9 分钟才能阅读完成。
在计算机编程领域中，面向对象编程（Object-Oriented Programming）是一种非常常用的编程范型。而在 Java 这种面向对象语言中，有封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）等核心概念，以及设计模式（Design Pattern）等高级特性。本文将对这些内容进行详细的介绍，并结合实例加深理解。
封装
封装是指将一个类的属性和方法进行合理的保护，使其不受外部干扰，同时提供公共接口供外部使用。在 Java 中，可以通过 private、protected、public 等关键字来定义某个成员变量或方法的可见性。下面是一个示例：
public class Person {
private String name; // 私有成员变量
private int age;
public void setName(String name) { // 公有方法
this.name = name;
}
public String getName() {return this.name;}
// ... 其他方法和成员变量
}
在上面的代码中，name 和 age 被定义为私有成员变量，只能在 Person 类内部访问。而 setName 和 getName 则是公有方法，可供外部调用来设置或获取 name 属性值。
继承
继承是指在一个已有的类基础上，通过添加新的属性和方法来创建一个新类的过程。在 Java 中，通过 extends 关键字来实现继承。下面是一个示例：
public class Student extends Person {
private String school;
public void setSchool(String school) {this.school = school;}
public String getSchool() {return this.school;}
// ... 其他方法和成员变量
}
在上面的代码中，我们定义了一个 Student 类，它继承了 Person 类，并新增了一个 school 属性和相应的 setter 和 getter 方法。因此，所有 Person 类中的属性和方法都可以在 Student 类中被使用。这样，我们就可以更好地复用已有的代码，提高程序的可维护性和效率。
多态
多态是指同一种行为或操作具有多个不同的表现形式或状态的能力，即对象在不同的情况下会表现出不同的行为。在 Java 中，可以通过重载（Overloading）、重写（Overriding）等机制来实现多态。下面是一个示例：
public class Animal {
public void move() {System.out.println("Animal is moving...");
}
}
public class Dog extends Animal {
@Override
public void move() {System.out.println("Dog is running...");
}
}
public class Cat extends Animal {
@Override
public void move() {System.out.println("Cat is climbing...");
}
}
public class Main {public static void main(String[] args) {Animal animal1 = new Dog();
Animal animal2 = new Cat();
animal1.move(); // 输出：Dog is running...
animal2.move(); // 输出：Cat is climbing...}
}
在上面的代码中，我们定义了一个 Animal 类，并在其子类 Dog 和 Cat 中分别重写了 move 方法。在 Main 类中，我们通过向上转型将 Dog 和 Cat 对象分别赋值给 Animal 类型的变量 animal1 和 animal2，然后调用它们的 move 方法。由于多态性质的存在，最终输出的结果分别是“Dog is running…”和“Cat is climbing…”。
设计模式
设计模式是指在软件开发过程中经常出现的一些问题的通用解决方案。在 Java 中，有很多种不同的设计模式，如单例模式、工厂模式、装饰器模式、观察者模式等等。在这里，我们以单例模式和工厂模式为例进行说明。
单例模式
单例模式是指一个类只能创建一个对象，并且该对象可以被全局访问。在 Java 中，可以通过私有化构造函数和静态方法来实现单例模式。下面是一个示例：
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {if (instance == null) {instance = new Singleton();
}
return instance;
}
// ... 其他方法和成员变量
}
在上面的代码中，我们定义了一个 Singleton 类，并将其构造函数私有化，使得外部无法直接创建 Singleton 对象。同时，我们提供了一个 getInstance 方法，通过判断 instance 是否为空来决定是否需要创建新的对象。由于 getInstance 方法是静态的，因此可以全局访问。
工厂模式
工厂模式是指通过一个工厂类来创建对象，而不是直接在调用方处进行对象的创建。在 Java 中，可以通过简单工厂模式、工厂方法模式、抽象工厂模式等来实现工厂模式。下面是一个示例：
public interface Shape {
void draw();}
public class Rectangle implements Shape {
@Override
public void draw() {System.out.println("Inside Rectangle::draw() method.");
}
}
public class Circle implements Shape {
@Override
public void draw() {System.out.println("Inside Circle::draw() method.");
}
}
public class ShapeFactory {public static Shape getShape(String shapeType) {if (shapeType == null) {return null;} else if (shapeType.equalsIgnoreCase("RECTANGLE")) {return new Rectangle();
} else if (shapeType.equalsIgnoreCase("CIRCLE")) {return new Circle();
} else {return null;}
}
}
public class Main {public static void main(String[] args) {Shape shape1 = ShapeFactory.getShape("RECTANGLE");
shape1.draw(); // 输出：Inside Rectangle::draw() method.
Shape shape2 = ShapeFactory.getShape("CIRCLE");
shape2.draw(); // 输出：Inside Circle::draw() method.
}
}
在上面的代码中，我们定义了一个 Shape 接口，并在其实现类 Rectangle 和 Circle 中分别实现了 draw 方法。同时，我们在 ShapeFactory 类中提供了一个 getShape 静态方法，通过传入不同的 shapeType 参数来决定需要创建哪种类型的对象。在 Main 类中，我们通过 ShapeFactory.getShape 方法获取 Rectangle 和 Circle 对象，并调用它们的 draw 方法。
总结
本文对 Java 中的封装、继承、多态和设计模式进行了详细的介绍，并结合实例加深理解。这些概念是面向对象编程中非常重要的核心概念和高级特性，掌握它们可以让我们更好地进行软件开发。
原文地址: 面向对象编程：Java 中的封装、继承、多态和设计模式
