Java面试题汇总 | 基础知识第五章

上一章 : Java面试题汇总 | 基础知识第四章-CSDN博客

流程控制语句

break ,continue ,return 的区别及作用?

break 跳出本次循环，不再执行循环(结束当前的循环体)

continue 跳出本次循环，继续执行下次循环(结束正在执行的循环，进入下一个循环条件)

return 程序返回，不再执行下面的代码(结束当前的方法，直接返回)

在 Java 中，如何跳出当前的多重嵌套循环？

在Java中，要想跳出多重循环，可以在外面的循环语句前定义一个标号，然后在里层循环体的代码中使用带有标号的 break 语句，即可跳出外层循环。以下是代码示例：

public static void main(String[] args){ 
    ok:for(int i = 0; i < 10; i ++){
            for(int j =0; j < 10; j ++){ 
                System.out.println("i=" + i + ",j=" + j);
                if(j == 5){
                    break ok;//使用break语句跳出带有标号的循环
                }
            }
        }
    }

加餐小tips : 

        在 Java 中，标号（Label）是用于标记代码块的一种机制，它使得我们可以使用 break 和 continue 语句来跳转和终止相应的循环或条件语句。标号通常用于循环语句和条件语句中，使得我们可以在满足特定条件时终止或继续循环的执行。标号的基本语法是在循环或条件语句之前声明一个标号，通常使用冒号" : "进行标记。

以下是一个更详细的代码示例 :

public class BreakExample {
    public static void main(String[] args) {
        // 外层循环
        outerLoop: // 声明标号
        for(int i = 1; i <= 5; i++) {
            // 内层循环
            for(int j = 1; j <= 3; j++) {
                // 循环体代码
                System.out.println("i = " + i + ", j = " + j);

                // 假设这里有一个条件，我们想要跳出外层循环
                if(i == 3 && j == 2) {
                    // 使用带标号的break语句跳出外层循环
                    break outerLoop; // 这里使用了outerLoop作为标号
                }

                // 内层循环继续执行
            }
            // 无论内层循环是否终止，外层循环都会继续执行
        }
        // 程序将在这里继续执行，直到外层循环结束
    }
}

面向对象

面向对象概述

面向对象和面向过程的区别?

面向过程：

        优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;

                比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

        缺点：没有面向对象易维护、易复用、易扩展。

面向对象：

        优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，

                可以设计出低耦合的系统，使系统更加灵活、更加易于维护。

        缺点：性能比面向过程低。

        面向过程是具体化的，流程化的，解决一个问题，需要一步一步的分析，一步一步的实现。

        面向对象是模型化的，你只需抽象出一个类，这是一个封闭的盒子，在这里你拥有数据也拥有解决问题的方法。需要什 么功能直接使用就可以了，不必去一步一步的实现，至于这个功能是如何实现的，不必关心，会用就可以了。

        总而言之，面向对象的底层其实还是面向过程，把面向过程抽象成类，然后封装，方便我们使用的就是面向对象了。

面向对象三大特性

面向对象的特征有哪些方面？

面向对象的特征主要有以下四个方面 ：

1.抽象 ：抽象是将一类对象的共同特征总结出构造类的过程，包括 数据抽象 和 行为抽象 两方面。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

加餐小tips：

        数据抽象是指从一类对象中抽取它们的共同特征和属性，并将其表示为类的属性的过程。换句话说，数据抽象关注的是对象的静态特征。例如，当我们创建一个“鸟”的类时，我们会为它定义一些属性，如两个翅膀、两支脚、有羽毛等。这些属性是从不同具体的鸟类对象中抽取出来的共同特征，它们构成了鸟类的数据抽象。
        行为抽象则是指从一类对象中抽取它们的共同行为和功能，并将其表示为类的方法的过程。行为抽象关注的是对象的运动和行为。仍以“鸟”为例，鸟会飞、会跳等行为，这些行为是从不同具体的鸟类对象中抽取出来的共同功能，它们构成了鸟类的行为抽象。

2.封装： 封装，即把一个对象的属性私有化，同时提供一些可以被外界访问的属性的方法。

3.继承： 继承是使用已存在类的定义作为基础建立新类的技术，新类（即子类）的定义可以增加新的数据或新的功能，也可以调用父类的功能，但不能选择性地继承父类。通过使用继承我们能够非常方便地复用以前的代码。

关于继承有以下 3 点请记住：

        1. 子类拥有父类非 private 的属性和方法。

        2. 子类可以拥有自己属性和方法，即子类可以对父类进行扩展。

        3. 子类可以用自己的方式实现父类的方法（即方法重写）。

4.多态：所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定。即一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

☆易混概念☆

其中Java 面向对象编程三大特性：封装 继承 多态

        封装：隐藏对象的属性和实现细节，仅对外提供公共访问方式，将变化隔离，便于使用，提高复用性和安全性。

        继承：继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。通过使用继承可以提高代码复用性。继承是多态的前提。

        多态：父类或接口定义的引用变量可以指向子类或具体实现类的实例对象。提高了程序的拓展性。 在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。

总结 ：

        面向对象编程的四大特征 ：抽象，封装，继承，多态

        面向对象编程的三大特性 ：封装，继承，多态

方法重写和方法重载的区别？

        方法重载（overload）实现的是编译时的多态性（也称为前绑定），而方法重写（override）实现的是运行时的多态性（也称为后绑定）。 一个引用变量到底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

         运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：

        1.方法重写  （子类继承父类并重写父类中已有的或抽象的方法）；

        2.对象造型（用父类型引用子类型对象，这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为）。

面向对象五大基本原则是什么？

单一职责原则SRP(Single Responsibility Principle)

        类的功能要单一，不能包罗万象，跟杂货铺似的。

开放封闭原则OCP(Open－Close Principle)

        一个模块对于拓展是开放的，对于修改是封闭的。

里式替换原则LSP(the Liskov Substitution Principle LSP)

        子类可以替换父类出现在父类能够出现的任何地方。比如你能代你爸去你姥姥家干活（？）

依赖倒置原则DIP(the Dependency Inversion Principle DIP)

        高层次的模块不应该依赖于低层次的模块，他们都应该依赖于抽象。抽象不应该依赖于具体实现，具体实现应该依赖于抽象。例如出国要说你是中国人，而不能说你是哪个市区的。

接口分离原则ISP(the Interface Segregation Principle ISP)

        设计时采用多个与特定客户类有关的接口比采用一个通用的接口要好。就比如一个手机拥有打电话，看视频，玩游戏等功能，把这几个功能拆分成不同的接口，比在一个接口里要好得多。

什么是多态机制？Java语言是如何实现多态的？

        所谓多态就是指  程序中定义的引用变量所指向的具体类型  和  通过该引用变量发出的方法调用  在编程时并不确定，而是在程序运行期间才确定，即 一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。

        因为在程序运行时才确定具体的类，不用修改原有的程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用或调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

        而多态分为 编译时多态 和 运行时多态 。

                 编译时多态： 是静态的，主要是指方法的重载，

                                     一般根据参数列表的不同来区分不同的函数，

                                      通过编译之后会变成两个不同的函数，在运行时谈不上多态。

                运行时多态： 是动态的，它是通过动态绑定来实现的，也就是我们所说的多态性。

多态的实现：

Java实现多态的两种形式：

         继承：多个子类对同一方法的重写

        接口：实现接口并覆盖接口中同一方法

Java实现多态有三个必要条件：

         继承：在多态中必须存在有继承关系的子类和父类。

        重写：子类对父类中某些方法进行重新定义，在调用这些方法时就会调用子类的方法。

        向上转型：在父类中调用已被子类重写的方法，同时保持代码的稳定性和可扩展性。

加餐小tips：

        向上转型允许程序在运行时使用子类的方法，即使代码中使用的是父类引用。这是因为Java支持方法重写，即子类可以有自己的方法实现，并且这些方法可以被父类引用调用。

        例如，假设有两个类Animal和Dog，其中Dog类是Animal类的子类。Animal类有一个方法叫作speak()，Dog类重写了这个方法来发出狗的叫声。如果我们有一个Animal类型的引用指向一个Dog对象，那么我们可以通过这个引用调用speak()方法，并且由于Dog类重写了这个方法，所以会发出狗的叫声，而不是其他动物的叫声。

        只有满足了上述三个条件，我们才能够在同一个继承结构中使用统一的逻辑实现代码处理不同的对象，从而达到执行不同的行为。 总而言之，Java多态性基于对象类型而非引用类型，允许子类方法通过超类引用调用。