编程马·菜鸟教程

Appearance

10.2 类的定义（属性 + 方法） ​

类的定义 ​

类是面向对象编程的基本单位，它定义了对象的属性和方法。在 Java 中，类的定义包括类声明、属性定义和方法定义。

类的声明 ​

语法：

java
[修饰符] class 类名 {
    // 属性定义
    // 方法定义
}

示例：

java
public class Person {
    // 属性定义
    private String name;
    private int age;
    private String address;
    
    // 方法定义
    public void eat() {
        System.out.println(name + " is eating.");
    }
    
    public void sleep() {
        System.out.println(name + " is sleeping.");
    }
}

属性的定义 ​

属性是对象的状态，也称为成员变量。属性定义了对象的特征。

属性的声明 ​

语法：

java
[修饰符] 数据类型 属性名 [= 初始值];

示例：

java
public class Person {
    // 属性声明
    private String name; // 姓名
    private int age; // 年龄
    private String address; // 地址
    private boolean isStudent = false; // 是否是学生，默认值为 false
}

属性的访问修饰符 ​

属性的访问修饰符控制属性的访问权限：

  • public：公共属性，任何类都可以访问
  • protected：受保护属性，同一个包或子类可以访问
  • default：默认属性，同一个包可以访问
  • private：私有属性，只有本类可以访问

示例：

java
public class Person {
    public String publicAttribute; // 公共属性
    protected String protectedAttribute; // 受保护属性
    String defaultAttribute; // 默认属性
    private String privateAttribute; // 私有属性
}

属性的类型 ​

属性的类型可以是任何 Java 数据类型，包括基本数据类型和引用数据类型。

示例：

java
public class Person {
    // 基本数据类型属性
    private int age; // 整数
    private double height; // 浮点数
    private boolean isStudent; // 布尔值
    private char gender; // 字符
    
    // 引用数据类型属性
    private String name; // 字符串
    private Date birthDate; // 日期
    private Address address; // 自定义类
    private int[] scores; // 数组
}

方法的定义 ​

方法是对象的行为，定义了对象可以执行的操作。

方法的声明 ​

语法：

java
[修饰符] 返回类型 方法名([参数列表]) {
    // 方法体
    [return 返回值;]
}

示例：

java
public class Person {
    private String name;
    private int age;
    
    // 无参无返回值方法
    public void eat() {
        System.out.println(name + " is eating.");
    }
    
    // 无参有返回值方法
    public String getName() {
        return name;
    }
    
    // 有参无返回值方法
    public void setName(String name) {
        this.name = name;
    }
    
    // 有参有返回值方法
    public boolean isAdult() {
        return age >= 18;
    }
}

方法的访问修饰符 ​

方法的访问修饰符控制方法的访问权限，与属性的访问修饰符相同：

  • public：公共方法，任何类都可以访问
  • protected：受保护方法，同一个包或子类可以访问
  • default：默认方法，同一个包可以访问
  • private：私有方法，只有本类可以访问

示例：

java
public class Person {
    public void publicMethod() {}
    protected void protectedMethod() {}
    void defaultMethod() {}
    private void privateMethod() {}
}

方法的参数 ​

方法的参数用于向方法传递数据，参数列表可以包含多个参数。

示例：

java
public class Calculator {
    // 一个参数的方法
    public int square(int number) {
        return number * number;
    }
    
    // 多个参数的方法
    public int add(int a, int b) {
        return a + b;
    }
    
    // 可变参数的方法
    public int sum(int... numbers) {
        int sum = 0;
        for (int number : numbers) {
            sum += number;
        }
        return sum;
    }
}

方法的返回值 ​

方法的返回值用于向调用者返回结果，返回类型可以是任何 Java 数据类型，包括基本数据类型和引用数据类型。如果方法没有返回值，使用 void 作为返回类型。

示例：

java
public class Calculator {
    // 返回 int 类型
    public int add(int a, int b) {
        return a + b;
    }
    
    // 返回 double 类型
    public double divide(double a, double b) {
        return a / b;
    }
    
    // 返回 String 类型
    public String getResult(int a, int b) {
        return a + " + " + b + " = " + (a + b);
    }
    
    // 无返回值
    public void printResult(int a, int b) {
        System.out.println(a + " + " + b + " = " + (a + b));
    }
}

构造方法 ​

构造方法是一种特殊的方法，用于创建对象时初始化对象的属性。构造方法的名称与类名相同，没有返回类型。

构造方法的声明 ​

语法：

java
[修饰符] 类名([参数列表]) {
    // 构造方法体
}

示例：

java
public class Person {
    private String name;
    private int age;
    
    // 无参构造方法
    public Person() {
        this.name = "Unknown";
        this.age = 0;
    }
    
    // 有参构造方法
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

默认构造方法 ​

如果一个类没有定义构造方法，Java 会自动提供一个无参构造方法，称为默认构造方法。

示例：

java
public class Person {
    private String name;
    private int age;
    // 没有定义构造方法，Java 会提供默认构造方法
}

// 使用默认构造方法创建对象
Person person = new Person();

示例：完整的类定义 ​

java
public class Student {
    // 属性
    private String name;
    private int age;
    private int studentId;
    private double grade;
    
    // 构造方法
    public Student() {
        this.name = "Unknown";
        this.age = 0;
        this.studentId = 0;
        this.grade = 0.0;
    }
    
    public Student(String name, int age, int studentId, double grade) {
        this.name = name;
        this.age = age;
        this.studentId = studentId;
        this.grade = grade;
    }
    
    // 方法
    public void study() {
        System.out.println(name + " is studying.");
    }
    
    public void takeExam() {
        System.out.println(name + " is taking an exam.");
    }
    
    public boolean isPass() {
        return grade >= 60;
    }
    
    // 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) {
        this.age = age;
    }
    
    public int getStudentId() {
        return studentId;
    }
    
    public void setStudentId(int studentId) {
        this.studentId = studentId;
    }
    
    public double getGrade() {
        return grade;
    }
    
    public void setGrade(double grade) {
        this.grade = grade;
    }
}

public class StudentExample {
    public static void main(String[] args) {
        // 使用无参构造方法创建对象
        Student student1 = new Student();
        student1.setName("John");
        student1.setAge(18);
        student1.setStudentId(1001);
        student1.setGrade(85.5);
        
        // 使用有参构造方法创建对象
        Student student2 = new Student("Jane", 19, 1002, 92.0);
        
        // 调用对象的方法
        student1.study();
        student1.takeExam();
        System.out.println(student1.getName() + " is pass: " + student1.isPass());
        
        student2.study();
        student2.takeExam();
        System.out.println(student2.getName() + " is pass: " + student2.isPass());
    }
}

类的命名规范 ​

  1. 类名应该使用大驼峰命名法：首字母大写，后续单词首字母也大写
  2. 类名应该有意义：使用能够描述类的用途的名称
  3. 类名应该简洁：避免过长的类名

示例：

  • Person：表示人
  • Student：表示学生
  • Car：表示汽车
  • BankAccount：表示银行账户

方法的命名规范 ​

  1. 方法名应该使用小驼峰命名法：首字母小写，后续单词首字母大写
  2. 方法名应该有意义：使用能够描述方法功能的名称
  3. 方法名应该使用动词或动词短语：表示方法的行为

示例：

  • getName()：获取名称
  • setAge(int age)：设置年龄
  • calculateSum(int[] numbers)：计算和
  • isAdult()：判断是否成年

属性的命名规范 ​

  1. 属性名应该使用小驼峰命名法：首字母小写，后续单词首字母大写
  2. 属性名应该有意义：使用能够描述属性用途的名称
  3. 属性名应该使用名词：表示属性的特征

示例：

  • name：姓名
  • age：年龄
  • address：地址
  • studentId：学生 ID

常见问题 ​

1. 类名命名错误 ​

症状：编译错误或代码风格不符合规范

解决方案：使用大驼峰命名法，确保类名有意义

2. 方法名命名错误 ​

症状：代码风格不符合规范

解决方案：使用小驼峰命名法，确保方法名有意义，使用动词或动词短语

3. 属性名命名错误 ​

症状：代码风格不符合规范

解决方案：使用小驼峰命名法，确保属性名有意义，使用名词

4. 访问修饰符使用错误 ​

症状：代码安全性问题或访问权限错误

解决方案：合理使用访问修饰符，通常属性使用 private，方法使用 public

5. 缺少构造方法 ​

症状：无法正确初始化对象

解决方案：根据需要定义构造方法，包括无参构造方法和有参构造方法

总结 ​

类的定义是面向对象编程的基础，它包括属性和方法的定义。属性是对象的状态，方法是对象的行为。构造方法用于创建对象时初始化对象的属性。

在定义类时，需要注意：

  • 类名使用大驼峰命名法
  • 方法名使用小驼峰命名法，使用动词或动词短语
  • 属性名使用小驼峰命名法，使用名词
  • 合理使用访问修饰符
  • 根据需要定义构造方法

通过合理定义类，可以创建结构清晰、功能完整的对象，实现面向对象编程的优势。

© 2026 编程马·菜鸟教程 版权所有

基于 VitePress 构建