类和对象（Classes and Objects）
类是Java中面向对象编程的基本构建块，它定义了对象的属性和方法。对象是类的实例，具有类定义的属性和行为。
class Car { String brand; int year; void start() { System.out.println("The car is starting."); } } public class Main { public static void main(String[] args) { Car myCar = new Car(); // 创建Car类的对象 myCar.brand = "Toyota"; myCar.year = 2022; myCar.start(); } }
封装（Encapsulation）
封装指的是将数据和方法包装在一个类中，并控制对其访问的权限。封装可以提高代码的安全性和可维护性，避免了外部程序直接访问和修改对象的属性或方法，从而减少了代码出错的可能性。
在Java中，我们可以通过访问修饰符（public、private、protected、default）来控制属性和方法的访问权限。其中：
- private：表示私有属性或方法，只能在本类中进行访问，其他类无法访问。
- public：表示公有属性或方法，可以在任何类中进行访问。
- protected：表示受保护的属性或方法，可以在本类、子类和同一包中进行访问，但其他类无法访问。
- default：表示默认属性或方法，只能在同一包中进行访问，其他包中的类无法访问。
示例：
public class Car { private String brand; // 品牌 private double price; // 价格 public Car(String brand, double price) { this.brand = brand; this.price = price; } public String getBrand() { return brand; } public void setBrand(String brand) { this.brand = brand; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } } public class Main { public static void main(String[] args) { Car car = new Car("BMW", 500000); // 创建一个汽车对象 System.out.println(car.getBrand()); // 输出汽车的品牌 car.setPrice(600000); // 修改汽车的价格 System.out.println(car.getPrice()); // 输出汽车的价格 } }
在上面的代码中，我们创建了一个Car类，包含了品牌和价格两个属性，并提供了get/set方法来访问这些属性。在Main类中，我们创建了一个Car对象，并通过调用get/set方法来访问或修改对象的属性。由于属性brand和price是private类型的，外部类无法直接访问，只能通过public的get/set方法来进行访问或修改，从而实现了封装的效果。
继承（Inheritance）
继承指的是通过子类继承父类的属性和方法来实现代码重用和扩展。继承可以减少代码的重复，提高代码的可维护性和可扩展性。在Java中，通过使用关键字 extends 来实现继承。
示例：
public class Animal { private String name; // 名称 private int age; // 年龄 public Animal(String name, int age) { this.name = name; this.age = age; } public void eat() { System.out.println("Animal is eating."); } } public class Dog extends Animal { public Dog(String name, int age) { super(name, age); } public void bark() { System.out.println("Dog is barking."); } } public class Main { public static void main(String[] args) { Dog dog = new Dog("Tom", 2); // 创建一个狗狗对象 System.out.println(dog.getName() + " is " + dog.getAge() + " years old."); // 输出狗狗的名称和年龄 dog.eat(); // 狗狗吃东西 dog.bark(); // 狗狗叫 } }
我们创建了一个Animal类，包含了名称和年龄两个属性，以及一个eat方法。然后我们创建了一个Dog类，通过 extends 关键字继承了Animal类，并添加了一个bark方法。在Main类中，我们创建了一个Dog对象，并通过调用getName/getAge方法来访问父类的属性，调用eat/bark方法来访问子类的方法。由于Dog类继承了Animal类，所以我们不需要再次定义name/age/eat这些属性和方法，而是可以直接调用父类的属性和方法，从而实现了代码的重用和继承的效果。
多态（Polymorphism）
多态是Java中的面向对象编程特性之一，它指的是同一种行为或方法具有不同的实现方式或表现形式。在Java中，多态有两种实现方式：重载和覆盖。
重载（Overloading）指的是在同一个类中定义多个同名方法，但参数列表不同，从而实现一种行为具有不同的实现方式的效果。例如：
public class Math { public int add(int num1, int num2) { return num1 + num2; } public double add(double num1, double num2) { return num1 + num2; } }
我们定义了两个名称相同但参数列表不同的方法add，分别用于实现整数和浮点数的加法操作。这就是重载的实现方式。
覆盖（Override）指的是在子类中定义一个与父类中同名同参数方法，从而实现一种行为的不同实现方式。例如：
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."); } }
我们定义了一个Animal类，包含一个名为move的方法。然后我们创建了一个Dog类，通过 extends 关键字继承了Animal类，并覆盖了Animal类中的move方法，从而实现了一种不同的行为实现方式。
在使用多态时，我们可以通过父类类型的引用来调用子类中的方法，从而实现代码的灵活性和扩展性。例如：
public class Main { public static void main(String[] args) { Animal animal = new Dog(); // 使用父类类型的引用来创建一个Dog对象 animal.move(); // 调用子类中覆盖的move方法 } }
我们创建了一个Animal类型的引用animal，并将其指向一个Dog对象。然后我们通过调用animal的move方法，实际上调用的是Dog类中覆盖的move方法，从而实现了多态的效果。
抽象（Abstraction）
抽象指的是一种行为的概念或定义，而不是具体的实现方式。在Java中，我们可以通过抽象类和接口来实现抽象特性。
抽象类是一种不能实例化的类，它的目的是为了让子类来实现它具体的行为。抽象类中可以包含抽象方法和非抽象方法，其中抽象方法只有方法的声明，而没有具体的实现方式。子类必须实现抽象类中的所有抽象方法才能被实例化。例如：
public abstract class Shape { public abstract double getArea(); // 抽象方法，计算图形的面积 public void printInfo() { // 非抽象方法，用于打印图形的信息 System.out.println("This is a shape."); } } public class Circle extends Shape { private double radius; public Circle(double r) { this.radius = r; } @Override public double getArea() { return Math.PI * radius * radius; } }
我们定义了一个抽象类Shape，其中包含一个抽象方法 getArea 和一个非抽象方法 printInfo。然后我们创建了一个Circle类，通过继承Shape类并实现抽象方法 getArea 来计算圆形的面积，从而实现了抽象类的继承。
接口是一种没有任何实现的抽象类，它只包含了方法的声明，不包含任何实现。在Java中可以使用关键字 interface 来定义接口。子类必须实现所有接口中声明的方法才能被实例化。例如：
public interface Drawable { void draw(); // 接口方法，用于绘制图形 } public class Circle implements Drawable { private double radius; public Circle(double r) { this.radius = r; } @Override public void draw() { // 绘制圆形的代码 } }
我们定义了一个接口Drawable，其中包含一个抽象方法 draw。然后我们创建了一个Circle类，通过实现接口Drawable中的方法 draw 来绘制圆形，从而实现了接口的实现。
抽象特性的主要作用是提高代码的可扩展性和重用性，通过抽象类和接口来定义一些通用的行为和功能，让具体的子类来实现具体的实现方式，从而实现了一种面向对象编程的设计思想。
