java三大特性-继承

一、继承概述

1.1 什么是继承

在Java编程语言中，继承是一种使得某个类型的对象（类）能获取另一个类型的对象（类）的属性和方法的方式。

1.2 为什么使用继承

继承的主要优点包括：

• 1、减少代码的冗余，提高代码的运行效率。这是因为子类继承父类后，可以直接使用父类的属性和方法，避免了重复编写代码的工作。
• 2、便于子功能的拓展。子类不仅可以使用父类的属性和方法，还可以添加新的属性和方法，扩展父类的功能。
• 3、提供多态性的基础。多态性是面向对象编程的一个重要特性，它允许一个类的接口可以被另一个类继承并重新定义。
• 4、提高代码的可维护性。当需要修改父类的属性或方法时，只需要修改一处即可，所有继承自该父类的子类都会受到影响。
• 5、体现相关类间的层次结构关系。继承关系简化了人们对事物的认识和描述，能清晰体现相关类间的层次结构关系。

然而，Java继承也不可忽视其缺点：

• 1、增强了类之间的耦合。若父类发生变化，可能会影响到子类的正常使用，增加了代码的维护成本。
• 2、继承关系不可逆。一旦建立了继承关系，就无法撤销，这在某些情况下可能会带来问题。

1.3 如何实现继承

Java中实现继承需要遵循以下步骤：

• 1、定义一个父类，使用关键字"class"来声明一个类，并在类名后面加上冒号。
• 2、在父类中定义属性和方法。
• 3、定义子类，使用关键字"class"来声明一个类，并在类名后面加上冒号。
• 4、在子类中使用extends关键字来继承父类。
• 5、在子类中可以访问父类中的属性和方法。
  代码实例：

// 定义一个父类Person
public class Person {
    String name; // 定义属性name
    int age; // 定义属性age
    // 定义方法sayHello()
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am " + age + " years old.");
    }
}

// 定义一个子类Student，继承自Person类
public class Student extends Person {
    String school; // 定义属性school
    // 重写父类的sayHello()方法
    @Override
    public void sayHello() {
        System.out.println("Hello, my name is " + name + " and I am a student at " + school + ".");
    }
}

在上面的代码中，我们首先定义了一个名为Person的父类，其中包含了两个属性和一个方法。然后，我们定义了一个名为Student的子类，它继承了Person类，并添加了一个新的属性school。最后，我们在子类中重写了父类的sayHello()方法，以输出不同的信息。

二、方法重写

2.1 什么是方法重写

在Java中，子类可以重写父类的方法。方法重写是指子类提供了与父类相同名称和参数列表的方法。当子类对象调用该方法时，将执行子类中的实现，而不是父类中的实现。

方法重写的规则如下：

• 1、方法名必须相同。
• 2、参数列表必须相同（包括参数类型和顺序）。
• 3、返回值类型不一定要相同，但必须是父类方法的子类型或相同类型。
• 4、访问修饰符不能比父类方法更严格。
  代码实例：

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    // 重写父类的makeSound方法
    @Override
    void makeSound() {
        System.out.println("汪汪汪");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        myAnimal.makeSound(); // 输出：动物发出声音
        myDog.makeSound();     // 输出：汪汪汪
    }
}

2.2 为什么要方法重写

在Java编程语言中，方法重写是一种强大的工具，允许子类重新定义或扩展父类中的方法。这主要出于以下几个原因：

• 1、代码的重用性和复用性：子类继承父类后，若需要使用父类的功能，同时还需要加入自己特有的内容，就可以通过方法重写实现。子类不仅继承了父类的特性，同时还加入了自己的特性，实现了两全其美。
• 2、增强程序的灵活性和扩展性：有时，子类需要修改从父类继承来的方法的行为。方法重写提供了一种方式，使得子类能够根据需要定义特定于自己的行为。
• 3、提高代码的可读性和可维护性：当子类重写父类的方法时，建议使用@Override注解。这不仅可以提高代码的可读性，而且可以防止由于方法名相同但参数列表不同而导致的错误。
• 4、实现多态性：方法的重写与重载都是Java多态性的不同表现。其中，方法重写是父类与子类之间多态性的一种表现。

因此，方法重写为Java编程提供了高度的灵活性和控制力，是面向对象编程的一个重要组成部分。

2.3 重写与重载的区别

在Java编程语言中，重写（Override）和方法重载（Overload）是两个重要的概念，他们有着明显的区别：

• 1、方法重载：方法重载是指在同一个类中，允许存在一个以上同名的方法，但这些方法的参数列表必须不同。换句话说，只有参数列表不同的方法才能共存。这些方法的返回类型可以相同也可以不同。

• 2、方法重写：方法重写则是子类对父类已经存在的方法进行重新定义，以实现新的功能或修改现有功能的行为。方法重写的关键字是@Override，返回值和形参都不能改变。

以下是一个简单的示例来说明这两者的差异：

class Animal {
    void makeSound() {
        System.out.println("The animal makes a sound");
    }
}

class Dog extends Animal {
    // 方法重写
    @Override
    void makeSound() {
        System.out.println("The dog barks");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();
        // 调用父类的方法
        myAnimal.makeSound(); // 输出： The animal makes a sound
        // 调用子类的方法，将执行子类的重写方法
        myDog.makeSound();     // 输出： The dog barks
    }
}

三、继承中构造方法的初始化顺序

在Java中，当一个类继承另一个类时，子类的构造方法会首先调用父类的无参构造方法（如果存在），然后才会调用子类的构造方法。如果父类没有无参构造方法，那么子类的构造方法必须显式地调用父类的有参构造方法。

初始化顺序遵循以下规则：

• 1、父类的成员变量和成员方法首先被初始化。
• 2、然后是父类的构造方法。
• 3、最后是子类的构造方法。
  示例代码：

class Parent {
    int a;

    Parent() {
        System.out.println("Parent constructor");
    }

    Parent(int a) {
        this.a = a;
        System.out.println("Parent constructor with parameter");
    }
}

class Child extends Parent {
    int b;

    Child() {
        System.out.println("Child constructor");
    }

    Child(int a, int b) {
        super(a); // 调用父类的有参构造方法
        this.b = b;
        System.out.println("Child constructor with parameters");
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child(1, 2); // 输出：Parent constructor with parameter -> Child constructor with parameters
    }
}

四、super关键字

在Java编程语言中，super关键字是用于访问父类的属性和方法的。其主要的使用场景包括：

• 1、在子类的构造方法中显式地调用父类的构造方法。这种情况下，super()必须作为子类构造函数中的第一条语句。
• 2、当子类成员变量或方法与父类有相同的名字时，可以使用super关键字来访问父类的成员变量或方法，从而覆盖父类的成员变量或方法。
• 3、使用super关键字可以方便地访问被子类隐藏的父类同名成员变量和成员方法。

此外，需要特别注意的是，虽然super和this在某些情况下具有相似的功能，但两者并不完全相同。例如，super代表父类存储空间的标识，而this关键字大部分情况下是指代当前对象的。
示例代码：

// 示例1：在子类的构造方法中显式地调用父类的构造方法
class Animal {
    String name;
    Animal(String name) {
        this.name = name;
    }
}

class Dog extends Animal {
    int age;
    Dog(String name, int age) {
        super(name); // 调用父类的构造方法
        this.age = age;
    }
}

// 示例2：使用super关键字访问父类的成员变量或方法
class Parent {
    String name;
    Parent(String name) {
        this.name = name;
    }
}

class Child extends Parent {
    String address;
    Child(String name, String address) {
        super(name); // 调用父类的构造方法
        this.address = address;
    }
}

五、final修饰符

Java中的final修饰符用于修饰类、方法和变量。它有以下几种用途：

• 1、修饰类：当一个类被final修饰时，表示这个类不能被继承。这意味着子类无法继承这个类的属性和方法。

final class MyClass {
    // ...
}

• 2、 修饰方法：当一个方法被final修饰时，表示这个方法不能被子类重写（覆盖）。这意味着子类无法提供与父类相同的方法实现。

class Parent {
    final void myMethod() {
        // ...
    }
}

class Child extends Parent {
    // 编译错误：不能重写final方法
    // void myMethod() {
    //     ...
    // }
}

• 3、修饰变量：当一个变量被final修饰时，表示这个变量的值在初始化后不能被修改。这意味着这个变量只能被赋值一次。

class MyClass {
    final int myVariable = 10;
}

六、Object类

Java中的Object类是所有类的基类，它位于java.lang包中。每个Java对象都是通过直接或间接地继承Object类来创建的。

Object类提供了一些通用的方法和属性，例如：

• 1、构造方法：Object类有一个无参构造方法，可以在创建新对象时被调用。
• 2、toString()方法：返回对象的字符串表示形式。
• 3、equals()方法：比较两个对象是否相等。
• 4、hashCode()方法：返回对象的哈希码值。
• 5、getClass()方法：返回对象的运行时类信息。
• 6、clone()方法：创建并返回一个与该对象相同类型的副本。
• 7、finalize()方法：在垃圾回收器准备释放对象所占用的内存之前被调用。
• 8、wait()方法：使当前线程等待，直到其他线程调用该对象的notify()或notifyAll()方法。
• 9、notify()方法：唤醒在此对象监视器上等待的单个线程。
• 10、notifyAll()方法：唤醒在此对象监视器上等待的所有线程。

由于Object类是所有类的基类，因此这些方法和属性在所有Java类中都可以使用。