Java 开发人员访谈问答分析。第三部分

你好！正如没有特殊训练就不可能学会驾驶飞机一样，如果不花大量时间学习必要的理论基础，也不可能成为 Java 开发人员。今天我们将致力于此：我们将继续分析Java 开发人员的250 多个面试问题，并给出相应的答案。以下是第一部分和第二部分的分析。是的，当然，如果没有这些问题，您就可以成为一名优秀的 Java 开发人员。但是，如果您对 Java 语言的来龙去脉有很好的了解，它将给您带来优势，使您成为未来雇主眼中更理想的候选人。

20. 哪些语言元素负责封装？

我们记得，封装是隐藏类的实现细节。也就是我们的类在外部使用的时候，内部的内容和逻辑并不明显。哪些语言元素造成了这种情况？当然，还有访问修饰符！我们用private修饰符标记需要隐藏的内容。例如，类的私有字段或一些有助于实现某些内部功能的内部方法。对于我们想要提供外部访问的内容，我们添加public访问修饰符。例如，负责提供某些功能的方法（其中可以使用许多私有方法）或用于访问类的私有字段的相同 getter 和 setter。哦，我们还有default和protected修饰符，它们可用于更灵活和更具体地配置对类的选定部分的访问。

21. 哪些语言元素负责继承？

继承是一种允许您基于另一个类创建类的机制。在 Java 中， extends关键字就是用于此目的。例如，我们有一个特定的类Cat，我们想创建它的后继者 - Lion。在代码中它看起来像这样：

public class Lion extends Cat

这意味着Lion类继承了Cat类的所有方法和变量，除了静态的。此外，负责继承的语言元素包括super。这是与this类似的引用，但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关键字负责多态性。 实现- 当我们创建接口时，我们在某个类中实现其可能的形式之一，但这不是唯一的形式，不是吗？让我们记住实现工具是什么样的：

public class Cat implements Animal

在Cat类中，我们必须实现Animal接口中提供的所有抽象方法。继承也是如此：在后代类中，我们可以重写方法的现有实现。例如：多个后代 -> 同一方法的多个不同重写。好吧，要么超类是抽象的，并且它有某种需要为其每个后代以特殊方式实现的方法。也就是说，我们可以说该方法将采取多种形式。另外， @Override注解可以帮助我们实现 this ，它被放置在实现的方法之上，表明我们想要实现或重写（如果超类中已经存在该实现）超类或接口的一个或另一个方法。它是可选的，用于更容易地检测错误。使用此注释，您向编译器表明您想要重写/实现超类/接口方法，它将确保您不会在方法签名中犯错误。

23.什么是实体？举例说明

SOLID是面向对象编程的五项基本设计原则的缩写，由 Robert Martin 创造。 S - Single-responsibilityprinciple——单一责任原则，它规定一个类应该只有一个目标和单一目的。也就是说，您不应该创建做所有事情的类。在这种情况下，您可以重现“神圣对象”反模式。如果您有一个Cat对象，它应该包含仅与其内部功能交互的方法，而不包含与此实例无关的业务逻辑。例如，在某处以某种方式保存这种类型的对象。这种外部功能（相对于Cat）需要转移到其他类，一些服务的任务是为这种类型的对象提供业务逻辑。 O - 开闭原则——开放/封闭原则。这意味着软件实体（类、接口）应该对扩展开放，但对修改关闭。例如，我们需要与现有Cat类的功能类似的功能，但略有不同。我们不改变Cat类的功能，破坏已经使用它的地方，而是使用继承或组合。结果，我们通过修改Cat类的功能实现了我们的目标，但同时我们没有改变它或破坏任何东西。 L - Liskov 替换原理- Barbara Liskov 的替换原理。该原则指出，使用基类型的函数应该能够在不知情的情况下使用基类型的子类型。例如，我们的Cat类应该与其任何后代（例如Lion ）互换，而不会从根本上改变行为。一般逻辑（行为）保持不变，但这个或那个功能的实现细节发生了变化。 I - Interface Segregation Principle——接口分离的原则。这一原则指出，拥有许多专用（狭隘的）接口比拥有一个通用接口更好。例如，用户实现了某个接口，他只需要这个方法，但是这个接口还有九个方法，这些方法与所需方法的逻辑无关。在这种情况下，用户将需要实现十个接口方法，其中九个对他来说是不必要的！相反，最好制作十个不同的接口，以便在必要时可以实现。好吧，或者不是十个，而是几个，其中将具有与接口的共同目的密切相关的方法。 D - 依赖倒置原则——依赖倒置原则。该原则规定较高级别的模块不应依赖于较低级别的模块。这一原则也被描述为“抽象不应该依赖于细节，细节应该依赖于抽象”。也就是说，我们必须通过引用接口来构建逻辑，然后才将特定对象传递给该功能，该功能的类实现所需的接口。例如，如果我们有一个Cat接口及其一些实现，例如Lion和HomeCat，我们将专门使用Cat接口类型构建交互逻辑，然后才替换Lion或HomeCat的特定实现，但反之则不然。

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

我们记得，Java 是一种 OOP 语言。也就是说，Java 程序是建立在对象之间的交互之上的。事实证明，该程序就像一个蚁丘，其中每只蚂蚁都是一个对象。对象是一些分组数据，其中包含与这些内部数据交互的各种方法（函数）。类是指令，是创建对象的模板。也就是说，可以有许多根据相同指令构造的对象，填充有不同或相同的数据值。举个生活中的例子，我们可以说类是一幅建筑物的图，而对象是根据这张图专门创建的建筑物。 接口与类类似，不同之处在于不能使用它们创建对象。他们的目标是向 Java 添加抽象元素。更准确地说，是为了增加类和对象之间关系的灵活性。我们所说的灵活性是指前面描述的多态性和抽象性，这反过来又为构建应用程序的内部架构提供了许多机会。

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

POJO - 普通旧 Java 对象- 一个很好的旧 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. 最终类不会被继承。
4. 最终方法不会被重写（但它们可以被继承和重载）。
5. 静态方法和变量不是继承的（因为它们不与对象绑定，而是与类绑定）。
6. 当继承抽象类时，需要实现其抽象方法，或者当前类也必须声明为抽象。
7. 如果父类中有非默认构造函数，则必须在子类中重写它们（但@Override不会覆盖它们）。
8. 后代中的重写方法可以使用访问修饰符进行扩展：private -> default -> protected -> public。
9. 后代中的重写方法可以缩小写入的异常范围，例如：Exception -> IOException -> FileNotFoundException。

28.什么是方法签名？举例说明正确和错误的签名

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

doSomething(int, double, double)

错误签名的示例：

void doSomething(int firstArg, int secondArg) throws Exception

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