2024-9-22

2023最新版Java秋招面试短期突击面试题【300道】我会出手带你一周上岸！（java基础、spring、redis、mysql、分布式等）_哔哩哔哩_bilibili什么是面向对象？谈谈你对面向对象的理解？

面向对象

什么是面向对象？

对比面向过程，是两种不同的处理问题的角度

面向过程更注重事情的每一个步骤及顺序，面向对象更注重事情有那些参与者（对象），及各自需要做什么

比如：洗衣机洗衣服

面向过程会将任务拆解成一系列的步骤（函数）

1，打开洗衣机--》2,放衣服---》3.放洗衣粉---》4.清洗---》5.烘干

面向对象会拆处人和洗衣机两个对象：

人：打开洗衣机，放衣服，放洗衣服

洗衣机：清洗，烘干

从以上例子能看出，面向过程比较直接高效，而面向对象更易于复用，扩展和维护。

面向对象

封装：封装的意义，在于明确标识出允许外部使用的所有成员和数据项

内部细节对外部调用透明。外部调用无需修改或者关心内部实现

javabean的属性私有，提供getset对外访问，因为属性的赋值或者逻辑只能由javabean本身决定，

而不能由外部胡乱修改。

private String name;

public void setName(String name){

        this.name="tuling_"+name

}

该name有自己的命名规则，明显不能由外部直接赋值

2.orm框架

操作数据库，我们不需要关心链接是如何建立的，sql是如何执行的，只需要引入mybatis，调用方法即可。

继承：继承基类的方法，并做出自己的改变和\或扩展

子类共性的方法或者属性直接使用父类的，而不需要自己再定义，只需扩展自己个性化的

多态：基类对象所属类的不同，外部对同一方法的调用，实际执行的逻辑不同。

继承，方法重写，父类引用指向子类对象

父类类型 变量名 = new 子类对象

变量名.方法名（）；

无法调用子类特有的功能

02-JDK、JRE、JVM区别和联系_哔哩哔哩_bilibili

JDK,JRE,JVM三者区别和联系

JDK JRE JVM

JDK 

Java Develpment Kit Java开发工具

JRE:

Java Runtime Environment Java运行时环境

JVM：

java Virtual Machine Java虚拟机

03-==和equals_哔哩哔哩_bilibili

==和equals比较

==对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的地址

equals:object中默认也是采用==比较，通常会重写

Object

public boolean equals(Object obj){

        return (this == obj);

}

String 

public boolean equals(Object anObject){

        if (this == anObject){

                return true;

        }

        if (anObject instanceof String){

                String anotherString =(String)anObject;

                int n = value.length;

                if ( n == anotherString.value.length){

                        char v1[] = value;

                        char v2[]=anotherString.value;

                        int i = 0;

                        while (n -- != 0){

                                if(v1[i] != v2[i])

                                        return false;

                                i++;

                        }

                        return true;

                }

        }

        return false;

{

上述代码可以看出，String类中被重写的equals()方法其实是比较两个字符串的内容

public class StringDemo{

        public static void main(String args[]){

                String str1 = "Hello";

                String str2 = new String("Hello");

                String str3 =str2;

                System.out.println(str1 == str2)://false

                System.out.println(str1 == str3);//false

                System.out.println(str2 == str3);//true

                SyStem.out.ptintln(str1.equals(str2));//true

                System.out.println(str1.equals(str3));//true

                System.out.println(str2.equals(str3));//true

        }

}

04-final_哔哩哔哩_bilibili

简述final作用

为什么局部内部类和匿名内部类只能访问局部final变量？

final

最终的

修饰类：表示类不可被继承

修饰方法：表示方法不可被子类覆盖，但是可以重载

修饰变量：表示变量一旦被赋值就不可以更改它的值。

（1）修饰成员变量

如果final修饰的是类变量，只能在静态。只能在静态初始化块中指定初始化值或者声明该类变量时指定初始值

如果final修饰方是成员变量，可以在非静态初始化块，声明该变量或者构造器中执行初始执行初始化

（2）修饰局部变量

系统不会为局部变量进行初始化，局部变量必须由程序员显示初始化。

因此使用final修饰局部变量时，即可以在定义时指定默认值（后面的代码不能对变量再赋值），也可以不指定默认值，而在后面的代码中对final变量赋初值（仅一次）

public class FinalVar{

        final static int a = 0; //再申明的时候就需要赋值，或者静态代码块赋值

        /**

        static{

                a = 0;

        }

        */

        final int b = 0;//再声明的时候就需要赋值，或者代码块中赋值 或者构造器赋值

        /*{

        b = 0;

        */

        public static void main(String[] args){

                final int localA;        //局部变量只声明没有初始，不会报错。与final无关

                localA = 0;//在使用之前一定要赋值

                //localA = 1; 但是不允许第二次赋值

        }

}

（3）修饰基本类型数据和引用类型数据

如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；

如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象，但是引用的值是可变的。

public class FinalReferenceTest{

        public static void main(){

                final int[] iArr={1,2,3,4}

                iArr[2]=3;//合法

                iArr=null//非法，对iArr不能重新赋值

                final Person p =new Person(25);

                p.setAge(24);//合法

                p=null；//非法

        }

}

为什么局部内部类和匿名内部类只能访问局部final变量？

编译之后会生成两个class文件，Test.class Test1.class

public class Test{

        public static void main(String[] args){
        }

        //局部final变量a,b

        public void test(final int b){

                final int a = 10;

                //匿名内部类

                new Thread(){

                        public void run(){

                                System.out.println(a);

                                System.out.println(b);

                        };

                }.start();

        }

}

class OutClass{

        private int age = 12;

        public void outPrint(final int x){

                class InClass{

                        public void Inprint(){

                                System.out.println(x);

                                System.out.println(age);

                        }

                }

                new InClass（）.InPrint();

        }

}

首先要知道的一点是：内部类和外部类是处于同一个级别的,内部类不会因为定义在方法中就会随之方法的执行完毕就被销毁。

这里就会产生问题：当外部类的方法结束时，局部变量就会被销毁了，但是内部类对象可能还存在（只有没有人在引用它时，才会死亡）。这里就出现了一个矛盾；内部类对象访问了一个不存在的变量。为了解决这个问题，就将局部变量复杂了一份作为内部类的成员变量，这样当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的“copy”。

这样就好像延长了局部变量的生命周期

将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果我们在内部乐类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？

就将局部变量设置为final，对它初始化后，我就不让你再去修改这个变量，就保证了内部类的成员变量和方法的局部变量的一致性，这实际上也是一种妥协。

使得局部变量与内部类内建立的考保持一致。

05-String、StringBuffer、StringBuilder区别及使用场景_哔哩哔哩_bilibili

String,StringBuffer,StringBuilder区别和联系

String,StringBuffer，StringBuilder

String是final修饰的，不可变，每次操作都会产生新的String对象

StringBuffer和StringBuilder都是在原对象上操作

StringBuffer是线程安全的，StringBuilder是线程不安全的

StringBuffer方法都是synchronized修饰的

性能StringBuilder>StringBuffer>String

场景：经常需要改变字符串内容时使用后面两个

优先使用StringBuilder，多线程使用共享变量时使用StringBuffer

06-重载和重写的区别_哔哩哔哩_bilibili

重载和重写的区别

重载：发生在同一个类中，方法名必须相同，参数类型不同，个数不同，顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。

重写:发生在父子类中，方法名，参数列表必须相同，返回值范围小于等于父类，抛出的异常范围小于等于父类，访问修饰符访问大于等于父类；如果父类方法访问修饰符为private则子类不能重写该方法

public int add(int a,String b)

public String add(int a,String b)

//编译报错