通过类可以创建对象，即类的实例。下面是一个简单的 Java 类的例子：
```java public class Person { private String name; private int age; public Person(String name, int age) { this.name = name; this.age = age; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setAge(int age) { this.age = age; } public int getAge() { return age; } public void displayInfo() { System.out.println("Name: " + name + ", Age: " + age); } public static void main(String[] args) { Person person = new Person("Alice", 25); person.displayInfo(); person.setAge(30); person.displayInfo(); } } ```
在上面的例子中，`Person` 类包含了两个私有字段 `name` 和 `age`，以及构造方法、设置和获取字段值的方法以及显示信息的方法。在 `main` 方法中，创建了一个 `Person` 对象并调用了相关方法来操作对象。
类的成员访问修饰符
Java 中的类成员（字段和方法）可以使用不同的访问修饰符来控制访问权限：
- `public`：可以被任意类访问。
- `protected`：可以被同一包内的类和子类访问。
- `default`：没有修饰符，可以被同一包内的类访问。
- `private`：只能被同一类内部访问。
类的继承
Java 支持单继承，一个子类只能继承一个父类，使用 `extends` 关键字来实现继承。例如：
```java public class Student extends Person { private String studentId; public Student(String name, int age, String studentId) { super(name, age); // 调用父类构造方法 this.studentId = studentId; } public String getStudentId() { return studentId; } public void displayInfo() { System.out.println("Name: " + getName() + ", Age: " + getAge() + ", Student ID: " + studentId); } } ```
类的多态
Java 中的多态性是指同一个方法调用可以在不同的对象上产生不同的行为。实现多态性的方式有方法重载和方法重写。方法重载是指在一个类中可以定义多个同名方法，但参数列表不同；方法重写是指子类重新定义父类的方法。
```java public class Animal { public void makeSound() { System.out.println("Animal makes sound"); } } public class Dog extends Animal { @Override public void makeSound() { System.out.println("Dog barks"); } } public class Cat extends Animal { @Override public void makeSound() { System.out.println("Cat meows"); } } ```
通过上面的例子，可以看到不同的动物类对象调用 `makeSound` 方法时产生不同的行为。
Java 中类的概念非常重要，它是面向对象编程的核心。通过类的定义和使用，可以实现代码的封装、继承和多态，提高代码的可读性和可维护性。
抽象类和接口
- 抽象类是不能被实例化的类，用 `abstract` 关键字来定义。抽象类可以包含抽象方法和非抽象方法，子类必须实现抽象方法。例如：
```java public abstract class Shape { public abstract double area(); } public class Circle extends Shape { private double radius; public Circle(double radius) { this.radius = radius; } @Override public double area() { return Math.PI * radius * radius; } } ```
- 接口是一种抽象类型，它定义了一组方法但没有实现。类通过 `implements` 关键字来实现接口，并实现接口定义的方法。一个类可以实现多个接口。例如：
```java public interface Drawable { void draw(); } public class Rectangle implements Drawable { @Override public void draw() { System.out.println("Drawing rectangle"); } } ```
类的静态成员
- 在 Java 中，可以使用 `static` 关键字来定义静态成员（字段和方法）。静态成员属于类而不是对象，可以通过类名来访问。静态方法中不能直接访问非静态成员，但可以访问静态成员。例如：
```java public class Counter { private static int count = 0; public Counter() { count++; } public static int getCount() { return count; } } ```
类的封装
- 封装是面向对象编程的重要特性，它将数据（字段）和方法（行为）打包在一起，对外部隐藏对象的内部实现细节。在 Java 中，可以使用 `private` 访问修饰符来实现封装。例如：
```java public class Person { private String name; private int age; public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { if (age >= 0) { this.age = age; } else { System.out.println("Age cannot be negative"); } } } ```
以上是关于 Java 类的一些补充内容，包括抽象类、接口、静态成员和封装。这些特性都是面向对象编程中非常重要的概念，能够帮助我们更好地组织和管理代码。
