Java 中的类类型主要可以分为几种类别，包括普通类、抽象类、接口、内部类等。每种类都有其特定的用途和特点。下面将详细解释每种类，并给出代码示例。
1. 普通类（Regular Class）
普通类是 Java 中最常见的类类型。它可以有属性（成员变量）和方法，并且可以创建该类的实例（对象）。这是实现面向对象编程的核心。
代码示例：
public class Person {
// 实例变量
String name;
int age;
// 构造器
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 实例方法
public void displayInfo() {
System.out.println("Name: " + name + ", Age: " + age);
}
public static void main(String[] args) {
// 创建对象
Person person1 = new Person("Alice", 25);
person1.displayInfo(); // 输出: Name: Alice, Age: 25
}
}
作用与特点：
作用：普通类用于表示现实世界的实体，并封装数据和行为（通过属性和方法）
特点：
可以实例化（即创建对象）
可以有构造器、成员变量、方法
可以继承其他类并实现接口
2. 抽象类（Abstract Class）
抽象类是一种不能被实例化的类，它通常用于表示通用的概念，具体的实现交给其子类完成。抽象类中可以有抽象方法（没有方法体），也可以有已实现的方法。
代码示例：
abstract class Animal {
// 抽象方法（没有实现）
public abstract void makeSound();
// 普通方法
public void eat() {
System.out.println("This animal is eating.");
}
}
class Dog extends Animal {
// 实现抽象方法
@Override
public void makeSound() {
System.out.println("The dog barks.");
}
}
public class Main {
public static void main(String[] args) {
// 创建子类对象
Animal dog = new Dog();
dog.makeSound(); // 输出: The dog barks.
dog.eat(); // 输出: This animal is eating.
}
}
作用与特点：
作用：用于表示通用的行为和属性，具体的实现由子类来完成
特点：
不能实例化，只能通过继承来使用
可以包含抽象方法（没有实现）和普通方法（有实现）
子类必须实现抽象类的所有抽象方法，否则子类也必须是抽象的
3. 接口（Interface）
接口是一个纯抽象的类，它只定义方法的签名（方法名、参数和返回值），不包含方法的具体实现。接口用于定义类必须实现的功能。
代码示例：
interface Animal {
void makeSound(); // 抽象方法
void eat(); // 抽象方法
}
class Cat implements Animal {
@Override
public void makeSound() {
System.out.println("The cat meows.");
}
@Override
public void eat() {
System.out.println("The cat eats.");
}
}
public class Main {
public static void main(String[] args) {
Animal cat = new Cat();
cat.makeSound(); // 输出: The cat meows.
cat.eat(); // 输出: The cat eats.
}
}
作用与特点：
作用：接口定义类应该具备的行为，但不提供具体的实现，主要用于规范类的行为
特点：
不能包含实例字段，只能有常量和抽象方法（Java 8 后可以有默认方法和静态方法）
一个类可以实现多个接口（多重继承）
所有方法都是 public 且 abstract，默认情况下接口中的方法就是抽象的
4. 内部类（Inner Class）
内部类是在另一个类中定义的类。内部类可以访问外部类的成员变量和方法，它主要用于逻辑上和外部类关联的类。
代码示例：
public class OuterClass {
private String message = "Hello from OuterClass";
// 内部类
class InnerClass {
public void displayMessage() {
System.out.println(message); // 可以访问外部类的成员变量
}
}
public static void main(String[] args) {
// 创建外部类对象
OuterClass outer = new OuterClass();
// 创建内部类对象
OuterClass.InnerClass inner = outer.new InnerClass();
inner.displayMessage(); // 输出: Hello from OuterClass
}
}
作用与特点：
作用：内部类用于封装与外部类紧密相关的功能，提供更好的封装性
特点：
内部类可以访问外部类的所有成员变量和方法
内部类对象的创建依赖于外部类对象
内部类可以隐藏在外部类内部，增加了封装性和可读性
5. 静态内部类（Static Nested Class）
静态内部类是内部类的一种，但它不依赖于外部类的实例。静态内部类无法访问外部类的非静态成员。
代码示例：
public class OuterClass {
private static String staticMessage = "Hello from Static Nested Class";
// 静态内部类
static class StaticNestedClass {
public void displayMessage() {
System.out.println(staticMessage); // 只能访问外部类的静态变量
}
}
public static void main(String[] args) {
// 直接创建静态内部类对象，不需要外部类对象
OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
nested.displayMessage(); // 输出: Hello from Static Nested Class
}
}
作用与特点：
作用：用于逻辑上与外部类关联，但不依赖外部类实例的类
特点：
静态内部类不能访问外部类的非静态成员变量
静态内部类可以直接通过外部类名来创建对象
6. 枚举类（Enum Class）
枚举类用于定义一组常量。它可以用于表示固定的常量集，如一周的天数、方向等。
代码示例：
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY;
}
public class Main {
public static void main(String[] args) {
Day today = Day.MONDAY;
switch (today) {
case MONDAY:
System.out.println("Today is Monday.");
break;
default:
System.out.println("Another day.");
}
}
}
作用与特点：
作用：用于定义常量的集合，如一周的天数、月份、方向等
特点：
枚举类的所有实例都是常量，且在类加载时就被初始化
可以有构造器、方法和字段
7、总结
普通类：用于表示一个具体的对象，适合需要创建实例的场景，是面向对象编程的基本组成部分
抽象类：用于通用功能的模板设计，适用于需要部分实现共享的场景，比如动物、交通工具等需要通用行为的实体
接口：用于定义行为规范，特别适合需要实现多种行为的类，通过接口实现多继承，增强了代码的灵活性
内部类：用于封装外部类的复杂功能，可以访问外部类的成员，适合封装与外部类紧密相关的逻辑，增强代码的封装性
静态内部类：适用于逻辑上与外部类相关，但不需要访问外部类实例的场景，通常用于工具类或辅助类的设计
枚举类：用于定义一组固定常量的集合，适合有固定值的业务场景，如状态管理、选项设置等