2023.2.18刷题

1、java的4类流程控制语句

解析：

java的4类流程控制语句

1. 循环语句：while，for，do while

2. 选择语句（分支语句）：if,switch

3. 跳转语句：break,continue,break,label

4. 异常处理语句：try catch finally，throw

2、类的加载过程

解析：

B、对象成员，实例化对象后才有的内容，已经完成类的加载过程了。类加载是对针对的类变量，而不是对象成员。

3、线程安全的map

解析：

线程安全的map:HashTable,SynchronizedMap,ConcurrentHashMap

解析：

4、String、StringBuilder和StringBuffer

4.1StringBuffer类和String类

解析：

1. String类对象一旦成立，便不能被改变，底层是数组，是final修饰的，所以不可变。

2. StringBuffer类对象成立后，依然可以被修改

4.2String、StringBuilder和StringBuffer 比较

速度：string< stringbuffer <stringbuilder

线程安全：

String对象是不可变的，可以理解为常量，所以是线程安全的

StringBuffer对方法加了同步锁或者对被调用的方法加了同步锁，所以是线程安全的

StringBuilder没有对方法加同步锁，所以是非线程安全的

可变不可变 ：

String用final修饰，所以string对象是不可变的

StringBuffer和StringBuilder都是继承AbstratStringBuilder，在AbstratStringBuilder中是使用字符串数组保存字符串，由此可知这两种对象是可变的

5、spring的事务传播特性

解析：

事务属性的种类：

1. 传播行为（PROPERGATION）：事务开启和事务结束（包括回滚和提交）

回滚：在事务提交之前将数据库数据恢复到事务修改之前数据库数据状态。

2. 隔离级别：

3. 只读：

4. 事务超时：

https://www.nowcoder.com/questionTerminal/1c65d30e47fb4f59a5e5af728218cac4

6、正则表达式

2023.2.19刷题

1、多态、匿名内部类、覆盖方法重写

解析：

匿名内部类：形式

形式：

例子：

Swimming s2 = new Swimming()

该代码是表示创建内部类对象，用于下面go方法，并重写了swim方法。

解析：

2、java解释器自动引入包

3、abstract、static、final、public关键字的使用

3.1关键字的使用

详细的解释：

1.抽象方法只能定义在抽象类中，抽象方法和抽象类必须由abstract修饰，abstract关键字只能描述类和方法，不能描述变量。抽象方法只定义方法声明，不定义方法实现。抽象类不可以被实例化（创建对象），只有通过子类继承抽象类并覆盖抽象类中的所有抽象方法后，该子类才可以被实例化，否则该子类还是一个抽象类。抽象类中有构造函数用于给子类对象进行初始化，同时抽象类中可以含有非抽象方法。abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。

2.static用于修饰成员变量和成员函数，想要实现对象中的共性数据的对象共享，可以将这个数据进行静态修饰，被静态修饰的成员可以直接被类名调用，静态随着类的加载而加载，而且优先于对象存在。静态方法只能访问静态成员（静态方法和静态变量），不可以访问非静态成员，这是因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。静态方法中不能使用this和super关键字，因为this代表本类对象，super代表父类对象，而静态时，有可能没有对象存在，所以this和super无法使用。

3.final关键字可以修饰类，方法，变量（成员变量内，局部变量，静态变量），被final修饰的类是一个最终类，不可以被继承，被final修饰的方法是一个最终方法，不可以被覆盖，但是可以被继承。被final修饰的变量只能是一个常量，只能赋值一次。内部类被定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。

https://www.nowcoder.com/questionTerminal/fb463f20d1cc44e3b4476e5d5319e7e9

3.2访问内部类的四种访问权限

private、protected、public以及默认的访问权限

4、类的线程安全

5、多态深度了解

5.1“编译看左，运行看右”

解析：

1、A是父类，B是子类继承了A类。

A a = new B();

该代码：父类引用指向子类对象（向上转型）（实则是向上转型，子类的实例对象->指向父类的引用）

编译看=的左侧，即父类的方法，运行看=右侧，即子类的方法，对父类的中相同的方法名进行了重写。

2、多态满足的条件：1.继承 2.重写 3.父类引用指向子类对象

3、成员变量，静态方法看左边；非静态方法：编译看左边，运行看右边,

参考复习链接：

https://blog.csdn.net/Fighting1021/article/details/119940351?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167679376116800188512455%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=167679376116800188512455&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~baidu_landing_v2~default-2-119940351-null-null.142^v73^wechat_v2,201^v4^add_ask,239^v2^insert_chatgpt&utm_term=%E7%BC%96%E8%AF%91%E7%9C%8B%E5%B7%A6%E8%BE%B9%E8%BF%90%E8%A1%8C%E7%9C%8B%E5%8F%B3%E8%BE%B9&spm=1018.2226.3001.4187

5.2多态实现的两种方法

Java通过方法重写和方法重载实现多态

方法重写（覆盖）是指子类重写了父类的同名方法

方法重载是指在同一个类中，方法的名字相同，但是参数列表不同

6、RMI采用什么通讯协议

RMI(Remote Method Invocation)远程方法调用是一种计算机之间利用远程对象互相调用实现双方通讯的一种通讯机制。使用这种机制，某一台计算机上的对象可以调用另外一台计算机上的对象来获取远程数据。RMI是Enterprise JavaBeans的支柱，是建立分布式Java应用程序的方便途径。在过去，TCP/IP套接字通讯是远程通讯的主要手段，但此开发方式没有使用面向对象的方式实现开发，在开发一个如此的通讯机制时往往令程序员感觉到乏味，对此RPC(Remote Procedure Call）远程过程调用协议应运而生，它使程序员更容易地调用远程程序，但在面对复杂的信息传讯时，RPC依然未能很好的支持，而且RPC未能做到面向对象调用的开发模式。针对RPC服务遗留的问题，RMI出现在世人面前，它被设计成一种面向对象的通讯方式，允许程序员使用远程对象来实现通信，并且支持多线程的服务，这是一次远程通讯的***，为远程通信开辟新的里程碑。 RMI的开发步骤

1、先创建远程接口及声明远程方法，注意这是实现双方通讯的接口，需要继承Remote 开发一个类来实现远程接口及远程方法，

2、值得注意的是实现类需要继承UnicastRemoteObject 通过javac命令编译文件，

3、通过java -server 命令注册服务，

4、启动远程对象

5、最后客户端查找远程对象，并调用远程方法 所以选C

7、Java基本类型

基本数据类型：八个

引用数据类型：

对象变量类型，复合数据类型，包含类、接口、数组（除了基本类型外，就是引用类型）。

8、对象实例化

解析：

抽象类和接口都不能实例化。

9、关键字

解析：

10、抛InterruptedException的代表方法

解析：

11、private,default,protected,public修饰符的区别

解析：

更多的部分参考 本部分的3、abstract、static、final、public关键字的使用。

注：default和friendly是相同的效果，default被称为缺省，即没有任何修饰。例如：

void m2（）    //该void的前面实际上是缺省了default

同题型：

解析：

public和protected都可以作用于子类，但在多态情况下，静态函数调用时编译和运行看左边，所以子父类存在同名静态函数访问的是父类，子类并不能覆盖父类的方法，所以选C

https://www.nowcoder.com/questionTerminal/e6aa308ad0ff422eb3b9eaf018565593

12、标识符（变量的规则）

解析：

标识符：

1. 数字，字母，符号（只有_和$两种），数字不能开头。

2. 不能是关键字（有两个保留关键字，goto，const，关键字都是小写的）或者显式常量（null，true，false）。

13、Java语言的特点

1、Java致力于检查程序在编译和运行时的错误。

2、Java虚拟机实现了跨平台接口

3、类型检查帮助检查出许多开发早期出现的错误。

4、Java自己操纵内存减少了内存出错的可能性。

5、Java还实现了真数组，避免了覆盖数据的可能。

14、抽象类和最终类

14.1抽象类和最终类

抽象类：

1. 抽象类是用来继承的，抽象类中的所有方法在子类中需要重写，否则该子类需要声明为抽象类

2. 抽象类中可以有抽象方法，也可以没有抽象方法。

3. 抽象类中的抽象方法没有方法体。

最终类（final类）：

1. 最终类不能被继承，即没有子类，最终方法也就不能被重写。

2. 最终类中可以有最终方法也可以没有。

14.2抽象类和接口

抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。

接口：是一种特殊的抽象类，接口中的方法全部是抽象方法（但其前的abstract可以省略），所以抽象类中的抽象方法不能用的访问修饰符这里也不能用。因为接口可以让所有的类去实现（非继承），不只是其子类，但是要用public去修饰。接口可以去继承一个已有的接口。即是个规范，所有的类都能实现它。

https://www.nowcoder.com/questionTerminal/3e2b6a4b06c84c08811f7c085dc1619c

15、JVM内存

15.1JVM内存之线程共享和非线程共享

解析：

方法区在JVM中也是一个非常重要的区域，它与堆一样，是被 线程共享 的区域。 在方法区中，存储了每个类的信息（包括类的名称、方法信息、字段信息）、静态变量、常量以及编译器编译后的代码等。

拓展：

概括地说来，JVM初始运行的时候都会分配好 Method Area（方法区） 和Heap（堆） ，而JVM 每遇到一个线程，就为其分配一个 Program Counter Register（程序计数器） , VM Stack（虚拟机栈）和Native Method Stack （本地方法栈）， 当线程终止时，三者（虚拟机栈，本地方法栈和程序计数器）所占用的内存空间也会被释放掉。这也是为什么我把内存区域分为线程共享和非线程共享的原因，非线程共享的那三个区域的生命周期与所属线程相同，而线程共享的区域与JAVA程序运行的生命周期相同，所以这也是系统垃圾回收的场所只发生在线程共享的区域（实际上对大部分虚拟机来说知发生在Heap上）的原因。

线程共享：方法区、堆

非线程共享：程序计数器、虚拟栈、本地地方栈

15.2JVM内存之堆

1. 堆被划分成两个不同的区域：新生代 ( Young )、老年代 ( Old )。

2. 新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。

3. Java中堆内存分为两部分，permantspace（持久区）和heap space。

4. permantspace（持久区）主要存放的是Java类定义信息，与垃圾收集器要收集的Java对象关系不大。持久代溢出通常由于持久代设置过小，动态加载了大量Java类。

5. 老年代常见的内存溢出原因有循环上万次的字符串处理、在一段代码内申请上百M甚至上G的内存和创建成千上万的对象。

6. 年轻代的垃圾回收叫 Young GC， 年老代的垃圾回收叫 Full GC。

16、线程的描述

1、线程的调度是抢先式，即根据线程的优先级来决定哪一个线程先运行。

2、不同优先级的线程间是抢先式的，而同级线程间是轮换式的。

3、一个新创建的线程并不是自动的开始运行的，必须调用它的start()方法使之将线程放入可运行态(runnable state)，这只是意味着该线程可被JVM的线程调度程序调度而不是意味着它可以立即运行。

4、一个线程停止运行的原因：

可能是因为更高优先级线程的抢占，也可能是因为调用sleep()方法。

17、类之间的几种常见关系

解析：

USES-A：依赖关系，A类会用到B类，这种关系具有偶然性，临时性。但B类的变化会影响A类。这种在代码中的体现为：A类方法中的参数包含了B类。

关联关系：A类会用到B类，这是一种强依赖关系，是长期的并非偶然。在代码中的表现为：A类的成员变量中含有B类。

HAS-A：组合关系，拥有关系，是关联关系的一种特例，是整体和部分的关系。比如鸟群和鸟的关系是组合关系，鸟群中每个部分都是鸟。

IS-A：表示继承。父类与子类，这个就不解释了。

要注意：还有一种关系：组合关系也是关联关系的一种特例，它体现一种contains-a的关系，这种关系比聚合更强，也称为强聚合。它同样体现整体与部分的关系，但这种整体和部分是不可分割的。

18、equals方法（包含Integer和int）

18.1equals方法

equals方法是String类型重写的方法，首先能够判断参数是不是String类型。

==表示两者的地址是否相同

equals方法是检查啷个字符串的内容是否相同。注意大小写。

equalsIgnoreCase方法是需要检查字符串内容是否相同，并且忽略大小写比较。

18.2 int和Integer两者内容的比较。

Integer的内部数据是-128-127。在这个范围内的数据，Integer进行拆箱后再和int的数据内容进行比较。

int：默认值为0、基本数据类型

Integer：默认值为null、是int包装类，表示对象。

18.3数组的比较和数组的遍历

1、.equals()比较的是两个数组的地址，相当于==的作用

2、如果是遍历数组中的元素，进行一一比较，应该选择Arrays.equals()

19、Java程序初始化顺序（父类子类静态代码块、普通代码块、构造方法）

解析：

关于Java程序初始化顺序：

1. 父类的静态代码块

2. 子类的静态代码块

3. 父类的普通代码块

4. 父类的构造方法

5. 子类的普通代码块

6. 子类的构造方法

2023.2.20刷题

1、关键字synchronized和volatile

synchronized: 具有原子性，有序性和可见性；

volatile：具有有序性和可见性

原子性：一个操作是不可中断的，要么全部执行成功要么全部执行失败，有着“同生共死”的感觉。

可见性：一个线程修改了共享变量的值，其他线程也能够立即得知这个通知。

有序性：如果在被线程内观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所有操作都是无序的。

2、socket（服务端）和ServerSocket（客户端）

1. ServerSocket(int port) 是服务端绑定port端口，调accept()监听等待客户端连接，它返回一个连接队列中的一个socket。

2. Socket(InetAddress address ,int port)是创建客户端连接主机的socket流，其中InetAddress是用来记录主机的类，port指定端口。

socket和servletSocket的交互如下图所示：

3、单例模式（饿汉单例模式、懒汉单例模式）

单例模式的形式：只有一个实例，即只能创建一个对象

懒汉单例模式：

步骤一：不让外部调用创建对象，所以把构造器私有化，用private修饰。

步骤二：怎么让外部获取本类的实例对象？通过本类提供一个方法，供外部调用获取实例。由于没有对象调用，所以此方法为类方法，用static修饰。

在主函数调用时是：类.方法名。（由于使用的是static修饰）

步骤三：通过方法返回实例对象，由于类方法(静态方法)只能调用静态方法，所以存放该实例的变量改为类变量，用static修饰。

步骤四：最后，类变量，类方法是在类加载时初始化的，只加载一次。所以由于外部不能创建对象，而且本来实例只在类加载时创建一次，

4、Collection接口

总结：

1. 继承Colletion接口的有结尾是Set、List的以及Vector、Stack

2. 继承Map接口的有结尾Map和HashTable

5、java的垃圾回收机制

5.1java垃圾回收机制

解析：

垃圾回收主要针对的是堆区的回收，因为栈区的内存是随着线程而释放的。堆区分为三个区：年轻代（Young Generation）、年老代（Old Generation）、永久代（Permanent Generation，也就是方法区）。

年轻代：对象被创建时（new）的对象通常被放在Young（除了一些占据内存比较大的对象）,经过一定的Minor GC（针对年轻代的内存回收）还活着的对象会被移动到年老代（一些具体的移动细节省略）。

年老代：就是上述年轻代移动过来的和一些比较大的对象。Minor GC(FullGC)是针对年老代的回收

永久代：存储的是final常量，static变量，常量池。

str3,str4都是直接new的对象，而substring的源代码其实也是new一个string对象返回，如下图：

经过fullgc之后，年老区的内存回收，则年轻区的占了15个，不算PermGen。

5.2GC（Garbage Collection）

garbage collection 垃圾回收，将没有引用的对象进行垃及回收，回收前调用finalize()方法，下一个周期进行回收

6、Static的叫法（类方法、类变量）

解析：

类方法：类的静态方法，调用方法是 类名.方法名();

类变量：静态变量

---

对象变量：实例变量

实例变量需要new对象后static才能调用

7、queue（LinkedBlockingQueue和PriorityQueue）

LinkedBlockingQueue是一个基于节点链接的可选是否有界的阻塞队列，不允许null值。

LinkedBlockingQueue是一个线程安全的阻塞队列，实现了先进先出等特性。

PriorityQueue是一个无界队列，不允许null值，入队和出队的时间复杂度是O（log(n)）。

PriorityQueue是不同于先进先出队列的另一种队列。每次从队列中取出的是具有最高优先权的元素。ConcurrentLinkedQueue是一个基于链接节点的无界线程安全队列，该队列的元素遵循FIFO原则。

8、>>、>>>、<<操作符

>>（右移）、<<（左移）都是算术操作符，因为都是包含符号位

>>>(右移)是逻辑操作符，没有“<<<”

最大的区别：

>> 最高位填充符号位

>>> 最高位补0

例子：

• 逻辑右移时，最高位补0，最低位丢失；

• 算术左移时，依次左移一位，尾部补0，最高的符号位保持不变。

• 算术右移时，依次右移一位，尾部丢失，符号位右移后，原位置上复制一个符号位；

• 循环左移时，将最高位重新放置最低位

• 循环右移时，将最低位重新放置最高位

例如：

• 1010100010101

• 逻辑右移一位结果为 0101010001010

• 算术左移一位结果为 1101000101010

• 算术右移一位结果为 1101010001010

• 循环左移一位结果为 0101000101011

• 循环右移一位结果为 1101010001010

https://www.nowcoder.com/questionTerminal/bc1b22b2af5c47f89caca1d4f77b8807

9、关于Java操作的内容

java,exe是java虚拟机

javadoc.exe用来制作java文档

jdb.exe是java的调试器

javaprof,exe是剖析工具

10、关于序列化

解析：序列化保存的是对象的状态，静态变量属于类的状态。

Java在序列化时不会实例化static变量和transient修饰的变量，因为static代表类的成员，transient代表对象的临时数据，被声明这两种类型的数据成员不能被序列化。

①实例化：是把类创建为对象的过程。格式一般为:｛类名 对象名 = new 类名（参数1，参数2...参数n）构成｝，也就是new对象。

②序列化：将对象的状态信息转换为可以存储或传输的形式的过程(对象转化为字节序列的过程)。序列化期间，对象将其当前状态写入到临时或持久性存储区。

③反序列化:把字节序列恢复为对象的过程称为对象的反序列化。

对象的状态：

https://blog.csdn.net/weixin_30368405/article/details/114041656?ops_request_misc=&request_id=&biz_id=102&utm_term=Java%E4%B8%AD%E5%AF%B9%E8%B1%A1%E7%8A%B6%E6%80%81%E6%98%AF%E4%BB%80%E4%B9%88&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-0-114041656.142^v73^wechat_v2,201^v4^add_ask,239^v2^insert_chatgpt&spm=1018.2226.3001.4187

2023.2.21刷题

1、基本运算

解析：

+号两边如果有一边为字符类型 则为字符串连接

如果变为y+z+x 则等价于(y+z)+x 输出47

当String对象进行"+"操作，编译时会将String类变为String Builder进行append()处理，而append()方法的功能就是字符串拼接

2、list有关知识点

2.1list、set和map的区别

列表（List）的元素是有 序、可重复 的；

集合（Set）的元素是无序、不可重复的。

map 使用的是键值对存放，可一对多，key不重复，value可重复

2.2list的API应用

解析：

https://www.nowcoder.com/questionTerminal/bc4e7f7d04a249e9adda0deb4dfc8359

3、控制台界面接收用户键盘输入，导入的包

解析:

1）必须要导入java.io包，不管是控制台（图形界面）还是字符界面（命令行）输入，都需要使用 InputStream 方法。

2）控制台输入需要使用 System.in，其实System.in 就是返回控制台输入字符的InputStream对象。我们可以直接使用 System.in.read 读取控制台输入，不过这种方法只能读取一个字符。至于其他答案说的 java.util.Sannner，它需要接收一个 System.in，即 new Scanner(System.in)，它是将System.in的流InputStream转换为某种格式的输入，并不一定是必要的。

4、线程

4.1jre判断程序

jre：Java Runtime Environment的缩写，顾名思义是java运行时环境。

main()函数即主函数，是一个前台线程，前台进程是程序中必须执行完成的，而后台线程则是java中所有前台结束后结束，不管有没有完成，后台线程主要用与内存分配等方面。

前台线程和后台线程的区别和联系：

1、后台线程不会阻止进程的终止。属于某个进程的所有前台线程都终止后，该进程就会被终止。所有剩余的后台线程都会停止且不会完成。

2、可以在任何时候将前台线程修改为后台线程，方式是设置Thread.IsBackground 属性。

3、不管是前台线程还是后台线程，如果线程内出现了异常，都会导致进程的终止。

4、托管线程池中的线程都是后台线程，使用new Thread方式创建的线程默认都是前台线程。

4.2线程的运行流程（线程五种状态）

在Java当中，线程通常都有五种状态，创建、就绪、运行、阻塞和死亡： 　　

第一是创建状态。在生成线程对象，并没有调用该对象的start方法，这是线程处于创建状态。 　　

第二是就绪状态。当调用了线程对象的start方法之后，该线程就进入了就绪状态，但是此时线程调度程序还没有把该线程设置为当前线程，此时处于就绪状态。在线程运行之后，从等待或者睡眠中回来之后，也会处于就绪状态。 即开启线程，获取时间片，获得时间片后就能执行程序。　　

第三是运行状态。线程调度程序将处于就绪状态的线程设置为当前线程，此时线程就进入了运行状态，开始运行run函数当中的代码。 　　

第四是阻塞状态。线程正在运行的时候，被暂停，通常是为了等待某个事件的发生(比如说某项资源就绪)之后再继续运行。sleep，suspend，wait等方法都可以导致线程阻塞。 　　

第五是死亡状态。如果一个线程的run方法执行结束或者调用stop方法后，该线程就会死亡。对于已经死亡的线程，无法再使用start方法令其进入就绪。 调用start（）后，线程会被放到等待队列，等待CPU调度，并不一定要马上开始执行，只是将这个线程置于可动行状态。然后通过JVM，线程Thread会调用run（）方法，执行本线程的线程体。先调用start后调用run。

5、java classloader

解析：

JDK中提供了三个ClassLoader，根据层级从高到低为：

1. Bootstrap ClassLoader，主要加载JVM自身工作需要的类。

2. Extension ClassLoader，主要加载%JAVA_HOME%\lib\ext目录下的库类。

3. Application ClassLoader，主要加载Classpath指定的库类，一般情况下这是程序中的默认类加载器，也是ClassLoader.getSystemClassLoader() 的返回值。（这里的Classpath默认指的是环境变量中配置的Classpath，但是可以在执行Java命令的时候使用-cp 参数来修改当前程序使用的Classpath）

JVM加载类的实现方式，我们称为 双亲委托模型：

如果一个类加载器收到了类加载的请求，他首先不会自己去尝试加载这个类，而是把这个请求委托给自己的父加载器，每一层的类加载器都是如此，因此所有的类加载请求最终都应该传送到顶层的Bootstrap ClassLoader中，只有当父加载器反馈自己无法完成加载请求时，子加载器才会尝试自己加载。

双亲委托模型的重要用途是为了解决类载入过程中的安全性问题。

假设有一个开发者自己编写了一个名为Java.lang.Object的类，想借此欺骗JVM。现在他要使用自定义ClassLoader来加载自己编写的java.lang.Object类。然而幸运的是，双亲委托模型不会让他成功。因为JVM会优先在Bootstrap ClassLoader的路径下找到java.lang.Object类，并载入它

6、局部变量和成员变量

解析：

1. 局部变量可以和成员变量重名

2. 成员变量属于类的对象，对象存在，则成员变量存在。this指的就是当前运行时对象。this.变量名访问的就是当前对象的成员变量。

3. 成员变量：是类中的实例化对象的

😁成员变量：在类范围里定义的变量，Field，包括以下两种：

类Field：定义变量时有static修饰的就是类Field

实例Field :定义Field是没有static修饰的就是实例Field

局部变量：

😁局部变量：是在方法体里定义的变量。局部变量除了形参之外，都必需显式初始化

• 方法局部变量

• 代码块局部变量

• 形参：在定义方法签名时定义的变量，形参的作用域在整个方法内有效

• 使用方法注意：如果局部变量在程序中没有被使用，那么可以不用被初始化，但是如果在程序中局部变量被使用，则必须要对局部变量进行初始化。

例如下面：

4. 例子

7、this关键字

this是指向对象的引用

1.this 用于调用本类中的变量

2.this用于调用本类中的其他方法

3.this用于调用本类中的其他的构造方法，调用的时候，要放在首行

4.this不能在static的方法中使用

8、类变量、成员变量的调用

1、类变量（静态变量）的调用：（1）静态、非静态方法中，可以直接调用。

2、成员变量的调用有2种方法：

（1）非静态方法中，可以通过this关键字直接调用。因为成员变量的初始化时间先于类的构造函数执行前,自然保证了成员变量已经被赋值。

（2）静态方法中，先实例化类，利用实例化类的引用才能调用。

3、this关键字：（1）不能在静态方法中使用。

9、异常处理

1、try...catch...finally

当Java程序执行try块、catch块时遇到了return或throw语句，这两个语句都会导致该方法立即结束，但是系统执行这两个语句并不会结束该方法，而是去寻找该异常处理流程中是否包含finally块。

😁没有finally块：程序立即执行return或throw语句，方法终止；

😁有finally块：

步骤一：系统立即开始执行finally块

步骤二：系统才会再次跳回来执行try块、catch块里的return或throw语句

步骤三：如果finally块里也使用了return或throw等语句，finally块会终止方法，系统将不会跳回去执行try块、catch块里的任何代码。

2、使用try时，catch和finally必须存在一个，也可以两者都同时存在。

10、&与&&和|与||区别

10.1&与&&的异同点

相同点：二者都表示与操作，当且仅当运算符两边的操作数都为true时，其结果才为true，否则为false。

不同点：在使用&进行运算时，不论左边为true或者false，右边的表达式都会进行运算。如果使用&&进行运算时，当左边为false时，右边的表达式不会进行运算，因此&&被称作短路与。

10.2|与||的异同点。

相同点：二者都表示或操作，当运算符两边的操作数任何一边的值为true时，其结果为true，当两边的值都为false时，其结果才为false。

不同点：不论左边为true或者false，右边的表达式都会进行运算，||表示短路或，当运算符左边的值为true时，右边的表达式不会进行运算。

11、在同一个类中构造方法的互相调用以及调用非构造方法

this.类名(x)：调用普通方法

this(x)：在同一个类中的构造方法调用其他构造方法

super(x)：调用父类构造方法

A(x)：在new一个类时使用，调用本类中的普通方法

12、线程与进程

https://blog.csdn.net/weixin_48776531/article/details/123767751?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167698794916782425163346%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=167698794916782425163346&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-123767751-null-null.142^v73^wechat_v2,201^v4^add_ask,239^v2^insert_chatgpt&utm_term=java%E7%BA%BF%E7%A8%8B%E4%B8%8E%E8%BF%9B%E7%A8%8B&spm=1018.2226.3001.4187

2023.2.22刷题

1、内部类

1、内部类不能被public、private、static修饰；不能被访问控制符（public、protected、friendly、private）修饰

2、在外部类中不能创建内部类的实例；

3、创建内部类的实例只能在包含他的方法中；

4、内部类访问包含他的方法中的变量必须有final修饰；

5、外部类不能访问局部内部类，只能在方法体中访问局部内部类，且访问必须在内部类定义之后。

2、字符流和字节流区别

stream结尾都是字节流， reader和writer结尾都是字符流。

https://www.nowcoder.com/questionTerminal/4e18b865ec55419bb45ed9be3c7ed9b4

2023.2.23刷题

1、Java并发

1. CopyOnWriteArrayList适用于写少读多的并发场景

2. ReadWriteLock即为读写锁，他要求写与写之间互斥，读与写之间互斥， 读与读之间可以并发执行。在读多写少的情况下可以提高效率

3. ConcurrentHashMap是同步的HashMap，读写都加锁

4. volatile只保证多线程操作的可见性，不保证原子性

2、Object类

1. object类是一切类的超类（父类）

2. class类是Object类的派生类（子类）

3. class类可以装在其他类，forName()方法返回与带有给定字符串名的类或接口相关联的Class对象

2023.2.24刷题

1、JAVA异常的描述

解析：

都是Throwable的子类：

1.Exception（异常）:是程序本身可以处理的异常。

2.Error（错误）:是程序无法处理的错误。这些错误表示故障发生于虚拟机自身、或者发生在虚拟机试图执行应用时，一般不需要程序处理。

3.检查异常（编译器要求必须处置的异常）： 除了Error，RuntimeException及其子类以外，其他的Exception类及其子类都属于可查异常。这种异常的特点是Java编译器会检查它，也就是说，当程序中可能出现这类异常，要么用try-catch语句捕获它，要么用throws子句声明抛出它，否则编译不会通过。

4.非检查异常(编译器不要求处置的异常):包括运行时异常（RuntimeException与其子类）和错误（Error）。