【Java基础2022复习，面试题，日刷必备，日后持续更新】

Java入门

1. java的特性和修饰:

跨平台/可移植性：java的int永远都是32位不像是C++可能是16或者32，移植还要考虑位数
安全性：
面向对象：面向对象是一种程序设计思想，java是面向对象的语言
简单：相对于c++等其他语言学起来简单
高性能：
分布式：java为了internet的分布式环境设计的，他能够处理tcp/ip协议，通过url访问一个资源像访问本地资源一样
多线程：java的多线程操作起来非常简单
健壮性：java是一种健壮性语言

1. java运行机制jdk/jre/jvm

java源文件(也就是.java文件)→java编译器(javac)→字节码(.class文件)→加载到jvm中
jdk包含jre，jre包含jvm
开发java程序需要安装jdk，如果只是运行java程序，只需要jre就行

2. 常见的dos命令

cd 进入一个目录
cd… 进入父目录
dir 查看本目录下的文件和子目录列表
cls 清空屏幕命令
上下键 获取敲过的命令
Tab键 自动补齐

变量、数据类型、运算符

3. 进制等就不做介绍了
4. 注释

单行注释：//
多行注释：/* /
文档注释：/* **/

5. 标识符和关键字

必须以字母、下划线、美元符号开头
其他可以是字母、下划线美元符号和数字的任意组合
大小写敏感，且长度无限制
不可以是java关键字
可以用中文命名变量，不建议用中文命名

6. 变量

变量的本质就是一个“可操作的存储空间”，存储空间位置是确定的，内容不确定(盒子里放什么都可以)
可以通过变量的名字访问变量里面的值
java是强语言，每一个变量都必须声明其数据类型

7. 变量的分类

     类型		           声明位置	                从属于       声明周期(作用域)  
局部变量 	          方法或者语法块内部            方法/语法块  	从声明位置开始直到方法或语句执行完毕，局部变量消失
成员变量(实例变量)       类内部，方法外部              对象           对象创建成员变量也跟着创建对象消失成员变量也跟着消失
静态变量(类变量)         类内部，static修饰           类             类被加载，静态变量就有效；类被卸载，静态变量消失

8. 常量

用finally修饰来定义常量

9. 基本数据类型：
   

控制语句、方法、递归算法

1.控制语句

将语句组合成能完成一定功能的小逻辑代码。分为三类：顺序、循环、选择
顺序也就是先a,后b
循环：一直打电话，直到打通
选择：别人给我打电话，接或者不接
这里也就是switch语句和if语句 while语句，for语句
break是跳出循环
continue用于结束本次循环，继续下一次

2.方法

方法：一段用来完成特定功能的代码片段
方法的详细说明：
形式参数：用于方法定义接受传入的参数
实参：调用方法时实际传给方法的数据
返回值：执行完毕后，返还给调用它的环境的数据
返回值的类型：事先约定的返回值的数据类型，无返回值的话就是void
方法的重载：方法名称相同，形参不同的方法

3.递归

定义递归头：递归结束的标志。也就是什么时候不调用递归，如果没有头，将陷入死循环。
递归体：就是递归的内容。需要考虑什么时候调用自己的方法
递归的缺点。会占用大量系统堆栈，内存耗用多，在递归调用层次多时候要比循环慢

面向对象详解和JVM底层内存分析

1.表格结构和类结构

生活中有很多这样的表格。java中的对象对应的每一个行
每一列对应java对象中的属性。
生活中还有很多例子，汽车，飞机，房子，人。都可以转成对象

2.jvm虚拟机内存模型

3.java虚拟机内存可以分为三个区域：栈stack、堆heap、方法区method area

虚拟机栈的特点：

栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等）
JVM为每个线程创建一个栈，用于存放该线程执行的方法信息（实际参数、局部变量等）
栈属于线程私有，不能实现线程间共享。
栈存储特性是“先进后出，后进先出”
栈由系统自动分配，速度快！栈是一个连续的内存空间！

堆的特点如下：

堆是用来存储创建好的对象和数组（数组也是对象）
jvm只有一个堆，所有线程共享一个堆
堆是一个不连续的内存空间，灵活分配，速度慢
堆被所有线程共享，在堆上的区域，会被垃圾回收器做进一步划分，例如：新生代、老年代、

方法区(也是堆)：

方法区是java虚拟机规范，有不同的实现（jdk7之前是永久代； jdk7部分去除永久代，静态变量、字符串常量池加入到堆内存中；jdk8是“元数据空间”和堆结合起来）
jvm只有一个方法区，被所有线程公用
方法区实际上也是堆，只是用于存储常量和类等信息！
用来存放程序中永远是不变或唯一内容。
常量池主要放常量

4.垃圾回收原理和算法：
java的内存管理很大程度就是：堆中对象管理，其中包括对象空间的分配和释放
对象空间的分配：使用new关键字创建对象即可
对象空间的释放：将对象赋值为null即可。
垃圾回收相关算法：
1.引用计数器：堆中对象都对应一个引用计数器，当有引用指向这个对象时，这个计数器+1，当失去引用就-1，如果该对象的引用为0.则java认为这个对象是无用对象并对其进行回收。算法简单，缺点：循环引用的对象无法试别
2.引用可达法
程序把所有的引用关系看作是图，从一个gc 根开始，继续寻找这个节点引用节点，当所有的 引用节点寻找完毕后，剩余的节点则被认为是没有被引用的节点，即无用节点
通用的垃圾回收机制：
分代垃圾回收机制，基于一个事实：不同对象的生命周期不一样的。因此不同生命周期的对象可以采取不同的回收算法，以便提高回收率。我们将对象分为三种状态：年轻代、老年代、永久代。将处于不同状态的对象放在不同的区域。

Eden区：存储了从未通过垃圾回收的新对象
Survivor区：存放垃圾回收后，仍然有用的对象，循环存放，小于15次垃圾回收次数
Tenured区：年老代区域存放超过15次垃圾回收的对象

新生代：
	所有新生成的对象首先都会放在Eden区。年轻代的目标尽可能快速的收集掉那些生命周期短的对象，
对应的是minor GC，每次Minor GC会清理年轻代内存，算法采用这种效率较高的复制算法，频繁的操作，
但是会浪费内存空间。当‘年轻代’区域存放满对象后，会将对象存放在老年代区

年老代：
	在年轻代中经历了N次垃圾回收后仍然存活的对象，就会存活在老年代中。因此老年代存放的大多数
都是一些生命周期较长的对象。年老代对象越来越多，我们就需要启动MajorGc和Full GC来一次大扫除，
全面清理年轻代区域和老年代区域。

永久代：
	用来存放静态文件，如java类，方法等，持久代对垃圾回收没有显著影响，jdk7以前就是方法区的
一种实现，jdk8以后采用了metspace元数据空间和堆代替	

Minor Gc ：用来清理年轻代的区域
Major GC：用于清理老年代区域
Full Gc：用于清理年轻代，年老代区域。成本价格高，会对系统性能产生影响

1.JVM调优和Full GC

在对JVM调优过程中，很大一部分工作就是对于fullGC的调节，如下原因导致FullGc
年老代被写满
永久代被写满
system.gc()被显示调用
上一次Gc之后Heap的各域分配策略动态变化

2.内存溢出

创建大量无用对象
静态集合类的使用
各种链接（Io流，数据库链接对象，网络链接对象）未关闭
监听器的使用不当

3.This关键字

普通方法中,this总是指向调用该方法的对象
构造方法中，this总是指向正要初始化对象
this()调用重载的构造方法，避免相同初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句
this不能用于static中
this是作为普通方法中“隐士参数”，由系统传入到方法中

4.static关键字

为该类的公共变量，属于类。被该类所有的实例共享，在类载入时初始化
static变量只有一份
一般“类名，类变量/方法”来调用
在static方法 不可以直接访问非static的成员

5.静态初始化块

构造方法用于对象的普通属性初始化
静态初始化块，用于类的初始化操作，初始化静态属性，
在静态初始化块中不能直接访问非static成员

6.变量类型

  类型     生明位置           从属于  			生命周期（作用域）
局部变量	方法或语句内部	  方法/语句块		从生命开始，到方法或语句块结束
成员变量	类内部方法外部  	      对象		对象创建，成员变量也跟着创建，对象消失也消失
静态变量	类内部static修饰        类		类被加载，静态变量就有效了

7.继承

extends
继承有两个作用：代码复用，更加实现类的扩展，方便建模
instanceof 是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象
时，返回 true；否则，返回 false。
java中是单继承，接口可以多实现
一个类没有调用extends，则他的父类是object

8.方法的重写

子类重写父类方法，用自身行为替换父类行为。
"=="形参和方法名要相同
“<=”返回值类型和声明异常类型，子类小于父类
">="返回权限，子类大于等于父类

9.final关键字

修饰变量：被修饰的变量不可改变。一旦赋值了，不可以改变。
修饰方法：不可以被重写，可以重载
修饰类：不可以继承。如String，Math类

10.组合

核心“将父类对象作为子类的属性”。其实我的理解就是在一个类里面创建其他类的对象，然后调用该类也就可以调用创建的类了。

11.==和equals方法比较

==是比较双方是否相同。如果是引用对象，比较地址。基本类型比较的是值
equals提供定义“对象内容相等”。默认是比较hashcode。可以根据自己想要的重写equals方法

12.super关键字

可以通过super关键字获取到被子类覆盖的父类方法或属性
使用super调用普通方法，语句没有位置限制，可以在子类中随便调用
super()含以上是调用父类的无参构造

13.构造方法的执行顺序

构造方法第一句总是：super()来调用父类对应的构造方法，流程是：先向上追溯到Object，然后在依次向下执行类初始化和构造方法，直到子类为止

14.编程中封装的具体优点

提高代码的安全性
提高代码的复用性
“高内聚“封装细节，便于修改内部代码，提高可维护性
”低耦合“：简化外部调用，便于调用者使用，便于扩展和协作。

15.封装的实现-使用访问控制符
java4种访问控制符，分别为：private、default、protected、public

public → 全局友好
protected → 父子友好，包内友好
default → 包内友好
private → 类内友好

protected两个细节

1. 若父类和子类在同一个包中，子类可访问父类的 protected 成员，也可访问父类对象的protected成员。
2. 若子类和父类不在同一个包中，子类可访问父类的 protected 成员，不能访问父类对象的 protected 成员。

16.多态的要点

多态是方法的多态不是属性的多态
多态的存在要有三个必要条件：继承，方法重写，父类引用指向子类对象
父类引用指向子类对象，用该父类引用调用子类重写的方法，此时多态就出现了

17.对象的转型

1.父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转型
2.向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型

18.抽象方法

1.使用abstract修饰的方法，没有方法体，只是声明
2.定义的是一种规范，就是高诉子类必须对其实现

19.抽象类

包含抽象方法的类，叫抽象类
通过抽象类，我们可以严格限制子类的设计，使子类更加通用

20.抽象类使用的要点

有抽象方法的类只能定义成抽象类
抽象类不能实例化，即不能用new来实例化抽象类
抽象类可以包含属性、方法、构造方法。但是构造方法不能通过new实例化，只能用来子类调用
抽象类只能用来被继承
抽象方法必须被子类实现

21.接口

子类通过implements来实现接口中的规范。
接口不能创建实例，但可以用于声明引用变量类型
一个类实现了接口，必须实现接口中的所有抽象方法
jdk1.8 之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法
jdk1.8之后，接口中包含普通的静态方法，默认方法（default关键字实现）

常量池分类：全局字符串常量池，class文件常量池，运行时常量池。

String中的方法

charAt（index） 返回字符串中第index个字符
equals（other） 字符串和other比较，相同返回true，不同false
equalslgnoreCase(other) 忽略大小写两个字符串比较大小
indexOf(str) 返回从开头查找第一个字符串str在索引出现的位置
lastIndexOf(str) 就是倒着查找str出现的位置
length 返回串的长度
replace(char oldchar，new newChar) 用newchar替换oldchar
startsWith(prefix) 字符串如果以prefix开头返回true
endsWith(prefix) 是否以prefix结尾
substring 从原始的串到串尾

22.内部类
内部类分为：成员内部类、匿名内部类、局部内部类
成员内部类包括：静态内部类、非静态内部类

内部类两个要点：
内部类提供了更好的封装。只能让外部类直接访问、不允许同一个包中其他类直接访问
内部类可以直接外部类的私有属性、内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性

23.非静态内部类

非静态内部类对象必须寄存在一个外部类对象里，因此，如果有一个非静态内部类对象，那么一定存对应的外部类对象，非静态内部类对象单独属于外部类的某个对象
非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员
非静态内部类不能有静态方法、静态属性和静态初始化
成员变量访问要点：1.内部类属性：this.变量名。外部类属性：外部类名.this.变量名

24.静态内部类

1.静态内部类可以直接访问外部的静态成员，不能访问外部的普通成园
2.静态内部类看作外部类的一个静态成员

25.匿名内部类

使用那种只需要使用一次的类，如键盘监听
匿名内部类没有访问修饰符
匿名内部类没有构造方法

数组和数据存储

数组也是对象
数组：相同类型数据的有序集合。每一个数据称为元素，每个元素通过下标访问他们
数组的特点

1.长度是确定的。一旦创建，大小不可以修改
2.元素类型是相同类型，不允许出现混合类型
3.数组类型可以是任何数据类型，包括基本类型和引用类型
4.数组变量属于引用变量，数组也是对象，数组内的元素，数组中的元素相当于对象的属性。

数组创建需要注意的事项：

1.声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时候与长度无关
2.声明一个数组的时候，并没有数组真正被创建
3.构造一个数组，必须指定长度

数组初始化总共有三个：静态初始化，动态初始化，默认初始化
静态初始化：就是直接定义出来内容是什么，根据数组的内容定义自定义长度
动态初始化：是自定义长度，内容根据后续然后在增加
默认初始化：比如int类型的数组，没给具体值，默认值为o，同理boolean默认值为false，string默认值是mull。

数组常见的操作：拷贝，遍历

遍历：

for(int i=0;i<a.length;i++){
System.out.println(a[i]);
}

for (String temp : ss) {
System.out.println(temp);
}

拷贝：

System.arraycopy(Object src,int srcpos, object dest, int destpos,int length)
该方法时将src数组内的值赋给dest数组中的元素，其中srcpos指定从src第几个元素开始，length指多少个元素赋值

对于数组还有对应的包

java.util.Arrays类包含了：排序、查找、填充、打印内容等常见的数组操作。

一维数组：相当于可以定义长度的盒子
多维数组：可以看成以数组为元素的数组.(二维，三维，甚至多维)。学过线性代数的可以联想到一起

comparable接口：用来比较接口