探索 Java 开发人员职位面试中的问题和答案。第三部分

你好！正如没有特殊训练就不可能学会如何驾驶飞机一样，如果不花大量时间学习必要的理论基础，就无法成为 Java 开发人员。这正是我们今天要解决的问题：我们将继续探讨 Java 开发人员在面试过程中遇到的问题，当然，我们也会查看答案。以下是本概述的第一 部分和第二 部分。毫无疑问，如果没有这些问题，您就可以成为一名优秀的 Java 开发人员。也就是说，如果您对 Java 的所有复杂性有很好的理解，那么您肯定会具有优势，并且在未来雇主的眼中看起来更有吸引力。

20. 语言的哪些元素支持封装？

让我们回想一下，封装是隐藏类的实现细节。也就是说，我们的类在使用的时候，它的内脏和内部逻辑对于外人来说是不明显的。语言的哪些元素造成了这种情况？当然是访问修饰符！任何我们需要隐藏的内容，我们都用private修饰符进行标记。例如，类的私有字段或一些有助于实现某些内部功能的内部方法。对于我们想要提供外部访问的任何内容，我们添加public访问修饰符。例如，实现某些功能的方法（可能在内部使用许多私有方法），或者当然还有用于访问类的私有字段的 getter 和 setter。我们还没有提到default和protected修饰符，它们可以更灵活地使用并专门定制对某些类部分的访问。

21. 语言的哪些元素支持继承？

继承是一种允许您基于另一个类创建类的机制。Java为此提供了extends关键字。例如，假设我们有一个Cat类，并且我们想要创建一个Lion子类。在代码中，它看起来像这样：

public class Lion extends Cat

而这意味着Lion类继承了Cat类的所有方法和变量，除了静态变量。该语言中负责继承的另一个元素是super。这是一个与此类似的参考。this关键字引用它所引用的对象。super关键字指的是当前对象的父对象。通常使用super ：

1. 调用超类的构造函数。例如，Cat类有一个必须在构造函数中初始化的内部名称变量。在Lion类构造函数中，它将如下所示：

   public Lion(final String name) {
      super(name);
   }

2. 引用父级的字段和方法。例如，在Cat类中，我们有一个初始化的年龄字段：

   public class Cat {
      int age = 10;

但我们在Lion中有相同的初始化字段：

public class Lion extends Cat {
   int age = 15;

如果在Lion对象中我们想要引用父对象的Age变量，那么我们必须通过super来完成：

super.name

22. 语言的哪些元素导致多态性？

多态性是具有一个签名的对象具有多种形式（多种实现）的能力。 我们可以自信地说，Java 的implements和extends关键字负责多态性。当我们有一个接口时，实现允许我们提供一种可能的实现，但这不一定是唯一的实现，不是吗？让我们回顾一下使用Implements的样子：

public class Cat implements Animal

然后在Cat类中，我们必须实现Animal接口中的所有抽象方法。继承也是如此：在子类中，我们可以重写方法的现有实现。这意味着对于多个子类，我们可以对同一方法进行多种不同的重写。或者，超类可以是抽象的，并且具有必须在其每个子类中以特殊方式实现的特定方法。换句话说，这个方法会有很多不同的实现。@Override注解也可以帮助我们解决这个问题。它位于已实现的方法之上，表示我们想要实现或覆盖（如果超类中已存在实现）超类或接口的特定方法。它是可选的，有助于更轻松地检测错误。您使用此注释告诉编译器您想要重写/实现超类/接口方法。然后编译器将确保您不会在方法签名中犯错误。

23.什么是实体？提供例子

SOLID是 Robert Martin 的五个基本 OOP 设计原则的缩写。 S（单一责任原则）：规定一个类应该只有一个目的/责任。换句话说，您不应该创建做所有事情的类。如果你这样做，你可能会重现“God Object”反模式。如果您有一个Cat对象，它应该具有仅与其内部功能交互的方法，但它不应该包含与该实例无关的任何业务逻辑。例如，用于存储这种类型的对象的某种机制。此功能（位于Cat实体外部）应移至其他类或服务，其任务是为相应对象提供业务逻辑。 O（开放-封闭原则）：该原则描述如下：软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。例如，假设我们需要与现有Cat类的功能相似但略有不同的功能。我们可以使用继承或组合，而不是更改 Cat类的功能，从而破坏已使用的所有代码。因此，我们实现了修改Cat类的功能的目标，并且无需更改类本身，也不会破坏任何内容。 L（Liskov替换原则）：这是Barbara Liskov的替换原则。该原则表示，采用基类型的函数应该能够使用该基类型的子类型，而无需知道发生了什么。例如，我们的Cat类应该可以被它的任何后代（例如Lion ）替换，而不会从根本上改变它的行为。一般逻辑（行为）保持不变，但特定功能的实现细节发生了变化。 I（接口隔离原则）：该原则指出，拥有许多专用（狭隘的）接口比拥有一个通用接口更好。例如，假设开发人员实现了某个接口。他们只需要其中一个方法，但该接口还有九个与所需方法的逻辑无关的方法。在这种情况下，开发人员将需要实现十个接口方法，其中九个对他们来说是多余的！相反，最好制作十个可以根据需要实现的不同接口。好吧，如果不是十个，那就是几个，每个方法都与接口的单一用途密切相关。 D（依赖倒置原则） ：原则上说高层模块不应该依赖于低层模块。该原则还指出，“抽象不应该依赖于细节。细节应该依赖于抽象。” 我们必须通过引用接口来构建逻辑，并传递实现所需接口的类的具体对象。例如，假设我们有一个Cat接口和一些实现，例如Lion和HouseCat。我们专门构建了与Cat界面交互的逻辑。然后我们才用特定的实现（ Lion或HouseCat ）替换接口，而不是相反。

24.什么是类、对象和接口？

我们还记得 Java 是一种 OOP 语言。也就是说，Java 程序是基于对象之间的交互而构建的。程序就像一个蚁丘，其中每只蚂蚁都是一个对象。 对象是数据的集合，其中包括用于与内部数据交互的各种方法（函数）。 类是用于创建对象的指令或模板。这意味着我们可以根据相同的指令构建许多对象，但填充不同（或相同）的数据。举个现实生活中的例子，我们可以说类是一座建筑的蓝图，而对象则是根据蓝图专门建造的一座建筑。 接口与类类似，但我们不能使用它们来创建对象。它们的目的是为 Java 添加抽象。更准确地说，它们为类和对象之间的关系增加了灵活性。我们所说的灵活性是指前面描述的多态性和抽象性，这为构建应用程序的内部架构创造了许多机会。

25. 什么是POJO类？举一个这样的类的例子

POJO （普通旧 Java 对象）是一个简单的类对象，它不继承任何特定的类，并且不实现超出业务模型所需的任何服务接口。换句话说，POJO类只是一个没有特殊要求的类。唯一的要求是没有与特定框架相关的各种花里胡哨的东西。通常，这些类不会继承其他类（同一包中的POJO类除外），不会实现接口（有时标准库中的标记接口（例如Serialized或Cloneable）会例外），不会使用注释，并且不依赖第三方库。请注意，POJO可以具有包含业务逻辑和任何类型的构造函数的方法。如果我们允许不改变类语义的注释（即，注释的缺失不会改变对象的目的或逻辑），那么POJO还可以包含从XML或JSON反序列化的JPA实体和DTO对象，其规则是注释中指定。关于POJO类要记住的另一件事是，最好重写它们的equals和hashCode方法，因为这可以帮助它们更好地履行其职责。POJO类的示例：

public class User {
   private Long id;
   private String firstName;
   private String lastName;
   private Long age;

   public User(final Long id, final String firstName, final String lastName, final long age) {
       this.id = id;
       this.firstName = firstName;
       this.lastName = lastName;
       this.age = age;
   }

   public Long getId() {
       return this.id;
   }

   public String getFirstName() {
       return this.firstName;
   }

   public String getLastName() {
       return this.lastName;
   }

   public Long getAge() {
       return this.age;
   }

   @Override
   public boolean equals(final Object o) {
       if (this == o) return true;
       if (o == null || this.getClass() != o.getClass()) return false;
       final User user = (User) o;
       return Objects.equals(this.id, user.id) &&
               Objects.equals(this.firstName, user.firstName) &&
               Objects.equals(this.lastName, user.lastName) &&
               Objects.equals(this.age, user.age);
   }

   @Override
   public int hashCode() {
       return Objects.hash(this.id, this.firstName, this.lastName, this.age);
   }
}

26. 类可以包含哪些元素？

一个类可以包含以下元素：

• 实例字段；
• 静态字段；
• 初始化块；
• 静态初始化块；
• 构造函数（默认情况下始终声明空构造函数）；
• 方法;
• 静态方法；
• 各种注释（可以应用于类本身或其组成部分）；
• 仿制药 ；
• 其他类的继承 ( extends ) 或接口的实现 ( implements )。

27. 告诉我们 Java 中的继承。super 关键字的具体特点是什么？

上面我之前讲过继承和Java中的super关键字。我再提几个更重要的点：

1. 我们只能继承一个类：Java 中没有多重继承。随着Java 8中默认方法的出现，这个说法将变得非常有争议。
2. 私有方法和字段也被继承。它们根本无法从子类访问（但是，例如，如果我们有一个私有字段并且有公共或受保护的getter 和 setter，那么我们可以使用它们来访问该字段）。
3. Final类不能被继承。
4. Final方法不能被覆盖（但它们可以被继承和重载）。
5. 静态方法和变量不是继承的（因为它们附加到类，而不是对象）。
6. 继承抽象类时，必须实现其抽象方法，或者子类也必须声明为抽象。
7. 如果父类中有非默认构造函数，则必须在子类中重写它们（但@Override不写在它们上面）。
8. 您可以将访问修饰符扩展到子类中重写的方法：private -> default -> protected -> public。
在子类中重写的方法可以抛出更窄的异常，例如：Exception -> IOException -> FileNotFoundException。

28.什么是方法签名？提供正确和错误签名的示例

方法签名 是方法的名称加上输入参数的类型（参数的顺序很重要）。方法签名不包括返回值或方法抛出的异常。正确签名示例：

doSomething(int, double, double)

错误签名示例：

void doSomething(int firstArg, int secondArg) throws Exception

方法签名与返回类型和抛出的异常列表相结合，称为方法契约。这就是今天的全部内容！回头见！