Java中的类和对象

Java是一种面向对象的编程语言，其中最基本的构建块是类和对象。了解如何在Java中定义类和创建对象是核心技能的一部分。

类（Class）

类是一个蓝图，它定义了创建对象的状态（属性）和行为（方法）。类中的属性通常称为字段（fields），行为则由方法（methods）表示。

定义一个类

你可以通过以下方式定义一个类：

public class Dog {
    // 字段
    String breed;
    int age;
    String color;

    // 方法
    void bark() {
        System.out.println("Woof!");
    }

    void sleep() {
        System.out.println("Zzz");
    }
}

在这个Dog类中，我们定义了三个字段：品种、年龄和颜色，并定义了两个方法：bark()和sleep()。

对象（Object）

对象是类的一个实例。使用new关键字和类的构造器来创建类的对象。每个对象都有其自己的状态和行为。

创建一个对象

基于Dog类创建一个对象的示例：

public class TestDog {
    public static void main(String[] args) {
        // 创建对象
        Dog myDog = new Dog();
        
        // 访问字段
        myDog.breed = "Beagle";
        myDog.age = 5;
        myDog.color = "brown";
        
        // 调用方法
        myDog.bark();
        myDog.sleep();
    }
}

在TestDog类的main方法中，我们创建了一个Dog类的对象，并给它的字段赋值。然后，我们调用了该对象的bark()和sleep()方法。

构造器（Constructor）

构造器是一种特殊的方法，当新对象被创建时，用来初始化对象的状态。每个类都可以有一个或多个构造器。

定义构造器

构造器的名称必须与类名相同，并且不能有返回类型。

public class Dog {
    String breed;
    int age;
    String color;

    // 默认构造器
    public Dog() {
        this.breed = "Unknown";
        this.age = 0;
        this.color = "Unknown";
    }

    // 带参数的构造器
    public Dog(String breed, int age, String color) {
        this.breed = breed;
        this.age = age;
        this.color = color;
    }

    // ...其他方法...
}

在这个例子中，Dog类有两个构造器：一个是无参的默认构造器，另一个是带有参数的构造器。

使用构造器创建对象

Dog myDog = new Dog("Beagle", 5, "brown");

这行代码会调用带参数的构造器来创建Dog对象。

方法重载（Method Overloading）

一个类可以有多个同名方法，只要它们的参数列表不同。这被称为方法重载。

public class Dog {
    // ...字段和构造器...

    // 方法重载
    void bark() {
        System.out.println("Woof!");
    }

    void bark(int times) {
        for (int i = 0; i < times; i++) {
            System.out.println("Woof!");
        }
    }
}

在这个例子中，Dog类有两个bark方法：一个不接受参数，另一个接受一个整数参数，表示狗叫的次数。

访问控制

Java提供了几种访问控制级别，用于限制类、方法和字段的可见性。

• public：成员可在任何地方访问。
• private：成员只能在定义它们的类内部访问。
• protected：成员可以在同一包内的类或不同包中的子类中访问。
• 默认（没有指定修饰符）：成员只能在其所在包内访问。

通常，字段被声明为私有（private），这是为了遵循遵循封装原则，方法通常被声明为公共（public）以供外部调用。

封装（Encapsulation）

封装是面向对象编程的一个核心概念，它指的是将对象的状态和行为包装在一起，同时对对象的实现细节进行隐藏。在Java中，你可以通过将字段设置为私有（private）并提供公共（public）方法来访问和修改这些字段来实现封装。

封装的实现

以下是一个展示封装的简单例子：

public class Person {
    // 私有字段
    private String name;
    private int age;

    // 公共构造器
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 公共方法，用于获取私有字段的值
    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    // 公共方法，用于设置私有字段的值
    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        if (age > 0) {
            this.age = age;
        }
    }
}

在Person类中，字段name和age是私有的，它们只能通过公共的getter和setter方法来访问和修改。

继承（Inheritance）

继承是面向对象编程的另一个关键概念，它允许一个类（子类）继承另一个类（超类或父类）的属性和方法。

实现继承

以下是一个使用继承的简单例子：

// 父类
public class Animal {
    protected String name;

    public void eat() {
        System.out.println(name + " is eating.");
    }
}

// 子类
public class Dog extends Animal {
    public void bark() {
        System.out.println(name + " says Woof!");
    }
}

在这里，Dog类继承自Animal类。这意味着Dog类继承了Animal类的所有公共和受保护的属性和方法。

多态（Polymorphism）

多态是面向对象编程的第三个核心概念，它指的是允许一个方法或对象采取多种形式。在Java中，多态通常是通过覆盖（方法重写）和接口实现。

方法覆盖（Overriding）

当子类有一个与父类同名、参数列表相同的方法时，子类可以提供自己的实现，这就是方法覆盖。

// 父类
public class Animal {
    public void makeSound() {
        System.out.println("Animal makes a sound");
    }
}

// 子类
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog says: Woof!");
    }
}

在这个例子中，Dog类覆盖了Animal类中的makeSound()方法。

接口（Interface）

接口是另一种实现多态的方式。在Java中，接口是一种完全抽象的类，它允许声明方法，但不允许包含它们的实现（直到Java 8之后，接口可以包含默认方法和静态方法）。

定义接口：

public interface Animal {
    void makeSound();
}

实现接口：

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog says: Woof!");
    }
}

在这个例子中，Dog类实现了Animal接口，并提供了makeSound()方法的具体实现。

总结

类和对象是Java编程的基础。通过类可以定义对象的模板，包括其属性和方法。对象是类的具体实例。封装、继承和多态是面向对象编程的三大主要特征，它们共同提供了一种结构化而且强大的方法来创建复杂的软件系统。