java基础面试

基础知识

基本数据类型

8种基本数据类型：byte，short，int，long，double，float，char，boolean，

基本类型	默认值	存储	对应的包装类	数据范围
byte	0	1个字节	java.lang.Byte	[-27，27-1]
int	0	4个字节	java.lang.Integer	[-231，231-1]
short	0	2个字节	java.lang.Short	[-215，215-1]
long	0L或0l	8个字节	java.lang.Long	[-263，263-1]
double高精度	0.0或0.0D(d)	8个字节	java.lang.Double	64位IEEE 754双精度范围
float低精度	0.0F或0.0f	4个字节	java.lang.Float	32位IEEE 754单精度范围
char	‘\u0000’	2个字节	java.lang.Character	[0，2^16-1]
boolean	false	1个字节	java.lang.Boolean	true\false

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iONk5hsJ-1684947403195)(java基础面试.assets/771270b1b017482e873ffea856644eb3.png)]

强类型语言（java，C++，必须先定义后使用，有严格的规定，单双引号有区别）和弱类型语言（js，单双引号无区别）？

Java声明变量：先指定类型后赋值，

装箱和拆箱是如何实现的?

装箱的时候自动调用的是Integer的**valueOf(int)**方法。而在拆箱的时候自动调用的是Integer的intValue方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CAMHTTjI-1684947403197)(java基础面试.assets/image-20221015143238882.png)]

为什么有装箱和拆箱？

①将基本数据类型变成引用数据类型，调用对象方法

②List<泛型必须是引用数据类型>

面向对象：能点

基于对象开始编程，

引用数据类型点击就会出现很多方法。

int和Integer有什么区别

Integer是引用数据类型（的默认值都是null），int的包装类；

int是基本数据类型。
Integer变量必须实例化后才能使用；int变量不需要。
Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值。
Integer的默认值是null；int的默认值是0

什么时候用int什么时候用Integer？

声明整型，int不能表示空，integer是表示空，用于判断。

比如淘宝搜索功能，搜和搜错的请求是一样的，不确定用户搜什么，可能还有错别字。

判断关键词是否存在，

比如搜索年龄，有值的时候显示，没有值的时候不显示，用integer。

分页功能，可以用int，

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1zbVKcfg-1684947403198)(java基础面试.assets/image-20221015144820905.png)]

状态判断用Integer

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-g4BsAW9r-1684947403198)(java基础面试.assets/image-20221015144640799.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MlLWR3bC-1684947403199)(java基础面试.assets/image-20221015144623503.png)]

Integer的缓存机制。

从jdk1.5开始，java给Integer类型引入了一个新的特性，用来节省内存和提高效率。整型对象在内部实现中通过使用相同的对象引用实现了缓存和重用。

• 上面的规则适用于整数区间 -128 到 +127。声明超过127的就会出现新的对象，就会缓存
• 这种 Integer 缓存策略仅在自动装箱（autoboxing）的时候有用，使用构造器创建的 Integer 对象不能被缓存。
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-i82KlUfq-1684947403199)(java基础面试.assets/image-20221015145049193.png)]
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Gfqq5zuu-1684947403200)(java基础面试.assets/image-20221015145106070.png)]
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OPtuLY4N-1684947403200)(java基础面试.assets/image-20221015145209428.png)]
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MdMyBOiH-1684947403200)(java基础面试.assets/image-20221015145237754.png)]
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-eqWXfpkk-1684947403201)(java基础面试.assets/image-20221015145324949.png)]

为什么不推荐使用浮点型来表示金额

一般来说，我们的单精度float和双精度double已经可以满足我们的大部分需求了。但是不管是float和double都会出现浮点的误差，而这点误差在一般情况下并不影响我们的使用。

但是，在金融行业，一个小小的精度误差，可能会导致成千上万的损失，甚至严重点来说，可能会有牢狱之灾。因此，我们必须去严格的计算每一个小数点的值，不能出现任何误差。

JDK提供了一个BigDecimal的类，这个类可以表示任意精度的数字。

double 0.1+0.2 != 0.3

String类型

String类中的常用方法

https://blog.csdn.net/weixin_45921434/article/details/125686916?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166581819016782388029759%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=166581819016782388029759&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduend~default-1-125686916-null-null.142

https://blog.csdn.net/weixin_57614141/article/details/122357581

+(语法糖)

拆分字符串、非空验证、截取字符串、替换字符串、查询字符出现的位置

indexOf()：返回指定字符的索引。
charAt()：返回指定索引处的字符。
replace()：字符串替换。
trim()：去除字符串两端空白。
split()：分割字符串，返回一个分割后的字符串数组。
getBytes()：返回字符串的 byte 类型数组。
length()：返回字符串长度。
toLowerCase()：将字符串转成小写字母。
toUpperCase()：将字符串转成大写字符。
substring()：截取字符串。
equals()：字符串比较。

什么是String的不可变性⭐

声明一个变量String S，对此进行操作，对象会变化，但是还是String S，

java的数组有什么特点？

数组长度不可变，内容可变。加一个删一个就会生成一个新的对象去存。

字符串也是一个不可变

String s = new String(“abc”);创建了几个对象？

2个，new String是一个对象，“abc”又是一个

扩展题目：String s = “aaa”+new String(“abc”);创建了几个对象。

3个，

new String是一个对象，

“abc”又是一个，

“aaa”+new String(“abc”)的结果，因为“aaa”没有去新的创建，

==和equal的区别

**==比较基本数据类型（年龄相同）时，比较的是他们的值，比较引用数据类型（人不同）**时，比较的是他们内存地址。

没有被重写的**equals（引用数据类型）**比较两个对象时，效果实际上和==一致，重写了equals后会按照重写的逻辑比较。

integer比较看范围，超出范围用equals

比如String类就重写了equals方法，让两个字符串强制比较值。

所有类都有equal类，

因为都会继承object类，类中有equal类

==

如果比较的是基本数据类型变量，比较两个变量的值是否相等。(不一定数据类型相同)
如果比较的是引用数据类型变量，比较两个对象的地址值是否相同，即两个引用是否指向同一个地址值

equal

如果类中重写了equals方法，比较内容是否相等。
String、Date、File、包装类都重写了Object类的equals方法。

如果类中没有重写equals方法，比较地址值是否相等（是否指向同一个地址值）。

  Student stu1 = new Student(11, "张三");
  Student stu2 = new Student(11,"张三");
  System.out.println(stu1.equals(stu2));//false

既然equals比较的是内容是否相同，为什么结果还是false呢？

回顾知识：
在Java中我们知道任何类的超类都是Object类，Student类也继承Object类。

查看Object类中的equals方法也是 == 比较（也就是比较地址值），因此结果当然是false。

public static void main(String[] args) {
  //    ==  equals区别详解
  Integer in3 = new Integer(56);   
  Integer in4 = new Integer(56);
  System.out.println(in3==in4); //false，引用数据类型，new了不同地址，==引用数据类型变量，比较两个对象的地址值是否相同，即两个引用是否指向同一个地址值，
  System.out.println(in3.equals(in4));//true，没有重写了equals方法，比较内容是否相等。
  
  Integer in5 = 25;       
  Integer in6 = 25;
  System.out.println(in5 ==in6);//true  地址相同，==引用数据类型变量，比较两个对象的地址值是否相同，即两个引用是否指向同一个地址值，
  System.out.println(in5.equals(in6));//true ，在范围内有不会创建新的
  
  Integer in7 = 256;    //-128到127，是常量值，边界值，之外的就是flase    
  Integer in8 = 256;
  System.out.println(in7 ==in8);		//false 超过限制，会new新的，地址不一样
  System.out.println(in7.equals(in8));	//内容相等，
    
  Integer in9 = 127;    //小于127，边界值    
  Integer in10 = 127;
  System.out.println(in9 ==in10);//true，==引用数据类型变量，比较两个对象的地址值相同
    
  Student stu1 = new Student(11, "张三");
  Student stu2 = new Student(11,"张三");
  System.out.println(stu1.equals(stu2));//false，new了两个对象，没有重写equals方法，比较地址值是否相等（是否指向同一个地址值），equal比较对象。

    
   String a = "张三";
   String b = "张三";
   System.out.println(a.equals(b));  //true String重写了Object类的equals方法，重写的equal方法比较的是内容，

字符串使用equals比较时需要注意什么？

但凡是字符串就会出现空，不然就会出现null.equal，就会出现空指针异常NullPointerException

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3mfhXAwD-1684947403201)(java基础面试.assets/image-20221015154212539.png)]

break和continue和return的区别

1、break 用于循环语句和switch语句

break用于跳出循环语句(即终止循环语句)或跳出switch语句
break语句之后没有使用任何标签时用于跳出循环或switch语句
break语句之后有标签时用于跳出标签所标记的循环语句

2、continue用于循环语句

continue用于略过本次循环中的后续语句进行下次循环
continue语句之后没有使用任何标签时用于略过本次循环后续语句进入下次循环
continue语句之有标签时用于略过后续语句进入标签所标记循环的下次循环

3、return用于方法体中

return可用于返回数据
return可将当前正在执行的方法终结

String 和 StringBuilder、StringBuffer 的区别是什么⭐

在条件查询的时候，拼接SQL的字符串，拼接用的StringBuilder处理单线程效率更快。StringBuffer处理多线程更安全。

String	StringBuilder	StringBuffer
String的值是不可变的，这就导致每次对String的操作都会生成新的String对象，不仅效率低下，而且浪费大量优先的内存空间	可变类，速度更快	StringBuffer是可变类，和线程安全的字符串操作类，任何对它指向的字符串的操作都不会产生新的对象。每个StringBuffer对象都有一定的缓冲区容量，当字符串大小没有超过容量时，不会分配新的容量，当字符串大小超过容量时，会自动增加容量
不可变	可变	可变
	线程不安全	线程安全
	单线程操作字符串	多线程操作字符串安全

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-29V6vHlQ-1684947403202)(java基础面试.assets/70-16658388336833.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-J78FQpsA-1684947403202)(java基础面试.assets/70.png)]

String实际上就是一个被**final修饰（修饰后不可变)**的char数组，是不可变字符串。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QKvM6aTM-1684947403202)(java基础面试.assets/9f197af6d835b752be051bd915ce7a8e.png)]

StringBuilder 与 StringBuffer是可变的字符串。

我们操作少量的字符串的时候用String ，在单线程环境下操作大量数据时使用StringBuilder，在多线程操作大量数据使用StringBuffer。

数组

Java数组的特点

dataType[] arrayRefVar = {"java", "js"};
dataType[] arrayRefVar = new dataType[arraySize];
dataType arrayRefVar[] = new dataType[]{"java", "js"};

数组长度不可变，

数组只能存相同类型的值

不会出现数组越界情况，

Java数组和Js数组的区别

let str = ["java", "js"];
let str = new Array(2);
let str = new Array("java", "js");

js长度不固定，长度可变，不会出现越界问题，

数组类型不固定，比如第一个可以是数字，第二个可以是String，对标的是java中ArrayList集合。

JS数组本质上市一个对象键值映射（因此JS数组中的内存并不一定相邻）

获取数组长度(是属性，不带小括号)和获取字符串（是方法，带小括号）长度

获取数组长度和获取字符串长度.length

数组越界

数组下标最小值一定是0，下标最大值一定是长度-1，可以快速获取数组最后一项。

使用的下标不在这个范围内，则会产生数组越界，报ArrayIndexOutOfBoundsException异常。

数组求和⭐

for循环外边写一个容器，

冒泡排序

N个数字来排序

两两比较小靠前

外层循环n减1

内存循环再减i

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-OloUFXGT-1684947403203)(java基础面试.assets/aHR0cHM6Ly9pbWFnZXMyMDE3LmNuYmxvZ3MuY29tL2Jsb2cvODQ5NTg5LzIwMTcxMC84NDk1ODktMjAxNzEwMTUyMjMyMzg0NDktMjE0NjE2OTE5Ny5naWY.gif)]

package day01;
public class demo_sort {
    public static void main(String[] args) {
        //冒泡排序算法
        int[] numbers=new int[]{1,5,8,2,3,9,4};
        //需进行length-1次冒泡
        for(int i=0;i<numbers.length-1;i++)
        {
            for(int j=0;j<numbers.length-1-i;j++){
                if(numbers[j]>numbers[j+1]){//存放临时变量
                    int temp=numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(int i=0;i<numbers.length;i++)
            System.out.print(numbers[i]+" ");
    }
}

二分查找法

前提是有序的，要求线性表中的记录必须按关键码有序，并且必须采用顺序存储。

二分查找与顺序查找的比较。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kQQZhQcY-1684947403203)(java基础面试.assets/20210313090428873.gif)]

时间复杂度
二分查找最好时间复杂度是[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-da5jBSSP-1684947403204)(java基础面试.assets/gif-166584056356814.gif)]
最好情况下只需要进行1次比较就能找到目标元素
二分查找最坏时间复杂度是：
最坏情况就是查找不到目标元素，所需的时间复杂度可借助该序列的二叉树(二分查找判定树)形式进行分析：
序列[5, 10, 22, 29, 43, 57, 58, 61, 73, 77, 81]可以构建成下图所示的二叉树

具有n个结点的二分查找树的深度为[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-d4MMIr2g-1684947403204)(java基础面试.assets/rfloor+1.gif)]，因此，查找成功时，所进行的关键码比较次数至多为[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-435StpSU-1684947403204)(java基础面试.assets/rfloor+1.gif)]。而查找失败时和目标元素进行比较的次数最多也不超过树的深度，因此最坏时间复杂度是
二分查找平均时间复杂度是

	/**
	 * 使用递归的二分查找
	 *title:recursionBinarySearch
	 *@param arr 有序数组
	 *@param key 待查找关键字
	 *@return 找到的位置
	 */
	public static int recursionBinarySearch(int[] arr,int key,int low,int high){
		
		if(key < arr[low] || key > arr[high] || low > high){
			return -1;				
		}
		
		int middle = (low + high) / 2;			//初始中间位置
		if(arr[middle] > key){
			//比关键字大则关键字在左区域
			return recursionBinarySearch(arr, key, low, middle - 1);
		}else if(arr[middle] < key){
			//比关键字小则关键字在右区域
			return recursionBinarySearch(arr, key, middle + 1, high);
		}else {
			return middle;
		}	
		
	}

面向对象

什么是对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UHc6SfnJ-1684947403205)(java基础面试.assets/2487ed8f566043ed8a5cd3df202e9525.png)]

万物皆可对象——能够被特性和行为描述的

面向过程关注如何按照步骤执行
面向对象关心如何设计事物

都是解决问题的思维方式，都是代码组织的方式。

面向过程是一种“执行者思维，解决简单问题可以使用面向过程。
面向对象是一种“设计者思维"，解决复杂、需要协作的问题可以使用面向对象。

面向对象离不开面向过程：
宏观上：通过面向对象进行整体设计
微观上：执行和处理数据，仍然是面向过程。

什么是类

类是对象的抽象概念，有一组相同特征和行为的。

类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。
类是具有共同特征事物的抽象，对象则是类的实例化。

如果没有父类，默认是object类

抽象

抽象层级越高，特征越模糊。

访问修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SjYX9cPP-1684947403205)(java基础面试.assets/ab992b12ef5b16774376e00dab0415e0.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9CnNttpl-1684947403206)(java基础面试.assets/image-20221015214703304.png)]

default关键字和Java中的public、private等关键字一样，都属于修饰符关键字，可以用来修饰属性、方法以及类，但是default一般用来修饰接口中的方法。

https://blog.csdn.net/qq_33521184/article/details/125700363?ops_request_misc=&request_id=&biz_id=102&utm_term=java%E7%9A%84Default&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduweb~default-0-125700363.142

• 在switch语句的时候使用default
• 在定义接口的时候使用default来修饰具体的方法

类变量和类方法（static修饰的方法，也叫静态属性静态方法）

修饰方法，成为静态方法

修饰属性，成为静态属性

修饰代码块

静态方法(又叫类方法)和普通方法（又叫成员方法）的区别：

静态方法类名::方法名

实例化以后通过

静态方法(只能够使用静态属性)

普通方法必须实例化之后调用(能够使用普通属性和静态属性)

静态代码块作用

给类属性和类方法做初始化数据用的

构造方法

java必须要有构造方法，

方法名和类名必须一致，没有返回值，普通方法可以自定义

调用方式不同：

构造方法通过new关键字（构造方法的调用），表示String类的构造方法

普通方法调用对象名.方法名进行调用，

不写默认继承无参构造方法。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-MYdULeRK-1684947403206)(java基础面试.assets/image-20221015223726119.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oa0QfVcB-1684947403206)(java基础面试.assets/image-20221015224054911.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6v791SkP-1684947403207)(java基础面试.assets/image-20221015224317493.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EkCP26Yg-1684947403207)(java基础面试.assets/image-20221015224416393.png)]

构造方法改成私有的，就调用不到，这个类没办法实例化

类方法： 又叫做静态方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zHfgjUR2-1684947403208)(java基础面试.assets/image-20221015163932619.png)]

this关键字

作用：
1、解决同名问题，标识局部变量（调用方法存在，调用完毕消失）和this.成员变量（随着对象存在而存在）的区别。
2、调用本类的其他构造方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yvlhflRj-1684947403208)(java基础面试.assets/image-20221015223440838.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WvIn2B9A-1684947403208)(java基础面试.assets/image-20221015222410361.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6iCUw8f1-1684947403209)(java基础面试.assets/image-20221015222858336.png)]

JS中的this和Java中this区别？

js中的this表示的window窗口对象

super关键词

调用父类的构造方法 super ，如果子类没写，jdk会默认调用父类的无参构造方法。

如果让一个类不能被实例化的话，构造方法public改成私有private，

super关键字的用法如下：

• super可以用来引用直接父类的实例变量。

• super可以用来调用直接父类方法。

• super()可以用于调用直接父类构造函数。

• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zE0sVv69-1684947403209)(java基础面试.assets/20201101193908438.png)]

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VAqkaaKn-1684947403210)(java基础面试.assets/688a0275a4294dd69d457b22011cf16c.jpeg)]

https://blog.csdn.net/weixin_46946002/article/details/109446881

方法重写

2个类中，发生在继承关系中

子类重写父类的方法，

方法名必须相同

参数列表完全相同

返回值必须相同

访问修饰符 >= 父级被重写的那个修饰符

方法重写必须满足：

  1. 重载发生在**同一个类**中

  2. 子类**方法名**与父类名称完全相同

  3. 子类方法参数列表必须与父类**参数列表完全相同**

  4. 子类方法返回值必须和父类方法返回值相同或是父类方法返回值的子类

  5. 子类方法访问权限修饰符必须和父类方法访问权限修饰符相同或比父类访问权限修饰符范围更大。

不希望被重写？

final修饰（类（不能被继承）、方法（不能被重写）、变量（不能被重新赋值））（修饰后不可变）

那些类不能被final继承？

String类。相当于Javajdk中的char[]数组，是不可变的。

math类 向上取整，向下取整等，也是不能被继承的。

方法重载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PMqTmgRV-1684947403210)(java基础面试.assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0ODAxMTE2,size_16,color_FFFFFF,t_70.png)]

输出语句是重载的体现。

工具类。生成随机数，写了一个工具，getr，

比如给一个n数字，生成0-n的

给n-m的范围，就生成n-m的。给的参数不同，返回的结果也不一样。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-3qNBlK92-1684947403211)(java基础面试.assets/image-20221015171037030.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VuFccLaV-1684947403212)(java基础面试.assets/05b3f9b28ba54c0093ce0bdd9677bbc6-166582420733715.jpeg)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dYCDDlgm-1684947403213)(java基础面试.assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA==,size_16,color_FFFFFF,t_70.png)]

为什么需要一个常量？

因为它不可更改。

生活中的常量：Π，

例如：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T2pcMMiG-1684947403213)(java基础面试.assets/image-20221015171540073.png)]

初始化数据，数据加载，Java的核心机制

标识符 和 变量

（标识符是变量、函数、类、模块、其他对象的名称）

标识符：
规则：标识符可以是字母、下划线、美元符、数字的任意组合。
但不能是以数字开头，不能使用关键字，不建议使用中文，不能包含#这样的特殊字符。

使用规范：
表示类名的标识符：首字母大写。
表示方法和变量的标识符：驼峰命名法。第一个小写，第二个大写。

HTML用—隔开，建议全大写

隔开_

SQL建议大写，不区分大小写

CSS区分大小写，用—

类和对象的关系

类可以看成一类对象的模板，对象可以看成该类的一个具体实例。
类是用于描述同一类型的对象的一个抽象概念，类中定义了这一类对象所应具有的共同的属性、方法。
类是具有共同特征事物的抽象，对象则是类的实例化。

new关键字

有new就一定调用了构造方法

什么是面向对象

C面向过程

Java面向对象

面向对象特性

封装

为什么要引入封装性 ？

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉
低耦合：仅对外暴露少量的方法用于使用

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

属性私有化，提供一组公开的get+set方法供使用，保证数据的安全性。提高代码的复用性。

继承

子类通过extends关键字父类，子类拥有了除**私有以外和构造方法（super关键字实例化去继承）**的属性和方法，是单继承（一个类有仅有一个父类），继承具有传递性。

extends关键字

继承注意事项

• 子类只能继承父类所有非私有的成员(成员方法和成员变量)
  • 其实这也体现了继承的另一个弊端：打破了封装性
• 子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。
  • 不能通过小范围=new 大范围初始化对象

方法重写

super关键字

final关键字

继承时构造函数的注意事项

Object类

如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。是基类，

toString，改变输出内容，toString是隐式调用，

equal方法

多态

（花木兰替父从军，声明父类=new.子类，声明父类得到子类）

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

Java中的多态发生在继承关系或者接口实现中，

多态存在的必要条件：

1、要有继承;

2、要有重写;

3、父类引用指向子类对象。

声明父类变量，实现的子类对象

默认是向上转型（自动转型），声明父类=子类，引用指向过程，花木兰替父从军，

默认是向下转型（强制转型）

多态关系中，属性都是父类的属性(比如打仗属性，叫名字是父亲的名字属性)，方法都是子类的方法（是花木兰自己打，花木兰独有属性不能被使用，向下转型之后才能使用，即做回自己）。

在Java中有两种形式可以实现多态：继承（多个子类对同一方法的重写）和接口（实现接口并覆盖接口中同一方法）。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BF6ItjRI-1684947403214)(java基础面试.assets/image-20221017093905255.png)]

抽象类和接口

什么是抽象类

被abstract修饰的类称为抽象类，

抽象类中可以有抽象方法和普通方法

一个类中如果存在抽象方法，那么这个类一定是抽象类，抽象类中才可以写抽象方法，可以不被实现，不可以被实例化。

如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

抽象类必须被继承，如果一个类想让他一定被继承，就把它变成抽象类。

抽象类：

1. 抽象类和抽象方法必须用关键字abstract修饰
2. 抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
3. 子类只能继承一个抽象类。
4. 抽象类可以包含任意类型属性。
5. 抽象类可以有普通方法，静态方法，抽象方法，但是不能有default修饰的方法。
6. 抽象类可以有构造方法。抽象类不能实例化→不加 {}
7. 不可以创建对象

抽象方法

抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

https://blog.csdn.net/weixin_51517370/article/details/115264737?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166674971516782395372316%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=166674971516782395372316&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_positive~default-2-115264737-null-null.142

什么是接口

接口不是类，是被interface修饰的java文件称为接口。它是对行为的抽象。

接口中可以含有 变量和方法。但是要注意，接口中的变量会被隐式地指定为public static final变量（并且只能是public static final变量，用private修饰会报编译错误），而方法会被隐式地指定为public abstract方法且只能是public abstract方法。

特点：

多实现：实现类可以实现多个接口。

接口不能被实例化。接口不允许有构造方法。

default修饰的方法。

default关键字

• default修饰的目的 是 让接口可以拥有具体的方法，让接口内部包含了一些默认的方法实现。
• 被default修饰的方法是接口的默认方法。既只要实现该接口的类，都具有这么一个默认方法，默认方法也可以被重写。
• jdk1.8新特性

抽象类和接口的区别

• 语法层面的区别

  1. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的
  2. 一个类只能继承一个抽象类，而一个类却可以实现多个接口

• 设计层面的区别

  1. 抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。

     举例：飞机和鸟的案例。

     结论：继承是一个"是不是"的关系，而接口实现则是 "有没有"的关系

  2. 设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。

常用类

Date类

时间戳，1970-现在度过的毫秒数，newDate构造函数可以返回时间戳。

Math类

用过cell向上取整，floor向下取整，round四舍五入，math.random生成随机数范围含头不含尾(0-1)

//产生一个[0，1)之间的随机数。
Math.random()：

//返回指定范围的随机数(m-n之间)的公式:
Math.random()*(n-m)+m；
或者
{int}{Math.random()*(n-m+1)+m};

异常处理

什么是异常

Java异常机制可以使程序中异常处理代码和正常业务代码分离，保证程序代码更加优雅，并提高程序健壮性。

异常处理关键字

throw

throws

写在方法里

try（正常代码）-catch（不正常）

finally

不管是否异常，最终一定执行

final、finally和finalize的区别

一、final是什么？
1:final是一个修饰词也是一个关键字。

2:被final修饰的类是属于最终类无法被继承

3:对于一个final变量，如果是基本数据类型的变量，则其数值一旦初始化以后就不能被修改。如果是引用类型的变量，则对初始化之后便不能再让其指向另一个对象，但是他指向的对象里边的内容是可变的。

4：被final修饰的方法无法被重写，但是可以重载。

二、finally是什么
1：finally是一个关键字

2：finally在处理异常机制的提供finally方法来执行一切操作，不管有没有异常捕捉或者抛出，finally都会执行操作，通常用于释放资源，关闭资源的操作。

3：finally正常情况下都会别执行，但是有两个极端情况下不会被执行
如果对应的try方法快没有执行，则这个try方法快中的finally不会被执行
如果try方法中jvm关机，列入system.exit(n)，finally也不会执行(电源都扒了怎么执行)

4：finally中如果有return关键字，则会覆盖try和catch中的return关键字，会导致return覆盖无法return，所以不推荐在finally中写return关键字

三、finalize是什么
1:finalize:是Object中的protected方法，子类可以覆盖方法可以实现资源的清理工作。

2：GC在回收对象之前都会调用该方法

3：finalize()方法还是存在很多问题的
java语言规范并不保证finalize方法会被及时的执行，更根本不会保证他们一定会被执行。
finalize()方法可能带来性能问题。因为JVM通常在单独的低优先级线程中完成finalize的执行。
finalize()方法中，可将待回收对象复制给GC Roots 可达的对象引用，从而达到对象再生的目的
finalize方法最多由GC执行一次（但是可以手动的调对象的finalize方法）

总结
final：常量用于声明属性，方法和类，分别表示属性不可交变，方法不可覆盖，类不可继承。

finally：异常处理机构 异常处理语句结构的一部分，表示总是执行。

finalize是Object类的一个方法，供垃圾收集时的其他资源回收，等操作

try-catch-finally-return的执行顺序

https://blog.csdn.net/lcz1999923/article/details/117753950?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166676496816782425129038%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=166676496816782425129038&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_allsobaiduend~default-2-117753950-null-null.142

return是最后一行
1、不管有没有出现异常，finally块中代码都会执行；

2、当try和catch中有return时，finally仍然会执行；

3、finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；

4、finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

// 申请资源对象需要外置定义
try{
	//1. 申请资源和要执行的代码逻辑
}catch(IOException e){
	//2. 捕获到的异常
	e.printStackTrace();
}finally{
	//3. 关闭资源，无论如何在最后都会执行到的代码
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0hE961JI-1684947403214)(java基础面试.assets/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d1b3J1aV9qYXZh,size_16,color_FFFFFF,t_70.png)]

Error和Exception区别是什么？

错误（代码错误不能执行）和异常（可以捕获）

常见异常

NullPointerException - 空指针引用异常

ClassCastException - 类型强制转换异常

IndexOutOfBoundsException - 下标越界异常

NumberFormatException - 数字格式异常

SQLException - 操作数据库异常

IOException - 输入输出异常

泛型

什么是泛型

泛型是 JDK 5 中引入的一个新特性。

泛型的本质是参数化类型

使用泛型参数，可以增强代码的可读性以及稳定性。编译器可以对泛型参数进行检测，并且通过泛型参数可以指定传入的对象类型。

声明List<>，new的是ArrayList

大转小，自动转，丢失精度

小转大，强制转

泛型有几种方式

泛型类、泛型接口和泛型方法

项目中哪里用到了泛型

jdbc（6步） baseDIO

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lZEUjr8c-1684947403214)(java基础面试.assets/c7f67e4a87cd1527d1ea0d4389551d23.png)]

泛型通配符

通配符是用来解决泛型无法协变的问题。

一般用于声明方法形参，类之间继承关系并不适用于泛型。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XRmoErrL-1684947403215)(java基础面试.assets/image-20221026145210337.png)]

无界通配符

使用?表示无界通配符< ? >

接受任何泛型类型数据

1. List<?> ，Map<?,?>
2. List<?>是List、List等各种泛型List的父类

上界通配符和下界通配符

• 上界通配符< ? extends E>

  用 extends 关键字声明，表示参数化的类型可能是所指定的类型，或者是此类型的子类。

• 下界通配符< ? super E>

  用 super 进行声明，表示参数化的类型可能是所指定的类型，或者是此类型的父类型，直至 Object。

集合容器

什么是集合

用于存储数据的容器。

集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。

集合和数组的区别

• 数组是固定长度的；集合可变长度的。
• 数组.length属性。数组array.length返回的是该数组的长度。
• String的.length是方法。str.length()返回的是该字符串的长度。
• [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-72DGNCsk-1684947403215)(java基础面试.assets/1991278fdcef649efd26dae89b7542da.png)]
• 数组可以存储基本数据类型，也可以存储引用数据类型；集合只能存储引用数据类型。
• 数组存储的元素必须是同一个数据类型；集合存储的对象可以是不同数据类型。

常用的集合接口有哪些

Collection接口和Map接口是所有集合框架的父接口：

• Collection接口的子接口包括：List接口和Set接口
• Map接口的实现类主要有：HashMap、TreeMap、Hashtable、ConcurrentHashMap以及Properties等。Map m=new HashMap();
• Set接口的实现类主要有：HashSet、TreeSet、LinkedHashSet等
• List接口的实现类主要有：ArrayList、LinkedList、Stack以及Vector等

List、Set、Map三者的区别

Java 容器分为 Collection 和 Map 两大类。

collection的子接口包含Set、List、Queue三种。

• List：一个有序（元素存入集合的顺序和取出的顺序一致）容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 等。基于数组
• Set：一个无序（存入和取出顺序有可能不一致）容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。基于嘻哈表
• Map：一个键值对集合，存储键、值和之间的映射。 Key无序，唯一；value 不要求有序，允许重复。Map没有继承于Collection接口，从Map集合中检索元素时，只要给出键对象，就会返回对应的值对象。

Set和List的使用场景

• Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。无序不重复
• List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。有序可重复。
• List快速去重：List转Set再转LIst。

Collection 和 Collections 有什么区别？

• java.util.Collection 是一个集合接口（集合类的一个顶级接口）。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式，其直接继承接口有List与Set。
• Collections则是集合类的一个工具类/帮助类，其中提供了一系列静态方法，用于对集合中元素进行排序、搜索以及线程安全等各种操作。

统计每个字母出现的次数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sJ27qVq7-1684947403215)(java基础面试.assets/image-20221016160425168.png)]

如何实现 Array 和 List 之间的转换？

• Array 转 List： Arrays. asList(array) ；
• List 转 Array：List 的 toArray() 方法。
• 数组快速去重：数组转成List，List转Set再转LIst，再转数组。

Arraylist与 LinkedList 异同

• Arraylist 底层使用的是Object数组；LinkedList 底层使用的是双向循环链表数据结构；
• ArrayList 采用数组存储，所以插入和删除元素的时间复杂度受元素位置的影响.向末尾添加效率较高。
• LinkedList 采用链表存储，所以插入，删除元素时间复杂度不受元素位置的影响。
• LinkedList 不支持高效的随机元素访问，ArrayList可以通过下标方式快速访问。
• ArrayList随机访问快，插入慢；LinkedList随机访问慢，插入快。

https://blog.csdn.net/SS1773818087/article/details/109154099?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522166677266016782427430207%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=166677266016782427430207&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2_alltop_click~default-1-109154099-null-null.142

遍历List有哪些方式

for循环遍历（确定次数）

Iterator迭代器遍历

foreach 循环遍历（底层实现Iterator迭代器）

ps：迭代器和foreach只能做遍历，不能在遍历中删除或替换数据。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TboHjMMv-1684947403216)(java基础面试.assets/image-20221016160727164.png)]

没有下标，抛离下边进行遍历。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DwVYeETu-1684947403216)(java基础面试.assets/image-20221026170253568.png)]

三大循环

while循环（先判断在执行。不确定长度）、do - while循环（先执行一次，再判断）、for 循环（确定次数）

如何在for循环内清空集合

删除remove，

for循环反着遍历，。length.size-1，i–

如何在for循环内清空数组

数组清空不了，换成null，长度固定，

IO流

什么是流

Java 中流的定义是源中支持聚合操作的一系列元素。

流是一组有序的数据序列，将数据从一个地方带到另一个地方。根据数据流向的不同，可以分为输入（Input）流和输出（Output）流两种。

流的概念有点类似集合，但是又有着本质的区别，它们的概念是不同的。

电影可以看作一组字节。由于DVD包含整个数据元素，因此可以将其视为字节的集合。通过互联网观看电影时，可以将电影视为字节流。流式视频播放器只需要在用户观看的位置之前有几个字节即可。这样，视频播放器可以从流的开头开始显示电影，甚至无需计算流中的大多数数据。

什么IO

java中的IO是以流为基础进行数据的输入输出的，所有数据被串行化(所谓串行化就是数据要按顺序进行输入输出)写入输出流。简单来说就是java通过io流方式和外部设备进行交互。

BIO、NIO和AIO

• BIO：同步并阻塞,适用于连接数目比较小且固定的架构
• NIO：同步非阻塞,适用于连接数目多且连接比较短（轻操作）的架构
• AIO：异步非阻塞,适用于连接数目多且连接比较长（重操作）的架构

IO流的分类，上传图片用IO流。

按方向分

• 输入流（InputStream）：从文件读入到内存。只能进行读操作。
• 输出流（OuputStream）：从内存读出到文件。只能进行写操作。

按处理数据单位

• 字节流：以字节为单位，每次次读入或读出是8位数据。可以读任何类型数据，图片、文件、音乐视频等。频率高。
• 字符流：以字符为单位，每次读入或读出是16位数据。其只能读取字符类型数据

字节流和字符流的区别

字节流读取的时候，读到一个字节就返回一个字节；

字符流读到一个或多个字节时，先去查指定的编码表，将查到的字符返回。

字节流可以处理所有类型数据，如：图片，MP3，AVI视频文件，而字符流只能处理字符数据。

只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。

字节流和字符流转换

字节输入流转字符输入流通过 InputStreamReader 实现，该类的构造函数可以传入 InputStream 对象。

字节输出流转字符输出流通过 OutputStreamWriter 实现，该类的构造函数可以传入 OutputStream 对象。

什么是java序列化

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

如何实现java序列化

序列化的实现，将需要被序列化的类实现Serializable 接口，该接口没有需要实现的方法，implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：File Output Stream)来构造一个 Object Output Stream(对象流)对象，接着，使用 Object Output Stream 对象的 write Object(Object obj)方法就可以将参数为 obj 的对象写出(即保存其状态)，要恢复的话则用输入流。

BIO、NIO和AIO

• BIO：同步并阻塞,适用于连接数目比较小且固定的架构
• NIO：同步非阻塞,适用于连接数目多且连接比较短（轻操作）的架构
• AIO：异步非阻塞,适用于连接数目多且连接比较长（重操作）的架构

IO流的分类，上传图片用IO流。

按方向分

• 输入流（InputStream）：从文件读入到内存。只能进行读操作。
• 输出流（OuputStream）：从内存读出到文件。只能进行写操作。

按处理数据单位

• 字节流：以字节为单位，每次次读入或读出是8位数据。可以读任何类型数据，图片、文件、音乐视频等。频率高。
• 字符流：以字符为单位，每次读入或读出是16位数据。其只能读取字符类型数据

字节流和字符流的区别

字节流读取的时候，读到一个字节就返回一个字节；

字符流读到一个或多个字节时，先去查指定的编码表，将查到的字符返回。

字节流可以处理所有类型数据，如：图片，MP3，AVI视频文件，而字符流只能处理字符数据。

只要是处理纯文本数据，就要优先考虑使用字符流，除此之外都用字节流。

字节流和字符流转换

字节输入流转字符输入流通过 InputStreamReader 实现，该类的构造函数可以传入 InputStream 对象。

字节输出流转字符输出流通过 OutputStreamWriter 实现，该类的构造函数可以传入 OutputStream 对象。

什么是java序列化

序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间。序列化是为了解决在对对象流进行读写操作时所引发的问题。

如何实现java序列化

序列化的实现，将需要被序列化的类实现Serializable 接口，该接口没有需要实现的方法，implements Serializable 只是为了标注该对象是可被序列化的，然后使用一个输出流(如：File Output Stream)来构造一个 Object Output Stream(对象流)对象，接着，使用 Object Output Stream 对象的 write Object(Object obj)方法就可以将参数为 obj 的对象写出(即保存其状态)，要恢复的话则用输入流。