基础知识点理解

1.父类只有一个带参数的构造方法，子类应该怎么样继承？

在子类构造方法中使用super关键字调用对应的代参构造函数，并提供对应需要的参数（显式调用）

在Java中，如果父类只有一个带参数的构造方法，子类必须显式地调用这个带参数的构造方法。这是通过在子类的构造方法中使用super关键字来实现的。以下是具体的步骤：

1. 在子类的构造方法中，使用super关键字调用父类的带参数的构造方法。

2. 传递必要的参数给super，这些参数必须与父类构造方法的参数列表相匹配。

2.子类怎么样调用父类的构造方法和属性？

父类的无参构造函数在子类构造函数被调用运行时会自动加载运行，但是要调用父类的有参构造函数时，必须使用super关键字对父类的有参构造函数进行一个显式调用，并提供与之对应的参数数据

在Java中，如果父类有一个无参构造函数，那么在创建子类实例时，这个无参构造函数会自动被调用。但是，如果父类没有无参构造函数，或者我们想要显式地调用父类的有参构造函数，我们必须在子类的构造函数中使用super关键字。 以下是优化后的答案： 在Java中，子类调用父类的构造方法和属性的方法如下：

调用父类的构造方法：

• 无参构造方法：如果父类有一个无参构造方法，那么在创建子类实例时，这个无参构造方法会自动被调用，无需显式调用。

• 有参构造方法：如果父类有一个或多个有参构造方法，并且没有无参构造方法，那么子类必须在每个构造方法中使用super关键字来显式调用父类的有参构造方法，并提供必要的参数。 例如：

public class ParentClass {
    private int value;
    // 父类的有参构造方法
    public ParentClass(int value) {
        this.value = value;
    }
    // 父类的属性
    public int getValue() {
        return value;
    }
}
public class ChildClass extends ParentClass {
    // 子类的构造方法，显式调用父类的有参构造方法
    public ChildClass(int value) {
        super(value); // 调用父类的有参构造方法
    }
}

调用父类的属性：

子类可以直接访问父类的非私有属性（public和protected）和方法，就像访问自己的属性和方法一样。如果父类的属性是私有的（private），则子类不能直接访问这些属性，但是可以通过父类提供的公共方法（getter和setter）来访问和修改这些属性。 例如：

public class ChildClass extends ParentClass {
    // 子类的构造方法
    public ChildClass(int value) {
        super(value);
    }
    // 访问父类的属性
    public void showParentValue() {
        // 直接访问父类的非私有属性
        System.out.println("Parent value: " + getValue());
    }
}

在这个例子中，ChildClass可以直接调用getValue()方法来访问父类ParentClass的value属性，因为getValue()是公共的（public）。如果value是私有的，则需要在ParentClass中提供一个公共的getter方法来允许子类访问它。

3.super与this的区别？

super关键字调用的是继承关系中的父类中的方法，（父类中的属性可以直接使用或者通过get或set方法进行修改或获取）

this关键字调用的本类中的方法或属性

以下是关于super和this关键字的区别的优化解释：

super关键字：

• super关键字用于引用父类（超类）的成员，如方法、构造函数或属性。

• 当子类覆盖了父类的方法时，super可用于调用父类中被覆盖的方法。

• 在构造函数中，super用于调用父类的构造函数。如果不显式调用，Java会自动调用父类的无参构造函数（如果存在）。

• super不能用于静态上下文（*静态上下文指与类的静态成员（静态字段和静态方法）相关联的代码区域）中，因为它指的是当前类的超类实例。 例如：

public class ParentClass {
    public void printMessage() {
        System.out.println("Message from ParentClass");
    }
}
public class ChildClass extends ParentClass {
    @Override
    public void printMessage() {
        super.printMessage(); // 调用父类的方法
        System.out.println("Message from ChildClass");
    }
}

this关键字：

• this关键字用于引用当前类的实例成员，如方法、构造函数或属性。

• this可以用来区分当前类的成员变量与局部变量（当它们名称相同时）。——this指当前类的成员变量

• 在构造函数中，this可以用来调用同一个类中的另一个构造函数（通过this的参数列表）。

• this也可以用于返回当前类的实例，通常在方法中使用。（不是很理解） 例如：

public class MyClass {
    private int value;
    public MyClass() {
        this(10); // 调用同一个类中的另一个构造函数
    }
    public MyClass(int value) {
        this.value = value; // 区分成员变量与局部变量
    }
    public MyClass setValue(int value) {
        this.value = value; // 设置成员变量的值
        return this; // 返回当前类的实例
    }
    public int getValue() {
        return this.value; // 获取成员变量的值
    }
}

总结区别：

• super用于访问父类的成员，而this用于访问当前类的成员。

• super主要用于继承的上下文中，而this用于当前类的实例的上下文中。

• super和this都不能在静态方法中使用，因为它们都需要指向类的实例。

4.继承的条件：

java中的继承限制只能进行单继承，但可以进行多重继承。

被final关键字修饰的类不可以有继承关系

在Java中，继承有以下条件和限制：

1. 单继承：Java语言只支持单一继承，即一个子类只能有一个直接父类。例如：

public class ChildClass extends ParentClass {
    // 子类代码
}

在这个例子中，ChildClass只能直接继承ParentClass。

1. 多重继承的模拟：虽然Java不支持类的多重继承，但可以通过实现多个接口来模拟多重继承的效果。例如：

public class MultipleInterfacesClass implements InterfaceA, InterfaceB {
    // 实现接口的方法
}

在这个例子中，MultipleInterfacesClass实现了InterfaceA和InterfaceB，从而获得了这两个接口的方法。

1. final类：如果一个类被声明为final，则它不能被其他类继承。例如：

public final class FinalClass {
    // 类的代码
}
​
// 编译错误，不能继承final类
// public class ExtendedFinalClass extends FinalClass {
// }

在这个例子中，FinalClass被声明为final，因此它不能被ExtendedFinalClass继承。

总结来说，Java的继承机制是单继承的，不允许多重继承，但可以通过实现多个接口来扩展类的功能。同时，final关键字可以用来防止类被继承。

5.1继承的作用

继承可以通过子类添加属性，方法从而达到扩充父类的功能的作用

继承的作用：

继承是面向对象编程中的一个核心概念，它在Java中具有以下作用：

1. 代码复用：继承允许子类重用父类的方法和属性，这意味着子类可以继承父类中已经实现的功能，无需重新编写。

2. 功能扩展：通过继承，子类可以添加新的属性和方法，以扩展或特殊化父类的功能。子类可以增加新的行为，而不会影响到父类的定义，这有助于实现多态。

3. 建立层次结构：继承有助于建立类之间的层次结构，使得代码更加模块化和组织化。在层次结构中，更通用的类位于上层，而更具体的类位于下层。 以下是优化后的解释： 继承在Java中的作用主要体现在以下几个方面：

• 属性和方法的重用：通过继承，子类自动拥有了父类的属性和方法。这使得代码更加简洁，避免了重复编写相同的代码。

• 功能扩充：子类可以根据需要添加新的属性和方法。这些新增的成员可以是对父类功能的补充，也可以是全新的功能。

• 行为修改：子类可以覆盖（override）父类的方法，以改变某些行为。这意味着子类可以提供与父类同名方法的不同实现。

• 类型层次：继承允许创建一个类型层次结构，其中子类是父类的一种特殊化。这种层次结构有助于组织和理解类之间的关系。 例如：

public class Vehicle {
    protected String type;
    public Vehicle(String type) {
        this.type = type;
    }
    public void displayType() {
        System.out.println("Type of vehicle: " + type);
    }
}
public class Car extends Vehicle {
    private String model;
    public Car(String type, String model) {
        super(type); // 调用父类的构造方法
        this.model = model;
    }
    // 新增方法
    public void displayModel() {
        System.out.println("Model of car: " + model);
    }
    // 覆盖父类的方法
    @Override
    public void displayType() {
        super.displayType(); // 调用父类的方法
        System.out.println("This is a car.");
    }
}

在这个例子中，Car类继承了Vehicle类，并添加了一个新的属性model和一个新的方法displayModel()。此外，Car类还覆盖了displayType()方法，以添加额外的行为。通过这种方式，Car类不仅继承了Vehicle类的功能，还扩展了它。

5.2 继承的特点：

继承是面向对象编程中的一个基本概念，以下是继承的一些主要特点：

1. 单继承性：Java中一个类只能有一个直接父类，这限制了类的直接继承关系。

2. 传递性：如果类B继承自类A，类C又继承自类B，那么类C也间接继承了类A的特性。

3. 层次性：通过继承，可以形成类的层次结构，高层类更通用，低层类更具体。

4. 可访问性：子类可以访问父类的非私有成员（public和protected），但不能直接访问父类的私有成员。

5. 方法覆盖：子类可以覆盖（override）父类的方法，提供不同的实现。

6. 构造器调用：在创建子类实例时，会隐式调用父类的构造器（如果没有显式调用特定的父类构造器）。

6. 方法重载多态与方法重写多态的区别：

• 方法重载（Overloading）：

  • 发生在同一个类中。

  • 方法名相同，但参数列表（参数的数量、类型或顺序）不同。

  • 编译时多态，即编译器根据方法签名（方法名和参数类型）决定调用哪个方法。

  • 重载方法可以有相同的返回类型，也可以不同。

• 方法重写（Overriding）：

  • 发生在子类和父类之间。

  • 子类中的方法与父类中的方法有相同的方法名和参数列表。

  • 运行时多态，即动态绑定，JVM在运行时根据对象的实际类型决定调用哪个方法。

  • 重写的方法必须具有相同的返回类型或子类返回类型（covariant return type）。

7. 方法重写多态的条件：

要实现方法重写并产生多态效果，必须满足以下条件：

1. 继承关系：子类必须继承自父类。

2. 方法签名相同：子类中的方法必须与父类中的方法具有相同的方法名和参数列表。

3. 访问权限：子类中方法的访问权限不能低于父类中方法的访问权限。例如，如果父类方法是public，子类方法也必须是public。

4. 返回类型：子类中方法的返回类型必须与父类中方法的返回类型相同，或者是父类返回类型的子类（协变返回类型）。

5. 异常：子类中方法抛出的异常类型必须与父类中方法抛出的异常类型相同或者是其子类。

6. 非静态：被重写的方法不能是静态的。

7. 非final：被重写的方法不能被声明为final，因为final方法不能被覆盖。 满足以上条件后，当通过父类引用调用方法时，实际执行的将是子类中重写的方法，从而实现多态。

8.父类引用指向子类对象的时候、只能访问到子类的什么方法？

Person peson = new Student(); peson.say();

当父类引用指向子类对象时，只能访问到子类中继承自父类的方法，以及子类中重写（override）了父类的方法。这意味着，通过父类引用只能调用那些在父类中声明的方法，即使是子类特有的方法，如果它们在父类中没有对应的声明，也无法通过父类引用调用。 以下是对您提供的代码片段的解释：

Person person = new Student();
person.say();

在这个例子中，假设Person是父类，Student是子类，并且子类Student重写了父类Person的say()方法。以下是可以发生的情况：

• 如果say()方法在Person类中声明，那么通过person引用调用say()方法时，将执行Student类中重写的say()方法。这是多态性的一个体现，即子类对象可以赋值给父类引用，并通过这个引用调用子类重写的方法。

• 如果say()方法是Student类独有的，而在Person类中没有声明，那么通过person引用是无法调用say()方法的。这是因为person引用只能调用Person类及其父类中声明的方法。

• 如果say()方法在Person类中声明为private，那么即使在Student类中重写了该方法，通过person引用也无法调用它，因为private方法不能被继承。 总结来说，通过父类引用指向子类对象时，只能访问到子类继承自父类的方法以及子类重写的方法，且这些方法在父类中必须是可访问的（非private）。子类特有的方法，除非它们在父类中有对应的声明，否则无法通过父类引用访问。

9、final关键字

(1).用在变量前面——该变量不可以修改，即指该变量为常量 ​ (2).用在方法的前面：——该方法在子类中不可以被重写，即该方法可以被继承，但不可以修改 ​ (3).用在类前面——该类不可以被继承

final关键字在Java编程语言中具有特定的意义，它可以用在变量、方法和类上，以下是final在不同位置的作用：

(1).用在变量前面：

• 基本数据类型：当final修饰基本数据类型变量时，该变量的值在初始化之后不能被改变。也就是说，它是一个常量。

• 引用数据类型：当final修饰一个对象引用时，该引用变量在初始化之后不能指向另一个对象，但是对象本身的内容可以改变。 例如：

final int MAX_VALUE = 100; // MAX_VALUE不能被重新赋值
final MyClass obj = new MyClass(); 
// obj不能指向新的对象，但是obj的内容可以改变，比如调用obj的方法改变它的状态

(2).用在方法的前面：

• 当final修饰一个方法时，这个方法不能被子类重写（override）。final方法可以被继承，但是不能修改。

例如：

public class Parent {
    public final void show() {
        System.out.println("This is a final method.");
    }
}
public class Child extends Parent {
    // 编译错误，不能重写final方法
    // public void show() {
    //     System.out.println("Attempting to override.");
    // }
}

(3).用在类前面：

• 当final修饰一个类时，这个类不能被继承。即它是一个终结类，不允许有子类。 例如：

public final class FinalClass {
    // 类的内容
}
// 编译错误，不能继承final类
// public class ExtendedFinalClass extends FinalClass {
// }

使用final关键字的好处包括：

• 安全性：它可以确保重要的数据不被更改，以及重要的方法不被覆盖。

• 效率：对于基本类型变量，编译器可以优化对final变量的引用，因为知道其值不会改变。

• 明确性：它向其他程序员传达了代码的意图，表明某些值或方法或类不应该被改变。

10、接口的特性：

接口（Interface）在Java中是一种引用类型，类似于类，用于存放抽象方法和静态常量。以下是接口的特性：

1. 抽象方法：接口中可以声明抽象方法，没有具体实现。

2. 默认方法：Java 8+允许接口中声明默认方法，带有默认实现，可以被继承或重写。

3. 静态方法：接口中可以声明静态方法，可以有具体实现。

4. 常量：接口中声明的变量默认是public static final的，即它们是常量。

5. 多实现：一个类可以实现多个接口。

6. 继承：接口可以继承其他接口，并添加新的抽象方法或默认方法。

7. 解耦：接口提供了一种解耦合的方式，使得实现类可以在不改变接口的前提下改变实现。

11、接口与抽象类的区别：

以下是接口与抽象类的主要区别：

• 定义：接口主要用于定义公共的方法规范，抽象类则是类层次结构的抽象层。

• 方法：接口只能声明抽象方法和默认方法（Java 8+），抽象类可以声明抽象方法和非抽象方法。

• 变量：接口中的变量只能是public static final的常量，抽象类可以有实例变量和类变量。

• 实现：一个类可以实现多个接口，但只能继承一个抽象类。

• 构造器：接口不能有构造器，抽象类可以有构造器。

12、throw与throws的区别：

• throw：throw关键字用于在代码块中显式抛出一个异常对象。

• throws：throws关键字用于方法签名中，声明该方法可能会抛出的异常类型。

13、finally的作用：

finally块用于执行那些无论是否发生异常都需要执行的代码。它通常与try和catch块一起使用。以下是finally的作用：

• 资源释放：确保在代码执行完毕后，资源如文件流、网络连接等被正确关闭。

• 异常处理：即使在try或catch块中执行了return、continue或break语句，finally块中的代码仍然会被执行。

14、多catch结构要注意的地方：

在使用多个catch块时，应注意以下几点：

• 异常类型顺序：从最具体的异常类型到最不具体的异常类型排列catch块。

• 避免重叠：确保catch块捕获的异常类型互不重叠，否则可能导致某些catch块永远不会被执行。

• 包含关系：如果一个异常类型是另一个的父类，那么父类异常的catch块应该放在子类异常的catch块之后。

15、异常的体系结构：

Java中的异常体系结构如下：

• Throwable：是所有异常和错误的超类。

  • Error：表示严重的问题，通常是程序无法处理的，如OutOfMemoryError。

  • Exception：表示程序可以处理的异常。

    • RuntimeException：运行时异常，通常是程序逻辑错误导致的，如NullPointerException。

    • Checked Exception：检查异常，必须被显式处理，如IOException。

16、B/S结构，C/S结构的优劣势：

• B/S结构（Browser/Server）：

  • 优势：

    • 易于维护和升级：只需更新服务器上的应用程序。

    • 无需安装客户端软件：用户通过浏览器访问，减少客户端维护。

    • 跨平台：用户可以在不同的操作系统上访问。

  • 劣势：

    • 性能：可能不如C/S结构响应速度快。

    • 安全性：客户端的数据处理可能会暴露安全风险。

• C/S结构（Client/Server）：

  • 优势：

    • 性能：客户端可以分担处理任务，通常响应更快。

    • 安全性：客户端可以处理敏感数据，减少数据传输。

    • 稳定性：客户端可以在断网情况下继续工作。

  • 劣势：

    • 维护：需要维护客户端和服务器两端。

    • 安装：需要安装客户端软件，可能存在兼容性问题。