class 关键字

概述

class 关键字用于定义类，是Java面向对象编程的基础。类是对象的模板，定义了对象的属性和行为。

语法格式

[访问修饰符] [修饰符] class 类名 [extends 父类] [implements 接口列表] {
    // 类体
    // 成员变量
    // 构造器
    // 方法
    // 内部类
}

基本用法

简单类定义

public class Person {
    // 成员变量（属性）
    private String name;
    private int age;
    private String email;

    // 默认构造器
    public Person() {
        this.name = "未知";
        this.age = 0;
        this.email = "";
    }

    // 带参数的构造器
    public Person(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    // 成员方法
    public void introduce() {
        System.out.println("我是" + name + "，今年" + age + "岁");
    }

    // Getter和Setter方法
    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 && age <= 150) {
            this.age = age;
        }
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }
}

// 使用类
public class ClassExample {
    public static void main(String[] args) {
        // 创建对象
        Person person1 = new Person();
        person1.setName("张三");
        person1.setAge(25);
        person1.introduce(); // 输出：我是张三，今年25岁

        Person person2 = new Person("李四", 30, "lisi@example.com");
        person2.introduce(); // 输出：我是李四，今年30岁
    }
}

完整的类示例

// 学生类
public class Student {
    // 静态变量
    private static int studentCount = 0;
    public static final String SCHOOL_NAME = "XX大学";

    // 实例变量
    private String studentId;
    private String name;
    private int age;
    private String major;
    private double gpa;

    // 静态初始化块
    static {
        System.out.println("Student类被加载");
    }

    // 实例初始化块
    {
        studentCount++;
        System.out.println("创建第" + studentCount + "个学生对象");
    }

    // 构造器
    public Student(String studentId, String name, int age, String major) {
        this.studentId = studentId;
        this.name = name;
        this.age = age;
        this.major = major;
        this.gpa = 0.0;
    }

    // 实例方法
    public void study(String subject) {
        System.out.println(name + " 正在学习 " + subject);
    }

    public void updateGPA(double newGPA) {
        if (newGPA >= 0.0 && newGPA <= 4.0) {
            this.gpa = newGPA;
            System.out.println(name + " 的GPA更新为：" + gpa);
        } else {
            System.out.println("GPA必须在0.0-4.0之间");
        }
    }

    public void displayInfo() {
        System.out.println("学号：" + studentId);
        System.out.println("姓名：" + name);
        System.out.println("年龄：" + age);
        System.out.println("专业：" + major);
        System.out.println("GPA：" + gpa);
        System.out.println("学校：" + SCHOOL_NAME);
    }

    // 静态方法
    public static int getStudentCount() {
        return studentCount;
    }

    public static void printSchoolInfo() {
        System.out.println("学校名称：" + SCHOOL_NAME);
        System.out.println("学生总数：" + studentCount);
    }

    // Getter和Setter方法
    public String getStudentId() { return studentId; }
    public String getName() { return name; }
    public int getAge() { return age; }
    public String getMajor() { return major; }
    public double getGpa() { return gpa; }

    public void setName(String name) { this.name = name; }
    public void setAge(int age) { this.age = age; }
    public void setMajor(String major) { this.major = major; }
}

// 使用学生类
public class StudentExample {
    public static void main(String[] args) {
        // 访问静态成员
        System.out.println("学校：" + Student.SCHOOL_NAME);
        Student.printSchoolInfo();

        // 创建学生对象
        Student student1 = new Student("2021001", "张三", 20, "计算机科学");
        Student student2 = new Student("2021002", "李四", 21, "软件工程");

        // 使用对象方法
        student1.study("Java编程");
        student1.updateGPA(3.8);
        student1.displayInfo();

        System.out.println("---");

        student2.study("数据结构");
        student2.updateGPA(3.6);
        student2.displayInfo();

        // 访问静态方法
        System.out.println("当前学生总数：" + Student.getStudentCount());
    }
}

内部类

public class OuterClass {
    private String outerField = "外部类字段";
    private static String staticField = "静态字段";

    // 成员内部类
    public class InnerClass {
        private String innerField = "内部类字段";

        public void innerMethod() {
            System.out.println("访问外部类字段：" + outerField);
            System.out.println("访问内部类字段：" + innerField);
        }
    }

    // 静态内部类
    public static class StaticInnerClass {
        private String staticInnerField = "静态内部类字段";

        public void staticInnerMethod() {
            System.out.println("访问静态字段：" + staticField);
            System.out.println("访问静态内部类字段：" + staticInnerField);
            // System.out.println(outerField); // 错误：不能直接访问外部类实例字段
        }
    }

    // 方法内部类
    public void outerMethod() {
        final String localVariable = "局部变量";

        class LocalInnerClass {
            public void localInnerMethod() {
                System.out.println("访问外部类字段：" + outerField);
                System.out.println("访问局部变量：" + localVariable);
            }
        }

        LocalInnerClass localInner = new LocalInnerClass();
        localInner.localInnerMethod();
    }

    // 匿名内部类
    public void anonymousInnerClass() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类中访问：" + outerField);
            }
        };

        runnable.run();
    }
}

// 使用内部类
public class InnerClassExample {
    public static void main(String[] args) {
        OuterClass outer = new OuterClass();

        // 使用成员内部类
        OuterClass.InnerClass inner = outer.new InnerClass();
        inner.innerMethod();

        // 使用静态内部类
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();
        staticInner.staticInnerMethod();

        // 使用方法内部类
        outer.outerMethod();

        // 使用匿名内部类
        outer.anonymousInnerClass();
    }
}

类的特性

1. 封装性

public class BankAccount {
    private double balance; // 私有字段，外部不能直接访问
    private String accountNumber;

    public BankAccount(String accountNumber, double initialBalance) {
        this.accountNumber = accountNumber;
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        }
    }

    // 通过公共方法控制访问
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("存款成功，余额：" + balance);
        }
    }

    public boolean withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            System.out.println("取款成功，余额：" + balance);
            return true;
        }
        System.out.println("取款失败");
        return false;
    }

    public double getBalance() {
        return balance; // 只读访问
    }
}

2. 继承性

// 父类
public class Vehicle {
    protected String brand;
    protected int maxSpeed;

    public Vehicle(String brand, int maxSpeed) {
        this.brand = brand;
        this.maxSpeed = maxSpeed;
    }

    public void start() {
        System.out.println(brand + " 启动");
    }

    public void displayInfo() {
        System.out.println("品牌：" + brand + "，最高速度：" + maxSpeed);
    }
}

// 子类
public class Car extends Vehicle {
    private int doors;

    public Car(String brand, int maxSpeed, int doors) {
        super(brand, maxSpeed); // 调用父类构造器
        this.doors = doors;
    }

    @Override
    public void start() {
        System.out.println("汽车" + brand + "发动引擎");
    }

    public void honk() {
        System.out.println(brand + "按喇叭：嘟嘟！");
    }

    @Override
    public void displayInfo() {
        super.displayInfo();
        System.out.println("车门数量：" + doors);
    }
}

3. 多态性

public class PolymorphismExample {
    public static void main(String[] args) {
        // 多态：父类引用指向子类对象
        Vehicle vehicle1 = new Car("丰田", 180, 4);
        Vehicle vehicle2 = new Vehicle("通用车辆", 100);

        // 运行时决定调用哪个方法
        vehicle1.start(); // 调用Car的start方法
        vehicle2.start(); // 调用Vehicle的start方法

        // 类型检查和转换
        if (vehicle1 instanceof Car) {
            Car car = (Car) vehicle1;
            car.honk(); // 调用Car特有的方法
        }
    }
}

最佳实践

1. 命名规范：

   • 类名使用帕斯卡命名法（PascalCase）
   • 每个单词首字母大写

2. 单一职责原则：

   • 一个类应该只有一个改变的理由
   • 类的功能要内聚

3. 封装原则：

   • 成员变量通常声明为private
   • 通过public方法提供访问

4. 构造器设计：

   • 提供合适的构造器
   • 在构造器中进行必要的初始化和验证

5. 方法设计：

   • 方法名要清晰表达意图
   • 方法长度要适中

注意事项

1. 类文件命名：

   // 文件名必须与public类名相同
   public class MyClass { } // 文件名必须是MyClass.java
   

2. 一个文件一个public类：

   // 一个.java文件只能有一个public类
   public class MainClass { }
   class HelperClass { } // 可以有多个非public类
   

3. 类的加载时机：

   public class ClassLoadingExample {
       static {
           System.out.println("类被加载时执行");
       }
   
       // 首次使用类时加载：
       // 1. 创建类的实例
       // 2. 访问类的静态成员
       // 3. 反射操作
   }
   

class关键字是Java编程的核心，掌握类的设计和使用是学习Java面向对象编程的基础。