java总结-理论知识点记录

最新推荐文章于 2024-08-23 15:54:50 发布

哈哈哈333555

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量393

点赞数 5

文章标签： java 开发语言

本文链接：https://blog.csdn.net/sansheng333/article/details/141109357

版权

1.构造方法是在什么时候被调用？能不能手动调用？

构造方法在类加载时自动运行无参构造方法，可以手动改为有参的构造方法手动调用（错误描述：不可以手动调用）。

1.1构造方法的作用？构造函数有没有返回值?

AI：在Java中，构造方法（Constructor）是在创建类的新对象时被调用的。构造方法的主要作用是初始化新创建的对象的状态。

关于构造函数被调用的关键点：

创建对象时：当使用new关键字创建一个对象时，Java虚拟机会为新对象分配内存，并调用相应的构造方法来初始化对象。
继承：当子类对象被创建时，会首先调用父类的构造方法（如果没有显式调用特定的构造方法，则默认调用父类的无参构造方法），然后调用子类的构造方法。

构造方法不能被手动直接调用,因为构造方法没有返回类型，甚至没有void，并且方法名必须与类名相同。但是，可以在构造方法内部通过this()或者super()来调用同一个类中的其他构造方法或者父类的构造方法。

2.为什么需要要封装？

封装：保护数据安全，限制访问权限

AI：Java语言中的封装（Encapsulation）是面向对象编程（OOP）的四大基本原则之一，它具有以下几个重要的理论和实践原因：

隐藏内部状态：封装允许将对象的内部状态（成员变量）隐藏起来，只通过有限的接口（方法）暴露给外部。这样做可以防止外部直接访问对象的内部状态，保证了对象的状态不会被意外修改。
控制访问权限：通过封装，可以控制对外部接口的访问权限，例如使用private关键字可以防止外部直接访问类的内部成员。这样可以确保对象的数据只能被授权的代码访问和修改，提高了数据的安全性。
提高可维护性：封装使代码更易于维护。由于外部只能通过定义良好的接口与对象交互，因此当对象的内部实现发生变化时，对其他部分的影响最小化。这使得修改和扩展代码更加容易，同时也减少了潜在的bug。
实现抽象：封装允许实现细节的抽象，这意味着对象对外只展示了一部分信息，隐藏了复杂的实现过程。这样可以让对象的使用者不必关心对象的内部如何工作，只需要知道如何使用对象提供的功能。
代码重用性：封装促进了代码的重用。当对象提供了合适的接口时，其他开发者可以不需要了解具体实现细节就能使用这些对象，这样就减少了对具体实现知识的依赖，提高了代码的可重用性。
符合封装原则：封装是面向对象设计的一个基本原则，它促进了对象的高内聚和低耦合。高内聚意味着对象的内部元素彼此紧密相关，而低耦合则意味着对象之间的依赖关系最少。这样的设计更加灵活，能够更好地适应需求的变化。

综上所述，封装是Java语言中面向对象编程的一个重要概念，它在确保数据安全、提高代码可维护性和可重用性、促进良好设计等方面发挥着重要作用。

3.属性怎么样封装

使用private修饰

AI：在Java语言中，属性的封装通常通过访问修饰符和私有化成员变量来实现。以下是如何封装属性的步骤和最佳实践：

使用访问修饰符：
- private：最常用的修饰符，它确保类的内部状态对外部不可见。这意味着属性只能被类的内部方法访问和修改。
- protected：允许类内部的访问以及继承该类的子类的访问，但不允许外部类直接访问。
- public：没有任何访问限制，任何类都可以直接访问和修改这个属性。通常不推荐在属性上使用public修饰符，因为它违反了封装的原则。
- default（没有关键字）：只在同一个包内的类可以访问，不推荐用于属性修饰，因为它的封装性不强。
定义私有成员变量：
- 将属性声明为私有（private），这样它们就不能被类的外部直接访问。
```
private int age;
private String name;
```

提供公共getter和setter方法：

为了允许外部访问私有属性，可以创建公共（public）的getter和setter方法。这些方法提供了一种受控的方式来读取和修改属性。

public int getAge() {
    return age;
}
public void setAge(int age) {
    if (age >= 0) {  // 添加有效性检查
        this.age = age;
    }
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}

使用构造函数：
- 通过构造函数来初始化属性值，可以在对象创建时就设置好属性值，同时也可以在这个时候执行任何必要的验证。
```
public Person(String name, int age) {
    this.name = name;
    this.age = age;
}
```
限制访问：
- 在setter方法中添加逻辑来限制对属性的不当访问，例如检查值的范围、是否为null等。
封装内部逻辑：
- 将属性和相关的逻辑封装在一个类中，避免将属性和逻辑暴露给外部。这意味着属性不应该直接暴露复杂的数据结构或者内部状态。
接口与抽象：
- 如果属性对于子类来说是不变的，可以通过抽象（如接口）来进一步封装，使得子类只能通过特定的方式访问这些属性。通过这些步骤，可以确保属性的封装性，使得对象的内部状态得到保护，同时提供了一种受控的方式来访问和修改这些状态。这样的设计提高了代码的可维护性、可测试性和安全性。
总结：并不是只有private修饰才是封装，只是private修饰的属性访问限制最大

4.静态属性和非静态属性的区别：static

静态属性是类的属性，对应该类的对象共享这一个属性，非静态是对应对象，一个对象有对应自己的非静态属性

AI：在Java中，静态属性（static fields）和非静态属性（non-static fields）的主要区别在于它们如何与类的实例关联以及它们如何在内存中存储。

静态属性：
- 归属：静态属性属于类本身，而不是类的任何特定实例。
- 内存存储：对于类的每个实例，静态属性只存储一份拷贝，这意味着无论创建多少个对象实例，静态属性的值都是相同的。
- 访问方式：可以直接通过类名访问静态属性，而不需要创建类的实例。
- 初始化：静态属性可以在类定义时初始化，也可以在静态代码块中初始化，或者在使用之前单独初始化。
- 依赖性：静态属性不依赖于类的实例，它们的存在与类的实例无关。
```
public class MyClass {
    public static int staticField = 10;
}
```
非静态属性：
- 归属：非静态属性属于类的实例，每个对象实例都有自己的属性值。
- 内存存储：每个对象实例都会有自己独立的属性值拷贝，除非在构造函数中明确地进行值的初始化。
- 访问方式：必须通过类的实例来访问非静态属性。
- 初始化：非静态属性通常在构造函数中初始化，也可以在实例化对象之后单独初始化。
- 依赖性：非静态属性依赖于类的实例，每个实例可以有不同属性的值。
```
public class MyClass {
    public int nonStaticField;
}
```
在使用静态属性时，由于它们不依赖于类的实例，因此它们非常适合存储那些与类本身相关的共享状态。例如，一个类用来跟踪全局计数器或者配置信息时，可以使用静态属性。非静态属性则用于存储每个对象实例独有的状态。这些属性对于对象的行为和状态至关重要，并且每个对象可以有独立的值。在编写类时，正确地使用静态和非静态属性是面向对象设计的重要部分，它有助于保持代码的清晰结构和正确的封装原则。

6.静态的方法能不能直接调用非静态的方法，

不能，因为静态方法属于类，非静态方法属于对象，静态方法的创建可能就在对象之前，这是对象对应的非静态方法没有加载，对应就不可以使用静态方法调用非静态方法（生命周期不同）

在Java中，静态方法不能直接调用非静态方法。原因如下：
1. 作用域不同：静态方法属于类本身，而非静态方法属于类的实例。静态方法在类加载时就已经存在，而非静态方法需要在创建类的实例后才能调用。
2. 生命周期不同：静态方法在类加载时就存在，而非静态方法依赖于对象的创建。因此，静态方法无法访问那些需要对象实例才能访问的资源。
3. 访问限制：静态方法只能访问类的静态成员（包括静态变量和静态方法），而不能访问非静态成员，因为非静态成员需要通过对象实例来访问。
4. 设计原则：Java的设计哲学鼓励使用静态方法来执行与特定对象实例无关的操作。如果静态方法需要执行与对象实例相关的操作，这通常意味着设计上可能存在问题。
5. 错误处理：如果允许静态方法直接调用非静态方法，将导致在静态方法中尝试访问尚未创建的对象实例，这将引发空指针异常（NullPointerException）。
总结来说，由于静态方法和非静态方法的作用域、生命周期和访问权限的差异，Java不允许静态方法直接调用非静态方法。如果需要在静态方法中执行与对象实例相关的操作，可以通过传递对象实例作为参数来实现。

7.静态方法有什么特点?

与static修饰的静态属性相同，属于类

静态方法在Java中具有以下特点：

属于类而非实例：静态方法属于类本身，而不是类的任何特定实例。这意味着即使没有创建类的实例，静态方法也可以被调用。
使用类名调用：由于静态方法属于类，它们可以通过类名直接调用，而不需要创建类的实例。
可以访问静态变量和方法：静态方法可以访问类的静态变量和其他静态方法，但不能直接访问非静态成员，除非通过类的实例。
不能直接访问非静态成员：静态方法不能直接访问类的非静态成员变量和非静态方法，因为这些成员需要通过对象实例来访问。
常用于工具类：静态方法常用于工具类或实用程序类中，提供一些与特定对象实例无关的功能。
可以被声明为final：静态方法可以被声明为final，这意味着它们不能被子类覆盖。
不能被声明为abstract：静态方法不能被声明为抽象的，因为它们在类中具有具体实现。
可以是private：静态方法可以声明为private，这意味着它们只能在定义它们的类内部被访问。
线程安全：如果静态方法不修改任何可变的状态，它们通常是线程安全的。但如果它们修改共享的可变状态，则可能需要同步。
与构造函数无关：静态方法不需要通过构造函数来初始化，因为它们在类加载时就已经存在。
可以声明为static：这是静态方法的一个明显特征，表明它们可以在不创建类实例的情况下被调用。
与类的生命周期相关：静态方法的生命周期与类的加载和卸载周期相关，而不是与任何特定对象的生命周期相关。

静态方法的使用可以提高代码的模块化和可重用性，但过度使用或不当使用静态方法可能会导致设计上的问题，如难以测试和违反面向对象的设计原则。

8.怎么样进行方法重载？

重载：类名相同，参数类型、参数数量、返回类型不同用于区分不同的方法

方法重载（Method Overloading）是面向对象编程中的一种特性，它允许在一个类中定义多个同名方法，只要这些方法的参数列表不同。参数列表的不同可以是参数的数量、类型或顺序不同。方法重载的主要特点包括：

方法名相同：被重载的方法必须具有相同的方法名。
参数列表不同：这是区分重载方法的关键。参数列表可以有不同的参数数量、不同的参数类型，或者参数类型的不同顺序。
返回类型可以相同或不同：方法的返回类型可以与重载的方法相同，也可以不同。但是，仅通过不同的返回类型来区分方法是不构成重载的，因为编译器是根据参数列表来选择调用哪个方法的。
访问修饰符可以相同或不同：方法的访问级别（如public, protected, private等）可以相同也可以不同，但这不影响方法重载的定义。
抛出的异常可以相同或不同：方法声明时抛出的异常列表可以与重载的方法相同或不同。
发生在同一个类中：方法重载发生在同一个类中，或者在父类和子类中，但子类重载的方法必须保持一致的访问级别或更宽松的访问级别。
构造函数可以被重载：构造函数也可以被重载，其规则与普通方法的重载规则相同。
重载解析（Overload Resolution）：当调用一个重载的方法时，编译器会根据提供的参数类型、数量和顺序来决定调用哪个具体的方法。
方法重载与方法覆盖（Override）不同：方法覆盖发生在继承体系中，子类提供了与父类具有相同方法名、返回类型和参数列表的方法，用于扩展或修改父类的行为。
方法重载增强了代码的可读性和灵活性：通过方法重载，可以为不同的参数提供相同的操作，使得代码更加直观和易于理解。

方法重载是多态性的一种表现，它允许以统一的方式处理不同的数据类型，从而提高了代码的复用性和灵活性。

9.方法重写（Method Overriding）和方法重载（Method Overloading）

都是面向对象编程中多态性的表现，但它们之间存在一些关键的区别：

方法重写（Method Overriding）

定义：发生在继承体系中，子类提供了与父类具有相同方法名、相同参数列表、相同返回类型的方法，用于修改或扩展父类的行为。
目的：允许子类根据需要改变继承自父类的行为。
访问级别：子类重写的方法不能缩小父类方法的访问级别。
返回类型：子类重写的方法必须返回与父类方法相同的类型，或者是其子类型。
参数列表：子类重写的方法必须具有与父类方法相同的参数列表。
可变特征：子类可以添加新的异常声明，但不得缩小父类方法声明的异常。
使用场景：通常用于实现多态性，允许通过父类的引用调用子类的方法。
例子：如果有一个父类Animal和一个子类Dog，Dog可以重写Animal中的makeSound方法。

方法重载（Method Overloading）

定义：在同一个类中定义多个具有相同方法名但参数列表不同的方法。
目的：允许调用者根据传递的参数数量或类型选择不同的方法版本。
访问级别：重载的方法可以有不同的访问级别。
返回类型：重载的方法可以有不同的返回类型。
参数列表：重载的方法必须具有不同的参数列表，这可以是参数的数量、类型或顺序。
可变特征：重载的方法可以抛出不同的异常。
使用场景：通常用于提供相同功能但接受不同参数的方法。
例子：一个类可以有多个print方法，分别接受int、double和String类型的参数。

对比

继承关系：方法重写需要继承关系，而方法重载不需要。
方法签名：方法重写要求方法签名（方法名、参数列表、返回类型）与父类完全一致，而方法重载只要求方法名相同，参数列表不同。
多态性表现：方法重写是运行时多态性的表现，编译器在运行时确定调用哪个方法；方法重载是编译时多态性的表现，编译器根据参数列表确定调用哪个方法。
目的和使用：方法重写用于改变继承自父类的行为，而方法重载用于提供相同功能但接受不同参数的方法。

理解这两种概念对于正确实现面向对象编程中的多态性至关重要。

10.怎么样判断父类引用的真实对象？——————多态

在Java中，可以使用多态性来确定一个父类引用实际上指向的是哪个子类的对象。以下是一些判断父类引用真实对象类型的方法：

使用instanceof操作符： instanceof操作符可以用来检查一个对象是否是特定类的实例。例如，如果有一个父类Animal和子类Dog、Cat，可以通过以下方式检查：
```
Animal animal = new Dog();
if (animal instanceof Dog) {
    System.out.println("The animal is a dog.");
}
```
通过反射（Reflection）： Java的反射API允许程序在运行时查询和使用类的信息。可以使用getClass()方法获取对象的Class对象，然后使用getName()方法获取类的全名，或者使用getSimpleName()获取类的简单名称。例如：
```
Animal animal = new Dog();
Class<?> clazz = animal.getClass();
System.out.println(clazz.getName()); // 输出 Dog 的完整类名
System.out.println(clazz.getSimpleName()); // 输出 Dog
```
使用getClass()方法：直接调用对象的getClass()方法，然后比较返回的Class对象。这通常与==操作符一起使用，因为getClass()方法返回的是同一个类的同一个Class实例：
```
Animal animal = new Dog();
if (animal.getClass() == Dog.class) {
    System.out.println("The animal is a dog.");
}
```
使用类型转换：如果知道对象的确切类型，可以直接尝试将父类引用转换为子类类型。如果转换成功，说明引用实际上是子类的对象。例如：
```
Animal animal = new Dog();
Dog dog = (Dog) animal; // 假设编译器允许这种转换
// 现在可以使用 dog 调用 Dog 类的特定方法或访问字段
```
使用toString()方法：如果子类重写了Object类的toString()方法，可以通过调用toString()方法来获取对象的字符串表示，这通常包含了类名信息：
```
Animal animal = new Dog();
System.out.println(animal.toString()); // 可能会输出 Dog@... 的形式
```
使用Object类的getClass()方法：由于getClass()方法是Object类的一部分，所有Java对象都可以调用它来获取自己的类信息。