56道java基础必“背“面试题（备战2024金三银四

最新推荐文章于 2024-08-23 15:54:50 发布

2401_84159783

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量464

点赞数 11

分类专栏：程序员文章标签： java 算法排序算法

本文链接：https://blog.csdn.net/2401_84159783/article/details/137616513

版权

程序员专栏收录该内容

29 篇文章 0 订阅

订阅专栏

5.常见基本数据类型和对应字节

byte 1

short 2

int 4

long 8 0l

float 4 23.23F

double 8 23.23D

boolean 1 true false

char 2

基本数据类型

byte 1B 0 -128~~~127

short 2B 0 -32768~~~32767

int 4B 0 -2147483648~~~2147483647

long 8B 0L

float 4B 0.0F|f

double 8B 0.0===>1.2D|d

boolean 1B false

char 2B ‘\u0000’

在这里插入图片描述

测试题

1. 0.553423   这个是什么类型      ===>double  字面值double

short的取值范围是多少? ~32768===32767
int a=32766 a=a+3 a=? 32769
short a=32766; //一个数据类型一旦数据超过范围之后会从负数最小值开始变化

a++; ====> //32767

a++;//-32768 //自增自减无法自动类型提升

System.out.println(a); ====> -32768

short a=1; 1. a++; 2 2.a=a+1 编译报错 int

double a = 0.6454D; (正确)

float f = 0.993434;(错误) 必须加入F|f

short a=12; a++;(正确) a=a+3;(错误) 解释:算数运行会自动类型提升自增自减运算不会自动类型提升

6.自动类型提升？

byte -> short -> int -> long -> float -> double

当两个操作数有一个为double时，运算结果为 double

没有double，出现float，结果为float

没有float，出现long，结果为long

没有long，出现int，结果为int

除long类型外，其余整数类型运算结果均为int类型

7.&&与 & 、|| 和 |有什么区别?

&&（与）、||(或)、!(非) ====> 逻辑运算

与: 两边同时为true 结果才是true
或: 两边只要有一个结果为true 结果就是true
非: 非真即假

&、|、~ 、^ =============> 位运算

int a = 1

0000 0000 0000 0000 0000 0000 0000 0001

int b = 2

0000 0000 0000 0000 0000 0000 0000 0010

1&2 = 0

1|2 = 3

~2 = -3

1^2 = 3

&(与): 从最高位运算，运算符两个位都为1，结果才为1，否则结果为0
|(或): 运算符两个位只要有一个为1，那么结果就是1，否则就为0
“~”(非): 表示位为0，结果是1，如果位为1，结果是0
“^”(异或): 表示的两个的位，相同则结果为0，不同则结果为1

8.冒泡排序选择排序

1 3 2 6 7 4 5 9 必须背下来

冒泡排序思路: 两个相邻的元素比较,并且交换位置

for (int i = 0; i < a.length; i++) {

for (int j = 0; j < a.length-1; j++) {

if(a[j]>a[j+1]){

int tmp = a[j];

a[j] = a[j+1];

a[j+1] =tmp;

}

选择排序思路: 指定下标与所有数字比较

for (int i = 1; i < a.length; i++) {

for (int j = i; j < a.length; j++) {

if(a[i-1] > a[j]){

int tmp = a[i-1];

a[i-1] = a[j];

a[j] = tmp;

}

9.数组扩容的思想？

1.创建更大数组进行搬家 int[] a = {12,23,23,345}; int[] b = new int[a.lenght*2]

2.java.util.Arrays.copyOf(原数组名，新数组长度);

3.System.arraycopy(原数组名，起始下标，新数组名，起始下标，复制长度);

10.面向对象的三大特性

1.封装继承多态

封装: 提高类和系统安装性体现: 属性私有提供公开的GET和SET方法
继承: 建立类的层次和等级方便扩展体现: 子类继承父类单继承一个子类只允许存在一个父类
多态: 父类引用指向子类对象体现: 父类引用调用父类中方法实际执行时执行的是子类覆盖之后方法

11.什么多态

多态: 父类引用指向子类对象

class Animal{

public void eat(){… Animal eat}

}

class Dog extends Animal{

public void eat(){… Dog eat}

public void play(){…}

}

class Cat extends Animal{

public void eat(){… Cat eat}

public void runing(){…}

}

Animal a = new Dog();

a.eat(); //Dog eat

Animal b = new Cat();

b.eat(); //cat eat

引用调用引用类中声明方法在实际执行时执行子类覆盖之后方法

12.关于构造方法?

构造方法

作用: 用来创建对象

特点:

1.构造方法没有返回值

2.方法名必须和类名一致

3.不允许手动调用,在创建对象时自动调用 new Student();

4.当在类中没定义任何构造方法时，系统会默认分配一个公共无参的构造方法注意:一旦类中显示定义构造方法默认的构造方法则不存在

13.this、super关键字

this: 当前引用指的:我

this.属性名 this.方法名: 用于在构造方法或普通方法中，调用当前对象的属性或方法
this(): 只能用在构造方法中,只能出现在构造方法第一行代表调用本类中构造方法

super: 父类引用指的父类对象

super.属性 super.方法 : 用在子类的构造方法或普通方法中，调用父类的属性或方法
super() : 只能用在构造方法中,只能出现在构造方法第一行代表调用父类中构造方法注意:this() super()不能同时出现

14.继承时对象的创建过程？

对象创建过程

分配空间
初始化属性默认值
调用构造方法

继承时对象的创建过程

分配空间 (父子类空间一起分配)
初始化父类属性
调用父类构造方法(创建父类对象)
初始化子类属性
调用子类构造方法(创建子类对象)

15.java中继承关系

java中类单继承

一个类只能存在一个父类但是可以实现多个接口

java中接口多继承

一个接口可以继承多个接口

为什么接口可以多继承

因为接口定义的都是抽象的方法，而且不能在接口中实现方法。所以，接口继承多个接口，并不会使接口的结构变得很复杂。

类 extends 父类 implemplents interface,interface1

为什么JAVA只能单继承？

因为在C++中一个类是可以继承自多个类,但这样的机制会使类的结构变的很复杂,所以JAVA将C++这一机制通过接口得以改善。

JAVA中不允许类多重继承,只能单一继承,但有些情况单一继承并不能表达出现实世界中的某些逻辑关系,所以就提出了通过接口来实现多重继承。

16.overload(重载)、override(覆盖)?

overload: 方法重载

方法名相同参数列表不同(参数个数,类型,顺序) 和返回值无关

override: 方法覆盖方法重写

方法名相同参数列表相同返回值相同访问权限修饰相同或更宽抛出异常相同或更少

18.instanceof关键字作用? transient关键字作用？

instanceof

用来判断引用实际类型是什么用法: a instanceof Dog 返回值: 类型一致 true 不一致 false

if(a instanceof Dog){

}

Animal a = new Dog(); a intanceof Dog

Animal b = new Cat();

transient

用来作用于成员变量属性上,代表这个属性在对象序列化时不参与对象序列化

19.三大修饰符

static: 静态的

类 : 静态类
属性 : 静态属性全类共享可以直接使用类名.属性名直接使用
方法 : 静态方法: 全类共享可以直接使用类型.方法名直接调用
代码块: 静态代码: 静态在类加载时候执行, 只执行一次

final: 最终的

类: 最终类: (断子绝孙) 该类不能被继承
属性: 最终的属性: 属性一旦被赋值不能被修改
方法: 最终方法: 可以被继承,不能被覆盖

try{}catch(Exception e){}finally{} //总是被执行

finallize() //在jvm垃圾回收自动调用

abstract: 抽象的

类: 抽象类: 不能通过new关键创建对象
方法: 抽象方法: 只有声明没有实现

注意:

1.抽象类中一定含有抽象方法不对

2.存在抽象方法类一定时抽象类对

3.抽象类中存在构造方法对

4.抽象类中因为不能通过new创建对象,因此类中没有构造方法不对

5.抽象类中构造方法用来干什么? 用来为子类继承时创建子类对象用的

6.String 类能不能被继承? 不能被继承 final 关键字

为什么使用final关键字修饰?

字符串类中所有方法都是线程安全的方法,如果允许继承,可能会破坏string

中线程安全

#面试

 1.存在抽象方法类一定是抽象类                    对

 2.抽象类一定存在抽象方法                       不对

 3.被static修饰方法方法内只能使用外部静态成员     对

 4.普通方法可以直接使用static修饰方法           对

 5.static修饰方法可以直接使用外部普通方法       不对

 6.jdk中String类可以被继承?                  不能       为什么String要设计成final的    String 不可变字符串  String name="小陈"  name+"xiaohei";

 7.抽象类中没有构造方法?                      存在,子类继承父类时  创建父类对象使用

20.静态代码块，动态代码块，构造方法的执行顺序

public class Student extends People{

//静态代码块: 类加载时候执行只执行一次类加载: jvm第一次使用到这个.class文件进行类加载 classLoader ===> jvm

static{

System.out.println(“1”);

}

//对象: 初始化属性调用构造方法

//动态代码块: 作用:用来给类中属性赋值的

{

System.out.println(“2”);

}

//构造方法: 创建对象的时候自动执行

public Student() {

System.out.println(“3”);

}

public static void main(String[] args) {

Student student = new Student();//5 1 6 4 2 3

}

class People{

static {

System.out.println(“5”);

}

{

System.out.println(“6”);

}

public People() {

System.out.println(“4”);

}

21.下面代码的执行顺序

public class Test{

private String name;

static{

System.out.println(“1”);

}

{

name = “小陈”;

System.out.println(“2”);

}

public Test() {

System.out.println(“3”);

}

public static void main(String[] args) {

new Test();

}

解释:

1.当jvm第一次读取类信息时会执行类加载,static代码块是在类加载时候执行,因此最先执行输出1
2.{}代码块: 初始化代码块,在创建对象时为属性进行初始化执行,因此创建对象之前要先经历属性初始化才创建对象因此输出2
3.构造方法: 在创建对象时自动调用,最后输出3

22.什么是类加载?

类加载

类加载，在JVM第1次使用某个类时，先在classpath下找到对应的.class文件，读取该.class文件中的内容(包/名/属性/方法…)到内存中并且保存(类对象)起来的过程。类加载只进行1次

23.简述 final finalized finally 的区别?

final 最终的

类: 修饰不能被继承
属性: 最终属性一旦被赋值不能被修改
方法:最终方法可以被继承不能覆盖
String类能不能被继承? 不能原因是:被final关键字修饰的
String:为什么要设计成final? String不希望有子类,子类会破坏父类中方法规则原因:字符串类中所有方法都是线程安全的,如果存在子类破坏父类中方法线程安全

finalized 垃圾回收时jvm自动执行的方法

finally 最终的一般 try catch 进行连用 try{}finally{}

finally 代码中的内容: 无论什么情况总是执行

24.接口和抽象类区别

interface 接口

1.接口之前可以多继承 interface A extends B,C… 2.类 implements A,B,…
2.接口中定义变量都是静态常量接口中变量都是被 public static final String NAME = “xiaochen”; 修饰的静态常量
3.接口中方法公开抽象方法只有声明没有实现 (jdk8) (jdk8)以后,接口中方法可以存在默认实现

抽象类 abstract

1.类中含有构造方法
2.抽象类只能单继承
3.抽象类存在普通方法
4.抽象类中存在抽象方法只有声明没有实现的

25.”==”与equals有何区别？

==

比较地址内存地址

user1 == user2

equals

比较内容是否一致

user1.equals(user2); //比较对象:必须覆盖euqals 和 hashCode方法

26.StringBuilder与Stringbuffer的区别？

StringBuilder 、 StringBuffer

共同点: 都是用来进行字符串拼接的
不同点:

1.StringBuilder 线程不安全效率高

2.StringBuffer 线程安全效率低

27.简述ArrayList、LinkedList、Vector三者的区别?

ArrayList LinkedList Vector 都是List接口实现类都是集合

ArrayList: 底层实现: 数组特点:一段连续内存空间根据下标快速查询查询快(O(1)) 增删慢 O(n) 线程不安全
LinkedList: 底层实现: 链表特点:指针概念将节点连接在一起增删快(O(1)) 查询慢(O(n))
Vector: 底层实现: 数组特点: 一段连续内存空间根据下标快速查询查询快(O(1)) 增删慢 O(n) 线程安全

28.HashMap和HashTable的区别？

hashmap

线程不安全的允许key value 同时为null

hashtable

线程安全的不允许key value 同时为null

ConcurrentHashMap(并发hashmap) 线程安全效率 hashtable

线程安全的效率远高于hashtable

Hashtable和ConcurrentHashMap有什么分别呢？它们都可以用于多线程的环境，

但是当Hashtable的大小增加到一定的时候，性能会急剧下降，因为迭代时需要被锁定很长的时间。数组+链表

因为ConcurrentHashMap引入了分割(segmentation)，不论它变得多么大，仅仅需要锁定map的某个部分，对表进行分段加锁16段

而其它的线程不需要等到迭代完成才能访问map。简而言之，在迭代的过程中，ConcurrentHashMap仅仅锁定map的某个部分，而Hashtable则会锁定整个map。

29.HashSet如何实现元素不重复?

自定义类型

需要在类中覆盖hashcode和equals方法

非自定义类型

内部底层自动覆盖hashcode 和 equals

30.简述流的分类？

方向

输入流: 将数据读入jvm中
输出流: 将jvm中数据写出

功能

节点流 : 实际负责传输数据的流
过滤流 : 增强节点流功能（处理流、装饰类），依赖节点流

单位

字节流: 读取一切数据
字符流: 读取文本类型的数据

InputStream is = new FileInputStream(“”)

OutputStream os = new FileOutputStream(“”)

文件拷贝代码

1.定义输入流定义输出流

InputStream is = new FileInputStream(new File(“d://aa.txt”)); 900byte

OutputStream os = new FileOutputStream(new File(“e://bb.txt”));

2.文件拷贝

byte[] b = new byte[1024]; //1KB

int len = 0;

while(true){

len = is.read(b);

if(len=-1)break;

os.write(b,0,len);

}

//2.IOUtils.copy(is,os); //引入commons-io工具包

3.释放资源

is.close();

os.close();

在这里插入图片描述

31.什么是线程？

线程

进程: 一个进程中可以化分为多个线程线程是程序调度基本单位
多线程: 可以提高程序运行效率

new Thread(()=>{

}).start();

java中实现多线程方式: 1.继承Thread类 2.实现runable接口 3.线程池 4.线程辅助类 FeatureTask Callable

线程状态 5种状态(操作系统角度)

NEW 新建状态
RUNNABLE start方法之后进入可运行状态
RUNNING 获取cpu时间片运行状态
BLOCKED Thread.sleep(1000); IO … 阻塞状态
DEAD 死亡状态

32.什么是线程安全？

线程安全

如果你的代码所在的进程中有多个线程在同时运行，

而这些线程可能会同时运行这段代码。

如果每次运行结果和单线程运行的结果是一样的，

而且其他的变量的值也和预期的是一样的，就是线程安全的。

一个线程安全的计数器类的

同一个实例对象在被多个线程使用的情况下也不会出现计算失误。

33.线程安全案例

类对象唯一，可以使用类对象加锁

类对象在jvm就一个，唯一

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gtCivnQq-1640409536714)(image/image.png)]

对象锁

public class TestThread {

private static int count = 0;

private static Object o = new Object();

//synchronized (对象) 对象锁

public static synchronized void main(String[] args) throws InterruptedException {

synchronized(TestThread.class){

// getstatic +1 value putstatic t1

Thread t1 = new Thread(() -> {

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

e.printStackTrace();

}

synchronized (o){

for (int i = 0; i < 10000; i++) {

count++;

}

});

Thread t2 = new Thread(() -> { //t2

synchronized (o) {

for (int i = 0; i < 10000; i++) {

count–;

}

});

t1.start();

t2.start();

t1.join();//阻塞main等待线程执行完成

t2.join();//阻塞main等待线程执行完成

System.out.println(count);

}

34.实现多线程方式

1.继承Thread类

Thread1 extends Thread {

public void run(){

// 线程的功能代码

}

//使用：a. 创建线程对象

Thread1 t1 = new Thread1();

//b. 启动线程

t1.start(); // 启动线程，JVM自动调用run方法

// t1.run(); //error. 相当于调用了一个对象中的方法

2.实现Runable接口

Thread2 implements Runnable{

//实现run方法

@Override

public void run(){

//线程的代码功能

}

//使用

Thread thread = new Thread(new Thread2());

thread.start();

3.实现 Callable 接口

Thread1 implements Callable {

public void run(){

// 线程的功能代码

}

//使用：a. 创建线程对象

Thread1 t1 = new Thread1();

//b. 启动线程

t1.start(); // 启动线程，JVM自动调用run方法

// t1.run(); //error. 相当于调用了一个对象中的方法

4.使用FeaturTask

获取线程执行任务结果

//线程任务对象

FutureTask futureTask = new FutureTask<>(new Callable() {

@Override

public Integer call() throws Exception {

System.out.println(Thread.currentThread().getName()+ “-----------”);

return 10;

}

});

new Thread(futureTask).start();

System.out.println(futureTask.get());

35.sleep() 和 wait() 有什么区别

共同点: 都是让线程进入等待状态 sleep 有限期等待 wait 无限期等待

sleep() 线程对象中方法

线程进入等待之后,不会释放对象锁,等待结束之后恢复线程继续执行

wait() Object类中方法

线程进入等待之后,释放掉当前对象锁,只有接收notify() 或者notfiyall() 之后才能恢复运行,恢复运行时重新进入等待队列获取锁表标记

36.通过反射获取类对象的3种方式

反射获取对象

1)通过类名.class 获取 Class对象

Class s = Student.class;

2)创建对象，通过对象 . getClass() 获取Class对象

Strudet student = new Student();

Class s = student.getClass();

3)通过 Class.forName(“包名.类名”); 获取Class对象

Class s = Class.forName(“java.util.HashSet”);

37.单例设计模式

//只能创建一个对象

懒汉式

class User{

private static User user;

private User(){}

public synchronized static User getInstance(){ //存在线程安全问题:必须加入线程锁

if(user == null){

user = new User();

}

return user;

}

恶汉式

class User{

private static final User user = new User();

private User(){}

public static User getInstance(){

return user;

}

38.单例模式案例

public class TestSingleton {

public static void main(String[] args) {

for (int i = 0; i < 100; i++) {

new Thread(()->{

System.out.println(Dept.getInstance());

}).start();

}

//懒汉式: 每次使用使用创建存在线程安全的问题

class Dept{

private static Dept dept;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）

最后

Java架构进阶面试及知识点文档笔记

这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理

Java分布式高级面试问题解析文档

其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！

互联网Java程序员面试必备问题解析及文档学习笔记

Java架构进阶视频解析合集

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

stSingleton {

public static void main(String[] args) {

for (int i = 0; i < 100; i++) {

new Thread(()->{

System.out.println(Dept.getInstance());

}).start();

}

//懒汉式: 每次使用使用创建存在线程安全的问题

class Dept{

private static Dept dept;

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-pLYkYI5c-1712764395176)]
[外链图片转存中…(img-dr8jdU99-1712764395176)]
[外链图片转存中…(img-QkvNjS0w-1712764395177)]
[外链图片转存中…(img-XTIvBFci-1712764395177)]
[外链图片转存中…(img-6U5A3ogN-1712764395177)]
[外链图片转存中…(img-ygxOswy3-1712764395177)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

如果你觉得这些内容对你有帮助，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-qv4rQotc-1712764395178)]

最后

Java架构进阶面试及知识点文档笔记

这份文档共498页，其中包括Java集合，并发编程，JVM，Dubbo,Redis，Spring全家桶，MySQL，Kafka等面试解析及知识点整理

[外链图片转存中…(img-hAUAa6Rn-1712764395178)]

Java分布式高级面试问题解析文档

其中都是包括分布式的面试问题解析，内容有分布式消息队列，Redis缓存，分库分表，微服务架构，分布式高可用，读写分离等等！

[外链图片转存中…(img-d7aGLp8H-1712764395178)]

互联网Java程序员面试必备问题解析及文档学习笔记

[外链图片转存中…(img-FRjXVPDE-1712764395178)]

Java架构进阶视频解析合集

一个人可以走的很快，但一群人才能走的更远。不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎扫码加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
[外链图片转存中…(img-SW8sqxS0-1712764395179)]

2401_84159783

关注

11
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
56道java基础必“背“面试题（备战2024金三银四

类: 抽象类: 不能通过new关键创建对象方法: 抽象方法: 只有声明没有实现注意:1.抽象类中一定含有抽象方法不对2.存在抽象方法类一定时抽象类对3.抽象类中存在构造方法对4.抽象类中因为不能通过new创建对象,因此类中没有构造方法不对5.抽象类中构造方法用来干什么?用来为子类继承时创建子类对象用的6.String 类能不能被继承?不能被继承 final 关键字为什么使用final关键字修饰?
复制链接

扫一扫