面试必背 - Java篇（九）

最新推荐文章于 2024-06-10 17:51:25 发布

摸鱼老师

最新推荐文章于 2024-06-10 17:51:25 发布

阅读量34

点赞数

文章标签：面试 java python

本文链接：https://blog.csdn.net/qq_35460634/article/details/132548536

版权

81、获得一个类的类对象有哪些方式？

在Java中，获得一个类的类对象有以下几种方式：

使用Class.forName()方法：

try {
    // 通过类名获取类对象
    Class<?> clazz = Class.forName("java.lang.String");
    System.out.println(clazz); // 输出：class java.lang.String
} catch (ClassNotFoundException e) {
    e.printStackTrace();
}

使用Class.newInstance()方法：

try {
    // 通过类名获取类对象
    Class<?> clazz = Class.forName("java.lang.String");
    // 创建类的实例
    Object obj = clazz.newInstance();
    System.out.println(obj); // 输出：java.lang.String@xxxxxxxx（其中xxxxxxxx为内存地址）
} catch (InstantiationException | IllegalAccessException e) {
    e.printStackTrace();
}

使用Class.getDeclaredConstructor().newInstance()方法：

try {
    // 通过类名获取类对象
    Class<?> clazz = Class.forName("java.lang.String");
    // 获取类的无参构造方法
    Constructor<?> constructor = clazz.getDeclaredConstructor();
    // 创建类的实例
    Object obj = constructor.newInstance();
    System.out.println(obj); // 输出：java.lang.String@xxxxxxxx（其中xxxxxxxx为内存地址）
} catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
    e.printStackTrace();
}

使用类名.class语法：

public class MyClass {
    public static void main(String[] args) {
        // 获取MyClass类的类对象
        Class<?> clazz = MyClass.class;
        System.out.println(clazz); // 输出：class MyClass
    }
}

82、如何通过反射创建对象？

在Java中，通过反射可以创建对象。具体步骤如下：

获取Class对象：通过类名的.class属性或者对象的getClass()方法可以获取Class对象。
调用Class对象的newInstance()方法：通过Class对象的newInstance()方法可以创建一个新的对象实例。

以下是一个使用反射创建对象的例子：

import java.lang.reflect.Constructor;

public class ReflectDemo {
    public static void main(String[] args) {
        try {
            // 获取Class对象
            Class<?> clazz = Class.forName("java.lang.String");

            // 获取无参构造方法
            Constructor<?> constructor = clazz.getDeclaredConstructor();

            // 创建对象实例
            Object obj = constructor.newInstance();

            // 输出创建的对象实例
            System.out.println(obj);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们首先通过Class.forName()方法获取了String类的Class对象。然后，通过getDeclaredConstructor()方法获取了String类的无参构造方法。最后，通过newInstance()方法创建了一个String对象实例，并输出了创建的对象实例。

83、如何通过反射获取和设置对象私有字段的值？

在Java中，通过反射可以获取和设置对象的私有字段的值。具体步骤如下：

获取Field对象：通过Class对象的getDeclaredField()方法可以获取指定名称和类型的Field对象。
设置Field对象的值：通过Field对象的set()方法可以设置字段的值。
获取Field对象的值：通过Field对象的get()方法可以获取字段的值。

以下是一个使用反射获取和设置对象私有字段的例子：

import java.lang.reflect.Field;

public class ReflectDemo {
    public static void main(String[] args) {
        try {
            // 创建Person对象
            Person person = new Person("Tom", 18);

            // 获取Person类的Class对象
            Class<?> clazz = person.getClass();

            // 获取私有字段name的Field对象
            Field nameField = clazz.getDeclaredField("name");

            // 设置私有字段name的值
            nameField.setAccessible(true); // 设置为可访问，因为name字段是私有的
            nameField.set(person, "Jerry");

            // 获取私有字段name的值
            String name = (String) nameField.get(person);
            System.out.println("Name: " + name); // 输出：Name: Jerry
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

在这个例子中，我们首先创建了一个Person对象。然后，通过Person对象的getClass()方法获取了Person类的Class对象。接着，通过Class对象的getDeclaredField()方法获取了Person类的私有字段name的Field对象。由于name字段是私有的，我们需要调用setAccessible(true)方法将其设置为可访问。然后，通过Field对象的set()方法设置了name字段的值。最后，通过Field对象的get()方法获取了name字段的值，并输出了结果。

84、如何通过反射调用对象的方法？

在Java中，通过反射可以调用对象的方法。具体步骤如下：

获取Method对象：通过Class对象的getDeclaredMethod()方法可以获取指定名称和参数类型的方法对象。
创建Method对象实例：通过Method对象的invoke()方法可以创建一个Method对象实例。
调用Method对象实例的方法：通过Method对象实例的invoke()方法可以调用方法。

以下是一个使用反射调用对象方法的例子：

import java.lang.reflect.Method;

public class ReflectDemo {
    public static void main(String[] args) {
        try {
            // 创建Person对象
            Person person = new Person("Tom", 18);

            // 获取Person类的Class对象
            Class<?> clazz = person.getClass();

            // 获取私有方法getName()的Method对象
            Method method = clazz.getDeclaredMethod("getName");

            // 调用getName()方法
            String name = (String) method.invoke(person);
            System.out.println("Name: " + name); // 输出：Name: Tom
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // 私有方法getName()
    private String getName() {
        return name;
    }
}

在这个例子中，我们首先创建了一个Person对象。然后，通过Person对象的getClass()方法获取了Person类的Class对象。接着，通过Class对象的getDeclaredMethod()方法获取了Person类的私有方法getName()的Method对象。由于getName()方法是私有的，我们需要调用setAccessible(true)方法将其设置为可访问。然后，通过Method对象的invoke()方法调用了getName()方法，并输出了结果。

85、简述一下面向对象的”六原则一法则”。

面向对象编程的六原则一法则是SOLID原则，它包括以下六个原则：

单一职责原则（Single Responsibility Principle, SRP）：一个类应该只有一个原因引起变化，即一个类应该只负责一项职责。
开放封闭原则（Open/Closed Principle, OCP）：软件实体（类、模块、函数等等）应该可以扩展，但是不可修改。也就是说，对于一个已经实现的功能，我们可以通过继承、接口等方式进行扩展，而不需要修改原有的代码。
里氏替换原则（Liskov Substitution Principle, LSP）：子类型必须能够替换掉它们的父类型。也就是说，如果一个程序使用了一个基类的对象，那么它应该能够在不知道的情况下使用一个派生类的对象，而不会影响程序的正确性。
接口隔离原则（Interface Segregation Principle, ISP）：客户端不应该被迫依赖于它们不使用的接口。也就是说，一个类可以实现多个接口，但是这些接口之间应该是相互独立的，不应该存在重复的方法。
依赖倒置原则（Dependency Inversion Principle, DIP）：高层模块不应该依赖于低层模块，它们都应该依赖于抽象。也就是说，我们应该通过抽象类或接口来定义高层模块需要的依赖关系，而不是直接依赖于具体的实现类。
组合/聚合复用原则（Composition/Aggregation Reuse Principle, CARP）：要尽量使用组合或聚合关系来实现复用，而不是使用继承关系。也就是说，如果我们需要在一个类中使用另一个类的实例，并且这个实例只在当前类中使用，那么我们应该使用组合或聚合关系来代替继承关系。
合成复用原则（Composite Reuse Principle, CRP）：要尽量使用合成关系来实现复用，而不是使用继承关系。也就是说，如果我们需要创建一个类，并且这个类需要包含一些已经存在的类的实例，那么我们应该使用合成关系来创建这个类。
开闭原则（Open/Closed Principle, OCP）：软件实体（类、模块、函数等等）应该可以扩展，但是不可修改。也就是说，对于一个已经实现的功能，我们可以通过继承、接口等方式进行扩展，而不需要修改原有的代码。

下面是一个使用SOLID原则的代码示例：

// 单一职责原则（SRP）
interface Animal {
    void eat();
}

class Dog implements Animal {
    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

class Cat implements Animal {
    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

// 开放封闭原则（OCP）
interface Flyable {
    void fly();
}

class Bird implements Flyable {
    @Override
    public void fly() {
        System.out.println("Bird is flying.");
    }
}

class Airplane implements Flyable {
    private Bird bird;

    public Airplane(Bird bird) {
        this.bird = bird;
    }

    @Override
    public void fly() {
        bird.fly();
        System.out.println("Airplane is flying.");
    }
}

// 里氏替换原则（LSP）
class BirdImpl extends Bird {
    @Override
    public void fly() {
        System.out.println("BirdImpl is flying.");
    }
}

public class Main {
    public static void main(String[] args) {
        Bird bird = new BirdImpl();
        Flyable flyable = (Flyable) bird;
        flyable.fly(); // 输出：BirdImpl is flying.
    }
}

86、简述一下你了解的设计模式。

设计模式是面向对象软件设计中的一种经验总结，它描述了在软件设计过程中经常出现的问题和解决方案。常见的设计模式包括创建型模式、结构型模式和行为型模式。

创建型模式用于处理对象的创建过程，其中包括：

单例模式（Singleton）：确保一个类只有一个实例，并提供全局访问点。
工厂方法模式（Factory Method）：定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。
抽象工厂模式（Abstract Factory）：提供一个接口，用于创建相关或依赖对象的家族，而不需要明确指定具体类。
建造者模式（Builder）：将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
原型模式（Prototype）：用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。

结构型模式用于处理类和对象的组合，其中包括：

适配器模式（Adapter）：将一个类的接口转换成客户希望的另一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。
桥接模式（Bridge）：将抽象部分与实现部分分离，使它们可以独立变化。
组合模式（Composite）：将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。
装饰器模式（Decorator）：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰器模式比生成子类更为灵活。
外观模式（Facade）：为子系统中的一组接口提供一个一致的界面。外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
享元模式（Flyweight）：运用共享技术有效地支持大量细粒度的对象。
代理模式（Proxy）：为其他对象提供一种代理以控制对这个对象的访问。
职责链模式（Chain of Responsibility）：为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。
命令模式（Command）：将一个请求封装成一个对象，从而使你可用不同的请求对客户进行参数化；对请求排队或者记录请求日志，以及支持可撤销的操作。
解释器模式（Interpreter）：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
备忘录模式（Memento）：在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。
观察者模式（Observer）：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
状态模式（State）：允许一个对象在其内部状态改变时改变它的行为。对象看起来似乎修改了它的类。
策略模式（Strategy）：定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。
模板方法模式（Template Method）：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。
访问者模式（Visitor）：表示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

87、用 Java 写一个单例类。

以下是使用 Java 编写的单例类示例：

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

在这个示例中，我们使用了懒汉式单例模式。在 getInstance() 方法中，我们首先检查实例是否为空，如果为空则创建一个新的实例。由于懒汉式单例模式需要多次创建实例，因此我们在 getInstance() 方法上加上了 synchronized 关键字，以确保多线程环境下的安全性。

此外，我们还可以在构造函数上加上 private 关键字，以防止其他类实例化该类。

88、UML中有哪些常用的图？

UML是一种用于面向对象软件的建模语言，它包括多种图形来描述系统的结构、行为和交互。常用的UML图有：用例图、类图、对象图、状态图、活动图、时序图、协作图、组件图以及配置图。

其中，用例图是描述系统功能的静态视图，类图是描述系统中类的静态结构和关系，对象图是描述系统中对象的实例以及它们之间的关系，状态图是描述系统中对象的状态变化，活动图是描述系统中业务流程和操作的控制流，时序图是描述对象之间的消息传递顺序，协作图是描述对象之间的交互关系，组件图是描述系统的组成部分及其依赖关系，配置图则是描述系统的配置信息。

89、用 Java 写一个冒泡排序。

以下是使用 Java 编写的冒泡排序示例代码：

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {5, 2, 8, 4, 1};
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        int temp;
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

在上述代码中，我们定义了一个 bubbleSort 方法来实现冒泡排序。该方法接受一个整型数组作为参数，并对其进行排序。在排序过程中，我们使用了两个嵌套的循环来比较相邻的元素，并根据需要交换它们的位置。最后，我们在 main 方法中调用了 bubbleSort 方法，并打印出排序后的数组。

90、用 Java 写一个折半查找。

以下是使用 Java 编写的折半查找示例代码：

public class BinarySearch {
    public static void main(String[] args) {
        int[] arr = {1, 3, 5, 7, 9, 11, 13, 15};
        int target = 11;
        int index = binarySearch(arr, target);
        System.out.println("Target " + target + " found at index " + index);
    }

    public static int binarySearch(int[] arr, int target) {
        int left = 0;
        int right = arr.length - 1;
        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (arr[mid] == target) {
                return mid;
            } else if (arr[mid] < target) {
                left = mid + 1;
            } else {
                right = mid - 1;
            }
        }
        return -1; // If the target is not found, return -1
    }
}

在上述代码中，我们定义了一个 binarySearch 方法来实现折半查找。该方法接受一个整型数组和一个目标值作为参数，并返回目标值在数组中的索引。如果目标值不在数组中，则返回 -1。在查找过程中，我们使用了两个指针 left 和 right 来表示当前查找的范围，并不断缩小范围直到找到目标值或者范围为空。