Java类与对象

Java是一种面向对象的编程语言，类是其中最基本的概念之一。在Java中，一个类包含了一组属性和方法，描述了一类对象的共同特征和功能。Java中的对象是根据类创建的，每个对象都拥有各自独特的状态和行为。

一、类的定义和使用

定义一个类，需要使用关键字class，类名一般使用首字母大写的驼峰命名法，类名之后的代码块称为类体，包含了属性和方法的定义。

public class Person {
    // 成员变量：姓名、年龄、性别
    String name;
    int age;
    char gender;

    // 成员方法：吃饭、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    public void work() {
        System.out.println(name + " is working.");
    }
    public void rest() {
        System.out.println(name + " is resting.");
    }
}

定义了一个Person类，包含了姓名、年龄、性别这三个属性和吃饭、工作、休息这三个方法，下面我们可以通过new关键字创建Person类的实例。

public static void main(String[] args) {
    // 创建Person类的实例
    Person person = new Person();
    // 调用成员变量和成员方法
    person.name = "Tom";
    person.age = 18;
    person.gender = 'M';
    person.eat();
    person.work();
    person.rest();
}

在这个例子中，我们通过new关键字创建了Person类的实例，随后可以使用点号.来访问实例的成员变量和成员方法。

二、构造方法和重载

构造方法是一种特殊的成员方法，用于创建对象时进行初始化，构造方法名与类名相同，没有返回值类型。当我们创建一个对象时，会自动调用该对象的构造方法，如果我们没有自定义构造方法，则会使用默认构造方法。

public class Person {
    // 成员变量：姓名、年龄、性别
    String name;
    int age;
    char gender;

    // 构造方法1
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.gender = 'U';
    }

    // 构造方法2
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    // 成员方法：吃饭、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    public void work() {
        System.out.println(name + " is working.");
    }
    public void rest() {
        System.out.println(name + " is resting.");
    }
}

在这个例子中，我们添加了两个构造方法，可以根据不同的参数创建对象并初始化成员变量。另外，我们使用this关键字来区分成员变量和构造方法参数的同名属性。

重载是指在同一个类中使用相同的方法名，但是参数列表不同的情况。Java允许我们对同一个方法进行重载，只要方法名相同，参数类型、个数或顺序不同即可。

public int add(int a, int b) {
    return a + b;
}

public double add(double a, double b) {
    return a + b;
}

public String add(String a, String b) {
    return a + b;
}

在这个例子中，我们对add方法进行了重载，可以对int、double和String类型做不同的处理。

三、访问修饰符和封装

访问修饰符是用于对类、属性和方法进行访问限制的关键字，Java中有四种访问修饰符。

public：可以在任何地方被访问

protected：可以被同一个包中的其他类访问，或者子类继承访问

default：在同一个包中可以被访问

private：只能被本类中的其他方法访问，不能被其他类访问

public class Person {
    // 成员变量：姓名、年龄、性别
    private String name;
    protected int age;
    char gender;

    // 构造方法1
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.gender = 'U';
    }

    // 构造方法2
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    // 成员方法：吃饭、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    protected void work() {
        System.out.println(name + " is working.");
    }
    void rest() {
        System.out.println(name + " is resting.");
    }

    // getter和setter方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

在这个例子中，我们使用private关键字来限制name属性的访问，使其只能在同一个类中访问。同时，我们添加了getter和setter方法，用于对name属性进行访问和修改。

封装是指隐藏对象的属性和实现细节，只向外界提供访问接口。封装可以提高代码的可重用性和安全性，对于复杂的对象系统尤其重要。

四、静态变量和静态方法

静态变量和静态方法属于类本身，不属于任何实例。使用static关键字来定义静态变量和静态方法。

public class Person {
    // 静态变量：人的数量
    static int count = 0;
    // 成员变量：姓名、年龄、性别
    private String name;
    protected int age;
    char gender;

    // 构造方法1
    public Person() {
        this.name = "Unknown";
        this.age = 0;
        this.gender = 'U';
        count++;
    }

    // 构造方法2
    public Person(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        count++;
    }

    // 成员方法：吃饭、工作、休息
    public void eat() {
        System.out.println(name + " is eating.");
    }
    protected void work() {
        System.out.println(name + " is working.");
    }
    void rest() {
        System.out.println(name + " is resting.");
    }

    // 静态方法：获取人的数量
    public static int getCount() {
        return count;
    }
}

在这个例子中，我们添加了静态变量count来表示Person类的实例数量，并在每个构造方法中进行了更新。同时，我们添加了静态方法getCount来获取实例数量。这些静态变量和静态方法可以通过类名.来访问。

五、继承和多态

继承是指一个类可以继承另一个类的属性和方法，使得子类具有父类的共性和特征。继承可以减少代码的重复，提高代码的可维护性。

public class Student extends Person {
    // 成员变量：学号、班级
    String id;
    String clazz;

    // 构造方法1
    public Student() {
        super();
        this.id = "Unknown";
        this.clazz = "Unknown";
    }

    // 构造方法2
    public Student(String name, int age, char gender, String id, String clazz) {
        super(name, age, gender);
        this.id = id;
        this.clazz = clazz;
    }

    // 成员方法：上课、做作业
    public void attendClass() {
        System.out.println(name + " is attending class.");
    }
    public void doHomework() {
        System.out.println(name + " is doing homework.");
    }
}

在这个例子中，我们使用extends关键字来实现Student类对Person类的继承，使得Student类自动拥有Person类的属性和方法。子类可以使用super关键字来访问父类的成员变量和成员方法。

多态是指同一个类的实例可以以不同的形态表现出不同的行为，即同样的方法调用可能会有不同的实现效果。实现多态需要使用继承、重写和向上转型等技术。

public static void display(Person person) {
    person.work();
}

Person person = new Person("Tom", 18, 'M');
Student student = new Student("Jerry", 20, 'M', "1234", "Class 1");
display(person); // Tom is working.
display(student); // Jerry is working.

在这个例子中，我们定义了一个静态方法display，接受一个Person类型的参数，并调用work方法。当我们传入一个Person实例或一个Student实例时，多态就会发生，实现不同的work行为。

六、总结

以上是对Java类与对象的介绍，包括类的定义和使用、构造方法和重载、访问修饰符和封装、静态变量和静态方法、继承和多态等方面。类是Java语言的核心概念之一，理解和运用好类和对象的相关知识对于Java程序的开发至关重要。