Java类设置 2

在Java编程中，类是一个非常重要的概念。类是对象的模板，用于描述对象的属性和方法。在这里，我们将介绍Java中一些常用的类设置，包括构造函数、继承、重写和多态性。

构造函数

在Java中，构造函数是用于创建和初始化对象的特殊方法。构造函数在类创建对象时自动被调用，并且可以设定对象的初始状态。在Java中，所有的类都有一个默认的构造函数，它没有参数，也没有任何操作。

自定义构造函数

我们可以通过自定义构造函数来设定对象的初始状态。自定义构造函数有以下几个特点：

• 构造函数与类名相同；
• 构造函数没有返回值；
• 构造函数可以有多个参数；
• 构造函数可以被重载。

下面是一个示例：

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 void setName(String name) {
    this.name = name;
  }

  public int getAge() {
    return age;
  }

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

在上述示例中，我们定义了一个Person类，并通过构造函数设定了两个属性：name和age。

继承

在Java中，我们可以通过继承来重用已有的代码，并且可以在此基础上添加新的功能。子类可以继承父类的属性和方法，并且可以进行修改或扩展。Java中使用extends关键字来实现继承。

public class Student extends Person {
  private String major;

  public Student(String name, int age, String major) {
    super(name, age);
    this.major = major;
  }

  public String getMajor() {
    return major;
  }

  public void setMajor(String major) {
    this.major = major;
  }
}

在上述示例中，我们定义了一个Student类，并通过继承Person类来获得name和age属性。

重写

在Java中，子类可以重写父类的方法，以便实现新的功能或改进性能。子类可以在方法签名相同的情况下重写父类的方法，并且可以使用super关键字来调用父类的方法。

public class Employee {
  public void work() {
    System.out.println("I am working!");
  }
}

public class Manager extends Employee {
  @Override
  public void work() {
    super.work();
    System.out.println("I am managing!");
  }
}

在上述示例中，Manager类重写了Employee类的work方法，并且在重写后使用super关键字调用了Employee类的work方法。

多态性

在Java中，多态性是指同一个方法名可以应用于不同的对象类型，并有不同的行为。多态性可以通过对象的向上转型或向下转型来实现。向上转型可以将一个子类的实例转化为父类的类型，可以实现多态性。向下转型可以将一个父类的实例转化为子类的类型，但需要注意类型转换时可能会出现ClassCastException异常。

public class Animal {
  public void move() {
    System.out.println("I'm moving!");
  }
}

public class Dog extends Animal {
  @Override
  public void move() {
    System.out.println("I'm running!");
  }

  public void bark() {
    System.out.println("Woof!");
  }
}

public class Cat extends Animal {
  @Override
  public void move() {
    System.out.println("I'm jumping!");
  }

  public void meow() {
    System.out.println("Meow!");
  }
}

在上述示例中，我们定义了一个Animal类和两个子类：Dog和Cat。由于Dog和Cat都继承了Animal类，因此我们可以使用Animal类型的变量来引用Dog或Cat的实例。

Animal animal = new Animal();
Dog dog = new Dog();
Cat cat = new Cat();

animal.move(); // 输出 "I'm moving!"
dog.move(); // 输出 "I'm running!"
cat.move(); // 输出 "I'm jumping!"

animal = dog;
animal.move(); // 输出 "I'm running!"
((Dog) animal).bark(); // 输出 "Woof!"

animal = cat;
animal.move(); // 输出 "I'm jumping!"
((Cat) animal).meow(); // 输出 "Meow!"

在上述示例中，我们利用向上转型将Dog和Cat的实例赋值给Animal类型的变量，并且调用了它们的move方法。利用向下转型，我们可以将Animal类型的变量转化为Dog或Cat类型，并且访问它们新增的方法。