第二讲__简答题

1.简单解释一下你对多态的理解？

​        多态是面向对象编程的一个核心特性，它允许子类对象可以被当作父类对象来使用。在Java中，多态主要通过以下几种方式实现：
        1.方法重写（Overriding）：

                子类覆盖父类的方法，使得在运行时根据对象的实际类型调用相应的方法。
        2.接口实现：

                一个类可以通过实现多个接口来获得多态的能力。
        3.抽象类与抽象方法：

                抽象类中的抽象方法必须在子类中具体实现，不同子类可以根据需要提供不同的实现版本。
多态的主要优点包括：
        代码复用：通过继承机制，子类可以复用父类的方法和属性。
        灵活性：可以在运行时决定使用哪个对象的方法，提高了程序的扩展性和灵活性。
        简化代码：可以使用父类引用指向子类对象，简化了代码结构。

2.instenceof关键字的作用是什么？ 用在什么场景下？

        ​instanceof 是 Java 中的一个关键字，用于判断一个对象是否属于某个类或接口的实例（或子类实例）。它的语法如下：

object instanceof ClassName

        其中 object 是要检查的对象，ClassName 是要检查的类或接口名称。

作用
        1.类型检查：

                确定一个对象是否为指定类或接口的实例。
        2.向下转型前的安全检查：

                在进行向下转型之前，使用 instanceof 来确保转型是安全的。
使用场景
        1.多态环境下的类型判断：
                当你有一个父类类型的引用，但实际操作的是子类对象时，可以使用 instanceof 来判断实际对象的类型。
        2.安全地向下转型：
                在多态环境中，如果需要将父类引用转换为子类引用，先使用 instanceof 检查可以避免 ClassCastException。
        3.接口实现检查：
                当一个类实现了多个接口时，可以使用 instanceof 来判断对象是否实现了特定接口。
        4.异常处理：
                在处理异常时，可以使用 instanceof 来判断异常的具体类型，并据此采取不同的处理措施。

3.final关键字可以修饰什么？有什么特点？

        ​final 关键字在 Java 中可以用来修饰类、方法和变量。下面是 final 关键字修饰不同实体的特点：
1. 修饰类
        不可继承：

                如果一个类被声明为 final，那么这个类不能被继承。也就是说，其他类不能从这个类派生出子类。
        用途：

                通常用于那些不需要被继承或者不希望被继承的类，比如 java.lang.String 类就是 final 的。
2. 修饰方法
        不可重写：

                如果一个方法被声明为 final，那么这个方法不能在子类中被重写（override）。
        可继承：

                尽管 final 方法不能被重写，但它们仍然可以被继承。
        用途：

                用于那些不希望被子类修改的行为，确保方法的实现不会被改变。
3. 修饰变量
        常量：

                如果一个变量被声明为 final，那么这个变量的值一旦被初始化后就不能被改变。
        基本类型：

                对于基本数据类型，final 变量的值不能改变。
        引用类型：

                对于引用类型，final 变量的引用不能改变，但引用的对象的内容可以改变（除非对象本身也是 final 的）。
        用途：

                用于定义常量，确保变量的值在整个程序执行过程中保持不变。

4.被final修饰的基本类型和引用类型变量有啥区别？

​对基本类型变量的影响
        不可改变：

                当 final 修饰一个基本类型变量时，该变量一旦被初始化就不能再被重新赋值。
值的不可变性：

                这意味着基本类型变量的值在其生命周期内是固定的。

---

对引用类型变量的影响
        引用不可改变：

                当 final 修饰一个引用类型变量时，该变量指向的内存地址（即引用）不能被改变。
        对象的可变性：

                虽然引用不可改变，但引用的对象本身是可以改变的，只要该对象不是 final 类型。

---

总结
        基本类型：

                final 修饰的基本类型变量表示该变量的值一旦被设置就不可改变。
        引用类型：

                final 修饰的引用类型变量表示该变量指向的对象引用不可改变，但对象本身的状态可以改变。
注意事项
        如果 final 修饰的引用类型变量指向了一个 final 类的实例，那么该实例的所有状态都是不可改变的。
        对于引用类型，即使变量本身是 final 的，如果指向的对象是可变的，那么该对象的状态仍然可以被修改。
        这些区别对于理解 Java 中的不可变性和多线程编程尤为重要。使用 final 修饰符可以帮助确保对象的状态在多线程环境下的一致性和安全性。

5.什么是抽象类？有什么特点？

​抽象类是一种特殊的类，它主要用于定义一个类族的公共接口和行为，但不允许直接实例化。

---

特点
        1.抽象类的声明：
                抽象类需要用 abstract 关键字声明。
                抽象类可以包含抽象方法（只有方法声明而没有方法体的方法）和非抽象方法（即普通方法）。
        2.不能实例化：
                抽象类不能被实例化，也就是说，不能创建抽象类的对象。
                如果尝试创建一个抽象类的实例，将会导致编译错误。
        3.抽象方法：
                抽象方法也需要用 abstract 关键字声明。
                抽象方法只有方法签名而没有方法体，即没有具体实现。
                抽象方法必须在子类中被实现（除非子类也是抽象类）。
        4.子类实现：
                子类可以继承抽象类，并且必须实现抽象类中的所有抽象方法，除非子类也是抽象类。
                如果子类实现了所有的抽象方法，则子类可以是非抽象类；否则，子类也必须声明为抽象类。
        5.构造方法：
                抽象类可以有构造方法，这些构造方法会被子类使用，以便在子类构造过程中初始化抽象类的部分状态。
        6.成员变量：
                抽象类可以包含成员变量，这些变量可以是普通的成员变量，也可以是静态成员变量。
成员变量不需要声明为抽象。
        7.继承：
                抽象类可以继承另一个抽象类或非抽象类。
                抽象类也可以实现一个或多个接口。
        8.不能被密封：
                抽象类不能被声明为 final，因为它本身就是用来被继承的。
        9.使用场景：
                抽象类通常用于定义一组相关的类的公共接口和行为。
                抽象类可以提供默认实现，同时强制子类实现某些特定的方法。

6.什么是设计模式？模板方法设计模式的作用和使用步骤是怎样的？

​什么是设计模式？对于某类问题,前人总结出类的解决问题的套路

模板方法设计模式的作用

        算法结构的固定：

                确保算法的结构不变，而允许子类提供特定的实现。
        代码复用：

                子类可以继承父类提供的算法框架，只需实现特定的步骤。
        易于扩展：

                通过定义抽象操作，子类可以很容易地扩展算法的功能，而无需修改现有代码。

使用步骤
        定义抽象基类：

                创建一个抽象基类，该类包含一个模板方法和一个或多个抽象方法。
        实现模板方法：

                在抽象基类中定义一个模板方法，该方法描述了算法的步骤，并调用抽象方法。
        声明抽象操作：

                在抽象基类中声明一个或多个抽象方法，这些方法将在子类中实现。
        实现具体子类：

                创建一个或多个具体子类，这些子类继承抽象基类并实现抽象方法。
        调用模板方法：

                在子类中调用模板方法，从而执行整个算法流程。

7.如何使用抽象类？

​        抽象类在 Java 中用于定义一个类族的共同行为和属性，但不允许直接实例化。下面是如何使用抽象类的步骤：
        创建抽象类
                1.声明抽象类：使用 abstract 关键字声明一个类为抽象类。
                2.定义抽象方法：在抽象类中定义一个或多个抽象方法，抽象方法也需要用 abstract 关键字声明，并且没有方法体。
                3.定义非抽象方法：除了抽象方法外，抽象类还可以包含非抽象方法（即有方法体的方法）。
        继承抽象类
                1.创建子类：定义一个新的类来继承抽象类。
                2.实现抽象方法：在子类中实现抽象类中的所有抽象方法。如果子类没有实现所有抽象方法，则子类也必须声明为抽象类。
                3.使用非抽象方法：子类可以直接使用抽象类中的非抽象方法。

8.一个类如何实现接口，实现接口后有什么要求？

        ​在 Java 中，一个类可以通过使用 implements 关键字来实现一个或多个接口。

        当一个类实现接口时，它必须满足以下要求：
                实现所有抽象方法：类必须实现接口中声明的所有抽象方法。如果类本身是抽象类，则可以不实现接口中的所有方法。
                遵循方法签名：实现的方法必须与接口中声明的方法具有相同的返回类型、方法名、参数列表和抛出的异常。
                访问权限：实现的方法至少需要与接口中声明的方法具有相同的访问级别。例如，如果接口中的方法是 public 的，那么实现的方法也必须是 public 的。
        实现接口的步骤
                声明类：定义一个类。
                使用 implements 关键字：在类声明中使用 implements 关键字后跟上要实现的接口名称。
实现方法：实现接口中声明的所有方法。