第五章 类（Class）

Java中的类是一种用于描述对象的模板，是Java程序中的一种基本概念。类是对象的蓝图，用于描述对象的属性（数据成员）和行为（函数成员）。

在Java中，每个类都有一个类名，该类名用于标识类。

类的语法格式如下：

class ClassName {
  // 数据成员
  // 函数成员
}

在Java中，一个类可以有多个函数成员，其中包括构造函数和普通函数。

构造函数是特殊的函数，用于在创建对象时初始化对象的属性。构造函数的名称必须与类名相同，且不能有返回值类型。

例如，下面是一个使用构造函数初始化对象的示例：

class Person {
  // 数据成员
  private String name;
  private int age;
  // 构造函数
  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }
  // 函数成员
  public void setName(String name) {
    this.name = name;
  }
  public String getName() {
    return this.name;
  }
  public void setAge(int age) {
    this.age = age;
  }
  public int getAge() {
    return this.age;
  }
}

Person p = new Person("Tom", 20);

在Java中，可以使用继承来实现代码的复用。继承是一种面向对象编程中的基本概念，可以将共有的属性和行为封装在父类中，然后使用继承关系将其复用到子类中。

继承的语法格式如下：

class SubClass extends SuperClass {
  // 子类的数据成员和函数成员
}

class Animal {
  // 数据成员
  private String name;
  // 构造函数
  public Animal(String name) {
    this.name = name;
  }
  // 函数成员
  public void setName(String name) {
    this.name = name;
  }
  public String getName() {
    return this.name;
  }
  public void speak() {
    System.out.println("I am an animal.");
  }
}

class Dog extends Animal {
  // 数据成员
  private String breed;
  // 构造函数
  public Dog(String name, String breed) {
    super(name);  // 调用父类的构造函数
    this.breed = breed;
  }
  // 函数成员
  public void setBreed(String breed) {
    this.breed = breed;
  }
  public String getBreed() {
    return this.breed;
  }
  // 重写父类的函数
  public void speak() {
    System.out.println("I am a dog.");
  }
}

在Java中，类还可以有接口，即一种特殊的类，它只包含函数的声明，而没有函数的实现。

接口可以被类实现，即一个类可以选择实现接口中的所有函数。实现接口的类必须为接口中的所有函数提供具体的实现。

例如，下面是一个使用接口的类的示例：

interface Shape {
  public double getArea();
  public double getPerimeter();
}

class Circle implements Shape {
  // 数据成员
  private double radius;
  // 构造函数
  public Circle(double radius) {
    this.radius = radius;
  }
  // 函数成员
  public void setRadius(double radius) {
    this.radius = radius;
  }
  public double getRadius() {
    return this.radius;
  }
  // 实现接口中的函数
  public double getArea() {
    return Math.PI * radius * radius;
  }
  public double getPerimeter() {
    return 2 * Math.PI * radius;
  }
}

Java还有一种特殊的类叫做抽象类，它可以包含数据成员和函数成员，但是可以有没有实现的函数，即抽象函数。

抽象类不能被实例化，只能被继承。继承抽象类的子类必须为抽象类中的抽象函数提供具体的实现。

例如，下面是一个使用抽象类的类的示例：

abstract class Shape {
  // 数据成员
  protected String color;
  // 构造函数
  public Shape(String color) {
    this.color = color;
  }
  // 函数成员
  public void setColor(String color) {
    this.color = color;
  }
  public String getColor() {
    return this.color;
  }
  // 抽象函数
  abstract public double getArea();
  abstract public double getPerimeter();
}

class Circle extends Shape {
  // 数据成员
  private double radius;
  // 构造函数
  public Circle(String color, double radius) {
    super(color);  // 调用父类的构造函数
    this.radius = radius;
  }
  // 函数成员
  public void setRadius(double radius) {
    this.radius = radius;
  }
  public double getRadius() {
    return this.radius;
  }
  // 实现抽象类中的函数
  public double getArea() {
    return Math.PI * radius * radius;
  }
  public double getPerimeter() {
    return 2 * Math.PI * radius;
  }
}

在Java中，可以使用接口来模拟多继承。例如，下面是一个使用接口的类的示例：

interface Animal {
  public void eat();
  public void sleep();
}

interface Bird {
  public void fly();
}

class Parrot implements Animal, Bird {
  public void eat() {
    // 实现eat函数
  }
  public void sleep() {
    // 实现sleep函数
  }
  public void fly() {
    // 实现fly函数
  }
}

Java中的包是用来组织类和接口的，避免名称冲突。例如，下面是一个使用包的类的示例：

package com.example;

import java.util.List;

public class MyClass {
  private List<Integer> list;
  // 其他代码
}

Java中的泛型是用来定义可以操作多种类型的数据的类和接口。例如，下面是一个使用泛型的类的示例：

public class MyClass<T> {
  private T data;
  // 其他代码
}

MyClass<String> myClass1 = new MyClass<String>();
myClass1.setData("hello");
String s = myClass1.getData();

MyClass<Integer> myClass2 = new MyClass<Integer>();
myClass2.setData(123);
int i = myClass2.getData();