JAVA面向对象程序设计（二）-优快云博客

本文链接：https://blog.youkuaiyun.com/MeyrlNotFound/article/details/146115816

继承

在Java面向对象程序设计中，继承是一个核心概念，它允许创建分等级层次的类，是代码重用和设计的重要工具。以下是对Java继承的详细阐述：

一、继承的基本概念

1. 定义：

继承是面向对象三大特征之一，它指的是一个类（子类或派生类）可以继承另一个类（父类或基类）的属性和方法，使得子类具有父类的特征和行为。

2. 关键字：

Java中使用extends关键字来实现继承。

3. 格式：

class 子类名 extends 父类名 {}。

二、继承的特点

1. 单继承：

Java只支持单继承，即一个类只能有一个直接父类。但是，一个类可以有多个间接父类，这是因为一个父类本身也可以继承其他类。

2. 多层继承：

子类可以继承父类，同时父类也可以继承其他类，形成多层继承关系。

3. 继承关系：

子类和父类之间应该具有“is a”的关系，即子类应该是父类的一种。

4. Object类：

所有Java类都直接或间接地继承自Object类，它是所有Java类的根类。

三、继承的内容

1. 构造方法：

父类的构造方法不能被子类继承。子类在实例化时，会首先调用其父类的构造方法，然后才会执行子类的构造方法。如果子类需要调用父类的带参构造方法，必须使用super关键字显式调用。

2. 成员变量：

子类可以继承父类的非私有成员变量。私有成员变量虽然不能被直接访问，但可以通过父类的public或protected修饰的getter和setter方法间接访问。

3. 成员方法：

子类可以继承父类的非私有成员方法。私有成员方法不能被继承。重写（Override）是子类对父类非私有成员方法的另一种使用方式，即子类提供与父类方法相同签名的方法实现。

四、继承中的访问特点

1. 成员变量：

在子类方法中访问一个变量时，遵循就近原则。首先在子类局部范围查找，如果没有，则在子类成员范围查找，最后在父类成员范围查找。如果都没有找到，则报错。

2. 成员方法：

通过子类对象访问一个方法时，也是遵循就近原则。首先在子类成员范围查找，如果没有，则在父类成员范围查找。如果都没有找到，则报错。

3. this和super：

• this关键字代表当前对象的引用，用于访问本类的成员变量和方法。

• super关键字代表父类对象的引用，用于访问父类的成员变量、方法和构造方法。在子类构造方法中，super()调用必须出现在第一条语句，用于调用父类的构造方法。

五、方法重写

1. 定义：

方法重写是指子类提供了与父类在方法签名上相同（方法名、参数列表、返回类型相同）的方法实现。

2. 目的：

当父类的方法不能满足子类的需求时，子类可以通过重写父类的方法来提供自己的实现。

3. 规则：

• 重写方法的访问权限不能低于被重写方法的访问权限。

• 重写方法的返回类型必须与被重写方法的返回类型相同或是其子类。

• 重写方法不能抛出比被重写方法更多的异常。

• 可以使用@Override注解来明确标识一个方法是重写父类的方法，这有助于编译器检查重写的正确性。

六、继承的优点和弊端

1. 优点：

• 代码重用：通过继承，子类可以重用父类的代码，避免重复编写相同的代码。

• 易于维护：继承使得代码结构更加清晰，易于管理和维护。

• 扩展性强：通过继承，可以方便地扩展现有类的功能。

2. 弊端：

• 耦合度高：子类与父类之间存在紧密的耦合关系，一旦父类发生变化，子类也可能需要相应地调整。

• 破坏了封装性：子类可以访问父类的非私有成员，这可能会破坏封装性。

综上所述，Java中的继承是一个强大的特性，它允许子类重用父类的代码和特征。然而，在使用继承时也需要注意其可能带来的问题，如耦合度高和封装性破坏等。因此，在设计类时应该谨慎使用继承，并考虑其他设计模式来替代继承关系以降低代码的复杂性和提高可维护性。

super 关键字

在Java面向对象程序设计中，super关键字是一个非常重要的概念，它主要用于引用父类的属性和方法。以下是关于super关键字的详细知识：

一、super关键字的基本用途

1. 访问父类的成员变量：

• 当子类和父类中存在同名的成员变量时，子类无法直接访问父类的同名成员变量。此时，可以使用super关键字来访问父类中的成员变量。

• 示例：

 public class Person {
       public String name = "张三";
   }
   public class Student extends Person {
       public String name = "李四";
       public void showName() {
           System.out.println("姓名为:" + name);
           System.out.println("父类中的姓名为:" + super.name);
       }
   }

输出结果：

姓名为:李四
父类中的姓名为:张三

2. 调用父类的方法：

• 当子类需要调用父类的方法时，可以使用super关键字。特别是当子类重写了父类的方法，但仍需要调用父类的原始实现时，super关键字非常有用。

• 示例：

public class Person {
       public void hello() {
           System.out.println("大家好,我是Person类。");
       }
   }
   public class Student extends Person {
       public void hello() {
           System.out.println("大家好,我是Student类。");
           super.hello();
       }
   }

输出结果：

大家好,我是Student类。
大家好,我是Person类。

3. 调用父类的构造方法：

• 在子类的构造方法中，可以使用super关键字来调用父类的构造方法。这是初始化那些继承自父类的属性的一种常用方法。

• 示例：

 public class Vehicle {
       protected String brand;
       public Vehicle(String brand) {
           this.brand = brand;
       }
   }
   public class Car extends Vehicle {
       private int doors;
       public Car(String brand, int doors) {
           super(brand); // 调用父类的构造方法
           this.doors = doors;
       }
   }

二、使用super关键字时的注意事项

1. 调用父类构造方法的位置：

• 在子类的构造方法中，调用父类构造方法的语句（super(形参列表)）必须声明在构造器的首行。

2. this与super的互斥性：

• 在类的构造器中，针对于“this(形参列表)”和“super(形参列表)”只能二选一，不能同时出现。

3. 默认调用父类无参构造方法：

• 在构造器的首行，如果没有显式的声明“this(形参列表)”或“super(形参列表)”，则默认调用的是父类中空参的构造器：super()。

4. 父类构造方法的必要性：

• 在类的多个构造器中，至少有一个类的构造器中使用了“super(形参列表)”来调用父类中的构造器。如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错。

三、super关键字与this关键字的区别

1. 引用对象不同：

• super关键字表示对父类对象的引用。

• this关键字表示对当前对象的引用。

2. 用途不同：

• super关键字主要用于访问父类的成员变量和成员方法，以及调用父类的构造方法。

• this关键字主要用于访问本类中的成员变量和成员方法，也可以调用本类的构造方法（通过在一个构造器中调用另一个构造器）。

3. 构造器中的使用：

• this关键字可以在构造方法中调用不同的构造方法来实现代码的重用。

• super关键字在构造方法中只能用来调用父类的构造方法。

综上所述，super关键字在Java面向对象程序设计中扮演着至关重要的角色，它使得子类能够方便地访问和调用父类的成员变量、方法和构造方法，从而实现类的行为的适当重用和扩展。

final 关键字

在Java面向对象程序设计中，final关键字是一个非常重要的修饰符，它可以用于修饰类、方法和变量。以下是关于final关键字的详细知识：

一、final修饰变量

1. 基本类型变量：

当final修饰基本类型变量时，该变量就变成了常量，其值在初始化后不能被改变。这是为了保证变量的不变性，提高程序的可读性和安全性。例如：

 final int MAX_VALUE = 100;

在上面的代码中，MAX_VALUE是一个常量，其值为100，不能被重新赋值。

2. 引用类型变量：

当final修饰引用类型变量时，该变量的引用（即内存地址）不能被改变，但是该引用所指向的对象的内容是可以被修改的。例如：

 final Person person = new Person("Alice");
person.setName("Bob"); // 可以修改person对象的内容
// person = new Person("Charlie"); // 错误，不能重新赋值

在上面的代码中，person是一个final变量，其引用不能被改变，但是person对象的内容（如姓名）是可以被修改的。

3. 初始化：

final变量必须在声明时或者在构造器中被初始化。对于类的成员变量，还可以在静态代码块中初始化。例如：

final int num1 = 10; // 声明时初始化
final int num2;
public MyClass(int num2) {
    this.num2 = num2; // 构造器中初始化
}

对于静态变量，还可以在静态代码块中初始化：

 static final int NUM_THREADS = Runtime.getRuntime().availableProcessors();
static {
    // 静态代码块中也可以进行初始化
}

二、final修饰方法

当final修饰方法时，该方法不能被子类重写。这是为了保证方法的行为在继承体系中不被改变，从而提高程序的安全性和稳定性。例如：

 class Animal {
    public final void eat() {
        System.out.println("This animal eats food.");
    }
}

class Dog extends Animal {
    // 下面的代码会导致编译错误，因为eat方法被final修饰了，不能被重写
    // @Override
    // public void eat() {
    //     System.out.println("This dog eats dog food.");
    // }
}

在上面的代码中，Animal类中的eat方法被final修饰了，因此Dog类不能重写该方法。

三、final修饰类

当final修饰类时，该类不能被继承。这是为了保证类的不可变性，防止其他类通过继承来修改该类的行为或属性。例如：

 public final class MathUtils {
    // 类中的方法和属性
}

// 下面的代码会导致编译错误，因为MathUtils类被final修饰了，不能被继承
// class MyMathUtils extends MathUtils {
//     // 类中的方法和属性
// }

在上面的代码中，MathUtils类被final修饰了，因此不能被其他类继承。

四、final关键字的其他用途

1. 提高性能：

由于final变量在编译时就已经确定了其值，因此编译器可以对final变量进行优化，从而提高程序的运行效率。例如，final变量可以被缓存，从而避免在运行时进行不必要的查找和计算。

2. 设计不变模式：

通过final关键字，可以设计出不可变（immutable）的对象。不可变对象在创建后其状态就不能被改变，这有助于保证线程安全和数据的一致性。例如，String类就是一个不可变类，其所有修改操作都会返回一个新的String对象，而不会改变原有的String对象。

3. 与匿名内部类一起使用：

在Java中，匿名内部类只能访问包含它的外部类中的final变量。这是因为匿名内部类在编译时需要一个固定的值来初始化其内部的变量副本。例如：

 public class Test {
    public static void main(String[] args) {
        final int num = 10;
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                System.out.println("Number: " + num);
            }
        };
        new Thread(runnable).start();
    }
}

在上面的代码中，匿名内部类Runnable访问了外部类中的final变量num。

五、注意事项

1. final变量必须在声明时或者在构造器中被初始化，否则会导致编译错误。

2. final方法不能被子类重写，但是可以被继承。

3. final类不能被继承，因此其内部的方法没有必要再被final修饰。

4. 当使用final关键字时，应该遵循Java的命名规范，例如常量名通常使用全大写字母，并使用下划线分隔单词。

综上所述，final关键字在Java面向对象程序设计中具有重要的作用，它可以帮助我们设计出更加安全、稳定和高效的程序。

abstract 关键字

在Java面向对象程序设计中，abstract关键字是一个核心概念，它主要用于定义抽象类和抽象方法。以下是关于abstract关键字的详细知识：

一、abstract关键字的作用

1. 定义抽象类：

• 使用abstract关键字修饰的类称为抽象类。

• 抽象类不能被实例化，即不能使用new关键字创建对象。它只能作为其他类的父类，供子类继承。

• 抽象类可以包含抽象方法和具体方法。抽象方法是没有方法体的方法，需要在子类中实现；而具体方法则包含方法体，可以直接在抽象类中被调用。

2. 定义抽象方法：

• 使用abstract关键字修饰的方法称为抽象方法。

• 抽象方法只有方法声明，没有方法体（即没有具体的实现）。

• 抽象方法必须定义在抽象类中。

• 子类继承抽象类时，必须实现抽象类中的所有抽象方法，否则子类也必须被声明为抽象类。

二、abstract关键字的语法

1. 定义抽象类：

 abstract class ClassName {
    // 抽象方法
    abstract void methodName();
    
    // 具体方法
    void concreteMethod() {
        // 方法实现
    }
}

2. 定义抽象方法：

在抽象类中定义抽象方法时，只需使用abstract关键字修饰方法声明，并省略方法体即可。例如：

 abstract class Animal {
    // 抽象方法
    abstract void makeSound();
    
    // 具体方法
    void eat() {
        System.out.println("This animal eats food.");
    }
}

三、abstract关键字的使用场景

1. 定义接口：

• 当需要定义一组方法，但这些方法的具体实现取决于子类时，可以使用抽象类和抽象方法。这提供了一种定义接口的方式，确保所有子类都具有一些共同的行为。

2. 共享代码：

• 抽象类可以包含具体方法和成员变量，这些方法和变量可以被多个子类共享。这有助于减少代码重复，提高代码的可维护性。

3. 强制实现：

• 通过定义抽象方法，可以强制子类实现某些特定的行为。这有助于确保子类的一致性，并防止子类遗漏必须实现的方法。

4. 模板方法模式：

• 在模板方法模式中，抽象类定义了一个算法的骨架，将一些步骤延迟到子类中实现。这提供了一种灵活的方式来定义算法的通用部分和可变部分，使得子类可以定制算法的具体实现。

四、注意事项

1. 抽象类不能被实例化：

• 尝试实例化抽象类会导致编译错误。

2. 抽象方法必须被子类实现：

• 如果子类没有实现抽象类中的所有抽象方法，那么子类也必须被声明为抽象类。

3. 抽象类可以有构造器：

• 抽象类的构造器主要用于初始化抽象类中的成员变量。虽然抽象类不能被实例化，但其构造器在子类实例化时会被调用。

4. abstract关键字不能修饰变量、构造器、静态方法等：

• abstract关键字只能用于修饰类和方法，不能用于修饰属性、构造器、静态方法、代码块等结构。

综上所述，abstract关键字在Java面向对象程序设计中具有重要作用，它提供了定义抽象类和抽象方法的能力，使得我们可以设计出更加灵活、可扩展和可维护的程序结构。

接口

在Java面向对象程序设计中，接口是一个核心概念，它定义了一组抽象方法和常量，用于描述类应该具有的行为，但不提供具体的实现。以下是关于Java接口的详细知识：

一、接口的定义

接口使用interface关键字定义，它包含抽象方法和常量。在Java 8及以后的版本中，接口还可以包含默认方法和静态方法，而在Java 9及以后的版本中，接口还可以包含私有方法。

接口的基本语法如下：

 [访问修饰符] interface 接口名 [extends 父接口列表] {
    // 常量声明（默认是 public static final）
    [public static final] 数据类型 常量名 = 初始值;
    
    // 抽象方法声明（默认是 public abstract）
    [public abstract] 返回类型 方法名(参数列表);
    
    // Java 8+ 默认方法
    default 返回类型 方法名(参数列表) {
        // 方法体（默认实现）
    }
    
    // Java 8+ 静态方法
    static 返回类型 方法名(参数列表) {
        // 方法体（静态实现）
    }
    
    // Java 9+ 私有方法
    private 返回类型 方法名(参数列表) {
        // 方法体（私有实现）
    }
}

二、接口的特性

1. 抽象性：

接口是纯抽象的，不能被实例化。它只定义了一组方法，而不提供具体的实现。

2. 多继承：

一个接口可以继承多个父接口，这允许接口组合多个功能。

3. 实现：

类通过implements关键字实现接口。一个类可以实现多个接口，但只能继承一个父类（单继承）。

4. 强制约束：

接口对实现类是一种强制性的约束。实现类必须提供接口中所有抽象方法的具体实现，否则该类必须声明为抽象类。

三、接口中的成员

1. 常量：

接口中的成员变量默认是public static final修饰的，即它们是公共的、静态的、最终的。

2. 抽象方法：

接口中的方法默认是public abstract修饰的。在Java 8之前，接口中只能包含抽象方法。

3. 默认方法（Java 8+）：

允许在接口中提供方法的默认实现。实现类可以选择性地覆盖这些方法。

4. 静态方法（Java 8+）：

属于接口本身而不是实现类，可以直接通过接口名调用。它们不能被实现类重写。

5. 私有方法（Java 9+）：

只能在接口内部被默认方法或静态方法调用，用于提取公共代码，提高代码复用性。

四、接口的使用场景

1. 定义规范：

接口规定了一组类应该具有的行为，确保所有实现类都具有相同的行为。

2. 统一行为：

通过接口，可以确保不同的实现类具有统一的行为，方便使用者调用。

3. 可替换性：

接口允许轻松替换不同的实现类，而无需修改使用接口的代码。

4. 降低耦合度：

接口可以将接口的定义与实现分离，降低代码之间的耦合度，提高代码的可维护性和可扩展性。

5. 实现多态性：

接口是实现多态性的重要手段。通过接口引用指向不同的实现类对象，并调用相同的方法，可以实现不同的行为。

五、示例代码

以下是一个简单的接口示例：

 // 定义一个接口
interface Animal {
    void eat();
    void sleep();
    
    // Java 8+ 默认方法
    default void run() {
        System.out.println("Animal is running.");
    }
}

// 实现接口的类
class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }

    @Override
    public void sleep() {
        System.out.println("Dog is sleeping.");
    }
    
    // 覆盖默认方法
    @Override
    public void run() {
        System.out.println("Dog is running fast.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.eat();
        myDog.sleep();
        myDog.run();
    }
}

在上面的示例中，Animal接口定义了两个抽象方法eat和sleep，以及一个默认方法run。Dog类实现了Animal接口，并提供了eat和sleep方法的具体实现，同时还覆盖了默认方法run。

综上所述，接口在Java面向对象程序设计中扮演着重要角色，它定义了一组抽象方法和常量，用于描述类应该具有的行为，并通过实现接口的方式，确保所有实现类都具有相同的行为规范。

内部类

Java面向对象程序设计中的内部类是一种特殊的类，它定义在另一个类的内部。以下是关于Java内部类的详细知识：

一、内部类的定义与分类

内部类就是定义在一个类里面的类，可以理解为里面的类是寄生，外部的类是宿主。内部类通常用于封装与外部类紧密相关的逻辑，并提供更好的封装性。Java中的内部类主要分为以下几类：

1. 成员内部类（非静态内部类）：

无static修饰，属于对象。它可以访问外部类的所有成员，包括私有成员。创建成员内部类对象需要通过外部类对象来创建。

2. 静态内部类：

使用static关键字修饰的内部类，隶属于类层级。它不能访问外部类的非静态成员，但可以直接访问外部类的静态成员。静态内部类可以直接创建对象，无需依赖外部类对象。

3. 局部内部类：

定义在方法、代码块或构造器中的内部类。它的作用域仅限于定义它的方法、代码块或构造器内部。局部内部类通常用于临时性的逻辑封装。

4. 匿名内部类：

没有名字的内部类，通常用于简化代码编写。匿名内部类常用于实现接口或创建子类对象，特别是在GUI编程中处理事件监听器时非常有用。

二、内部类的特性

1. 封装性：

内部类可以将相关逻辑封装在外部类中，使代码更加模块化和清晰。同时，内部类本身可以用private、protected等修饰符进行修饰，从而进一步控制封装性。

2. 访问权限：

内部类可以直接访问外部类的所有成员，包括私有成员。这使得内部类在处理与外部类紧密相关的逻辑时更加方便。

3. 实现接口：

内部类可以实现外部类或接口，从而提供更灵活的设计。例如，一个类可以通过其内部类实现多个接口，从而模拟多继承的效果。

4. 回调机制：

内部类常用于实现回调机制。例如，在GUI编程中，可以使用匿名内部类作为事件监听器来处理用户事件。

三、内部类的使用场景

1. 当一个类的内部还需要一个完整结构进行描述，而这个内部的完整结构又只为外部类服务时，可以使用内部类。例如，一个表示人的类中可以包含一个表示地址的内部类，因为地址与人是紧密相关的，并且地址只为这个人服务。

2. 简化代码编写：匿名内部类常用于简化代码编写。例如，在实现接口或创建子类对象时，可以直接使用匿名内部类来避免编写额外的类定义。

3. 回调接口：当某个类需要一个对象来执行其方法时，通常可以使用回调接口。这时，内部类可以作为一个匿名实现类来简化代码。例如，在GUI编程中处理事件监听器时，可以使用匿名内部类来实现回调接口。

4. 隐藏实现细节：内部类可以将实现细节隐藏在外部类内部，从而提供一个更简洁、更易于使用的API。例如，一个数据持有类可以包含一个内部类来处理数据，而外部类只提供获取内部类对象的接口。

四、内部类的示例代码

以下是一个关于内部类的示例代码及其解释：

 public class OuterClass {
    private String outerField = "Outer Field";

    // 成员内部类
    public class InnerClass {
        private String innerField = "Inner Field";

        public void display() {
            // 内部类可以访问外部类的成员变量
            System.out.println("Outer field: " + outerField);
            System.out.println("Inner field: " + innerField);
        }
    }

    // 静态内部类
    public static class StaticInnerClass {
        private String innerField = "Static Inner Field";

        public void display() {
            // 静态内部类只能访问外部类的静态成员变量（假设有一个静态成员变量）
            // 注意：这里为了示例说明，我们假设OuterClass有一个静态成员变量staticOuterField
            // System.out.println("Static outer field: " + OuterClass.staticOuterField);
            System.out.println("Inner field: " + innerField);
        }
    }

    public static void main(String[] args) {
        // 创建外部类的实例
        OuterClass outer = new OuterClass();

        // 创建成员内部类的实例
        OuterClass.InnerClass inner = outer.new InnerClass();

        // 调用内部类的方法
        inner.display();

        // 创建静态内部类的实例（注意：静态内部类不需要依赖外部类对象）
        OuterClass.StaticInnerClass staticInner = new OuterClass.StaticInnerClass();

        // 调用静态内部类的方法
        staticInner.display();
    }
}

注意：在上面的示例代码中，静态内部类StaticInnerClass尝试访问外部类的静态成员变量staticOuterField的部分被注释掉了，因为在实际的OuterClass定义中并没有这个静态成员变量。为了完整性，你可以自行在OuterClass中添加一个静态成员变量staticOuterField，并取消注释相应的代码行。

综上所述，Java内部类是一种强大的特性，它提供了更好的封装性、访问权限控制、实现接口和回调机制等能力。在面向对象程序设计中合理利用内部类可以使代码更加简洁、模块化和易于维护。