什么是B/S架构，C/S架构？Java都有那些开发平台？
B/S(Browser/Server)，浏览器/服务器程序
C/S(Client/Server)，客户端/服务端，桌面应用程序
JAVA SE：主要用在客户端开发
JAVA EE：主要用在web应用程序开发
JAVA ME：主要用在嵌入式应用程序开发
JDK, JRE, JVM？JDK（Java Development Kit）： JDK是Java开发工具包，它是Java开发的完整工具集，包括了Java编译器（javac）、Java虚拟机（JVM）、Java类库等。主要用于Java应用程序的开发，提供了开发、编译、调试和运行Java程序所需的工具。JRE（Java Runtime Environment）： JRE是Java运行时环境，它是Java应用程序执行的环境，包含了Java虚拟机（JVM）和Java类库。用于在计算机上运行已经编译过的Java应用程序，但不包含用于Java开发的工具，如编译器。JVM（Java Virtual Machine）： JVM是Java虚拟机，是一个在物理计算机上模拟运行Java字节码（.class）的虚拟机。负责解释和执行Java字节码，通过不同操作系统上的 JVM 解释为该操作系统的机器指令，使得Java程序能够在不同的平台上实现一次编译，到处运行的跨平台特性。
Java语言有哪些特点？
简单易学、有丰富的类库
面向对象 OOP（Java最重要的特性，让程序耦合度更低，内聚性更高）
与平台无关性（JVM是Java跨平台使用的根本）
可靠安全
支持多线程
一个java类中包含那些内容？
数据结构？Java的数据结构有那些？Java中有几种数据类型？
float 和 double.
float是一种单精度浮点数数据类型，通常用于需要小数点的计算，但它不如double类型精确。float类型有7位十进制有效数字，并且它的存储大小是32位（4字节）。
double是一种双精度浮点数数据类型，比float类型有更高的精度，通常用于需要更精确计算的情况。double类型有15位十进制有效数字，并且它的存储大小是64位（8字节）。 1 double myDouble = 3.141592653589793 ;
如何解决浮点型数据运算出现的误差的问题？float f=3.4;是否正确？Bigdecimal类 进行浮点型数据的运算。
short s1 = 1; s1 = s1 + 1;有错吗？short s1 = 1; s1 += 1; 有错吗？
int i = 0; count = (i++)+ (i++)+ (i++); 值为？
什么是隐式转换，什么是显式转换？Char类型能不能转成int类型，string类型，double类型？
char 型变量中能不能存贮一个中文汉字？
数组在java中是一种基本数据类型吗？引用类型？
什么是基本数据类型和引用类型？
基本数据类型：是编程语言中内置的简单数据类型，用于直接存储具体的值。这些值通常是不可变的，即一旦赋值，就不能改变它们的类型。基本数据类型通常包括整形：byte,short,int,long；浮点型：float,double；字符型：char；布尔型：boolean。在Java中，基本数据类型是直接存储值的，它们占用的内存空间是固定的，且不会引用其他对象。
引用类型：与基本数据类型相对，它们不直接存储值，而是存储对内存中对象的引用。这意味着，引用类型的变量实际上是一个指针，指向存储在堆内存中的对象。当你创建一个引用类型的变量（如数组、类、接口等）时，你实际上是在内存中创建了一个对象，并将变量设置为指向这个对象的引用。引用类型包括类（Class）、接口（Interface）、数组（Array）等。
Java 中变量是“值传递” 还是 “引用传递”？
基本数据类型的变量存储的是值本身。当你将一个基本数据类型的值赋给另一个变量时，实际上是复制了这个值。所以，对于基本数据类型，Java确实是通过值来传递的。1 2 3 4 5 6 7 8 9 10 11 public class Main { public static void main (String[] args) { int originalValue = 5 ; modifyValue(originalValue); System.out.println(originalValue); } public static void modifyValue (int value) { value = 10 ; System.out.println(value); } }
1 2 3 4 5 6 7 8 9 public class Main { public static void main (String[] args) { int number = 5 ; System.out.println("Before modification: " + number); number = 10 ; System.out.println("After modification: " + number); } }
引用类型的变量实际上存储的是一个指向内存中对象的引用的地址。当你将一个引用类型的变量赋给另一个变量时，你实际上是在复制这个引用地址，而不是对象本身。这意味着两个变量现在指向同一个对象。因此，尽管在引用类型中，传递的是引用（地址），但这并不等同于传统意义上的“引用传递”。
Java创建对象有几种方式？
使用 new 关键字： 1 MyClass obj = new MyClass ();
通过反射机制： 1 2 3 4 5 6 try { Class<?> clazz = Class.forName("MyClass" ); MyClass obj = (MyClass) clazz.newInstance(); } catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) { e.printStackTrace(); }
使用 clone() 方法： 1 2 3 4 5 6 MyClass original = new MyClass ();try { MyClass cloned = (MyClass) original.clone(); } catch (CloneNotSupportedException e) { e.printStackTrace(); }
通过反序列化： 1 2 3 4 5 6 7 8 ObjectOutputStream out = new ObjectOutputStream (new FileOutputStream ("object.ser" ));out.writeObject(new MyClass ()); out.close(); ObjectInputStream in = new ObjectInputStream (new FileInputStream ("object.ser" ));MyClass obj = (MyClass) in.readObject();in.close();
使用匿名类
工厂方法
使用静态工厂方法
面向对象和面向过程的区别。
面向过程：一种较早的编程思想，顾名思义就是该思想是站着过程的角度思考问题，强调的就是功能行为，功能的执行过程，即先后顺序，而每一个功能我们都使用函数（类似于方法）把这些步骤一步一步实现。使用的时候依次调用函数就可以了。
面向对象：一种基于面向过程的新编程思想，顾名思义就是该思想是站在对象的角度思考问题，我们把多个功能合理放到不同对象里，强调的是具备某些功能的对象。
instanceof 关键字的作用1 boolean result = obj instanceof Class
封装 ？什么是拆装箱？
int 与 Integer初始值？
抽象
面向对象的特征有哪些方面?
封装：通常认为封装是把数据和操作数据的方法绑定起来，对数据的访问只能通过已定义的接口。
面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装；编写一个类就是对数据和数据操作的封装。
优点:
信息隐藏 : 允许隐藏对象的内部状态和实现细节，只暴露必要的接口。这样可以保护对象的内部数据不被外部直接访问和修改，减少错误和不一致的状态。模块化 : 将复杂的系统分解为独立的、可管理的模块。每个模块负责特定的功能，使得开发和维护更加简单。易于维护 : 封装使得对象的实现可以独立于其使用者进行更改。只要接口保持不变，内部的修改不会影响到使用该对象的其他部分代码。
继承：继承是从已有类得到继承信息创建新类的过程.
提供继承信息的类被称为父类(超类、基类);得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段。
优点:
代码重用 : 继承允许子类继承父类的属性和方法，减少了代码的重复编写，提高了开发效率。建立层次结构 : 继承支持创建一个类的层次结构，这有助于组织和管理具有共同特征的对象。子类可以扩展或覆盖父类的行为，从而实现更具体的功能。多态的基础 : 继承是多态实现的基础。通过继承，可使用父类类型的引用来操作子类对象，为多态提供了可能。
多态性：是指允许不同子类型的对象对同一消息作出不同的响应。
简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。
优点:
接口统一 : 允许不同的子类对象通过统一的接口进行操作，简化了客户端代码的复杂性，可以处理不同类型的对象而不需要知道对象的具体类型。扩展性 : 提高了代码的扩展性。如果需要引入新的子类，只需确保它遵循现有的接口，而无需修改已有的代码。动态绑定 : 在Java等语言中，多态允许在运行时动态决定对象的具体类型和调用的方法。这种动态绑定提供了更大的灵活性和更强的表达能力。
方法重载（overload）实现的是编译时的多态性（也称为前绑定），编译器在编译时根据参数类型和数量确定哪个方法 1 2 public int add (int a, int b) return a + b; public double add (double a, double b) return a + b;
方法重写（override）实现的是运行时的多态性（也称为后绑定）。运行时的多态是面向对象最精髓的东西，要实现多态需要做两件事：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class Animal { public void sound () { System.out.println("The animal makes a sound" ); } } class Dog extends Animal { @Override public void sound () { System.out.println("The dog barks" ); } } public class Main { public static void main (String[] args) { Animal animal = new Dog (); animal.sound(); } }
总的来说，封装、继承和多态共同为面向对象编程提供了一种强大的方式来构建复杂和可扩展的软件系统。它们使得代码更加清晰、易于维护和扩展，同时也提高了代码的复用性和可读性。极大地提高了软件开发的效率、可维护性和可扩展性。
重载和重写的区别
重写 Override：在子类中把父类本身有的方法重新写一遍。子类继承了父类原有的方法，但有时子类并不想原封不动的继承父类中的某个方法，所以在方法名，参数列表，返回类型(除过子类中方法的返回值是父类中方法返回值的子类时)都相同的情况下， 对方法体进行修改或重写，这就是重写。被重写方法比父类更好访问（即子类函数的访问修饰权限不能少于父类的），不能比父类被重写方法声明更多的异常（里氏代换原则）。方法名，参数列表，返回类型（除过子类中方法的返回类型是父类中返回类型的子类）必须相同 访问修饰符的限制一定要大于被重写方法的访问修饰符（public>protected>default>private） ，子类重写方法应该要比父类方法具有相同或更广泛的可见性，子类对外暴露的接口比父类更多，这符合面向对象编程中的开闭原则（对扩展开放，对修改关闭），提供了更多的灵活性。
重载（Overload）在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同甚至是参数顺序不同）则视为重载。同时，重载对返回类型没有要求，可以相同也可以不同，但不能通过返回类型是否相同来判断重载。重载要求同名方法的参数列表不同(参数类型，参数个数甚至是参数顺序) 重载的时候，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准
动态绑定？
public，private，protected，以及不写（默认）时的区别？
public声明类的成员时，它可以在任何其他类中（同一包中/不同的包中）被访问。
private成员只能在其自己的类中被访问。它不能被任何其他类（即使是同一包中的类）访问。
protected成员可以在其自己的类、同一包中的其他类以及任何子类（无论子类在哪里）中被访问。
默认（无修饰符）default：当一个类的成员没有明确的访问修饰符时，它只能在同一包中的其他类中被访问。对于同一个包中的其他类相当于 public，对于不是同一个包中的其他类相当于 private。这意味着它不能被其他包中的类直接访问，但可以被同一包中的任何类访问。这是比private更开放，但比protected和public更受限的访问级别。
String 是最基本的数据类型吗？
String的初始值是？NULL.
String 常见题.
“字面量创建字符串”：yesA 是一个引用指向了堆里面的字符串常量池里的对象 a。如果字符串常量池已经有了 abb，那么直接返回其引用，如果没有 abb，则会创建 abb 对象，然后返回其引用。 1 2 3 String yesA = "abb" ; String yesB = "abb" ; System.out.printIn(yesA == yesB);
“new String创建字符串”：先判断字符串常量池里面是否有 abb，如果没有 abb 则创建一个 abb，然后会在堆内存里面创建一个对象 abb，返回堆内存对象 abb 的引用，也就是说返回的不是字符串常量池里面的 abb 1 2 3 yesA = new String ("abb" ); yesB = new String ("abb" ); System.out.println(yesA == yesB);
intern()：判断下 yesB 引用指向的值在字符串常量里面是否有，如果没有就在字符串常量池里面新建一个 aaabbb 对象，返回其引用，如果有则直接返回引用。 1 2 3 4 5 String yesA = "aaabbb" ; String yesB = new String ("aaa" ) + new String ("bbb" ); String yesC = yesB.intern(); System.out.println(yesA == yesB); System.out.println(yesA == yesC);
JDK 1.6 时，字符串常量池是放置在永久代的;1 2 3 4 5 String yesB = new String ("aaa" ) + new String ("bbb" ); String yesC = yesB.intern(); String yesA = "aaabbb" ; System.out.println(yesA == yesB); System.out.println(yesA == yesC);
String 连接？
使用 + 运算符：字符串连接最简单的方法，但在大量连接操作时可能效率较低，因为它会生成多个临时的字符串对象。
使用 StringBuilder：可变的字符序列，适用于需要频繁进行字符串连接的场景。append 方法用于添加字符串内容，最后使用 toString 方法获取最终的字符串。适合单线程环境下使用。
使用 StringBuffer：与 StringBuilder 类似，也是可变的字符序列，但不同之处在于 StringBuffer 是线程安全的，适用于多线程环境。
String，StringBuffer 和 StringBuilder 的区别是什么？
String类的常用方法有那些？
分割字符串常用的方法。
split(String regex) 方法：1 2 3 String input = "apple,orange,banana" ;String[] fruits = input.split("," );
split 方法配合正则表达式的转义字符：1 2 3 String input = "apple.orange.banana" ;String[] fruits = input.split("\\." );
substring 和 indexOf 方法：1 2 3 4 5 String input = "apple,orange,banana" ;int commaIndex = input.indexOf("," );String firstPart = input.substring(0 , commaIndex);String secondPart = input.substring(commaIndex + 1 );
使用 Pattern 和 Matcher 类： 进行更复杂的正则表达式匹配和分割。 1 2 3 4 5 6 7 import java.util.regex.Pattern;import java.util.regex.Matcher;String input = "apple,orange;banana" ;Pattern pattern = Pattern.compile("[,;]" );String[] fruits = pattern.split(input);
JDK9为什么要将 String 的底层实现由 char[] 改为 byte[]？
Unicode 和 UTF-8 的区别：
Unicode（统一码）： UTF-8（Unicode Transformation Format-8）：
++i与i++的区别
i++：先赋值，后计算；
++i：先计算，后赋值
在JVM层面，这两个操作的实现是通过指令集中的不同指令来完成的。Java虚拟机中的字节码指令包含 iinc 指令用于递增局部变量的值。这两种递增操作在底层都是通过 iinc 指令实现的，但在具体的使用上有一些差异。 1 2 3 4 getstatic i iconst_1 iadd putstatic i
1 2 3 4 getstatic i iconst_1 isub putstatic i
count += –count; 值为？--count 表示先对 count 执行减一操作，然后将结果赋给 count。count 的当前值（执行了减一操作后的值）加上 count 的当前值，再将结果赋给 count。
a=a+b 与 a+=b 有什么区别吗?
+= 操作符会进行隐式自动类型转换,此处a+=b隐式的将加操作的结果类型强制转换为持有结果的类型,1 2 3 4 5 6 byte a = 127 , b = 127 ;b = a + b; b += a; short s1= 1 ;s1 = s1 + 1 ; s1 += 1 ;
&和&&的区别
200 + null 值为？
(-10) % (-3) = ？
如果被取模数为正数，结果的符号与被取模数相同。10 = 3 * 3 + 1；
如果被取模数为负数，结果的符号与除数相同。 (-10) = (-3) * 3 + (-1); 所以 (-10) % (-3) = -1。
Java 常用的类，包，接口。
Object类常用方法有那些？
equals与==的区别
==：比较的是变量(栈)内存中存放的对象的(堆)内存地址，用来判断两个对象的地址是否相同，即是否是指相同一个对象。比较的是真正意义上的指针操作。== 操作符直接比较它们的值，值相等则为true。如：int a=10 与 long b=10L 与 double c=10.0都是相同的（为true），因为他们都指向地址为10的堆。而对于 Integer a =10 与 Long b = 10L， 使用 == 比较的是对象的引用而不是值，结果为 false。
equals：用来比较的是两个对象的内容是否相等，由于所有的类都是继承自java.lang.Object类的，所以适用于所有对象，如果没有对该方法进行覆盖的话，调用的仍然是Object类中的方法，而Object中的equals方法返回的却是==的判断。
equals() 和 hashCode() 方法。为什么重写 equals() 时通常也需要重写 hashCode()？
equals() 方法hashCode() 方法：关系： 在使用哈希表的集合中，hashCode() 和 equals() 之间存在一定的关系。如果两个对象通过 equals() 方法比较相等，它们的 hashCode() 应该返回相同的值。这是为了保持一致性，使得相等的对象在哈希表中能够正确地识别和处理。确保相等的对象具有相同的哈希码，从而使得在集合中正确地处理相等性。equals() 方法比较相等，但它们的 hashCode() 不相等，那么当放入哈希表等集合中时，它们将被视为不同的对象。这可能导致哈希表中存在相等的对象，破坏了集合的一致性。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class MyClass { private int id; private String name; @Override public boolean equals (Object obj) { if (this == obj) return true ; if (obj == null || getClass() != obj.getClass()) return false ; MyClass myClass = (MyClass) obj; return id == myClass.id && Objects.equals(name, myClass.name); } @Override public int hashCode () { return Objects.hash(id, name); } }
有没有可能两个不相等的对象有相同的hashcode？
拉链法:每个哈希表节点都有一个next指针,多个哈希表节点可以用next指针构成一个单向链表，被分配到同一个索引上的多个节点可以用这个单向链表进行存储.
开放定址法:一旦发生了冲突,就去寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到,并将记录存入
再哈希:又叫双哈希法,有多个不同的Hash函数.当发生冲突时,使用第二个,第三个….等哈希函数计算地址,直到无冲突.
java中有没有指针？java中是值传递引用传递？java都是值传递 ，对于基本数据类型，传递是值的副本，而不是值本身。对于对象类型，传递是对象的引用，当在一个方法操作操作参数的时候，其实操作的是引用所指向的对象。
构造方法 constructor
构造方法是Java类中的一种特殊方法（可省略），用于在创建对象时进行初始化操作。
方法也可以与class同名，区别在于方法必须要有void或具体返回值类型；
一个类可以拥有多个构造方法，只要它们的参数列表不同。这称为构造方法的重载。 1 2 3 4 5 6 7 public class MyClass { private int value; public MyClass () {this .value = 0 ;} public MyClass (int value) {this .value = value;} }
构造方法能不能显式调用？
构造方法能不能重写，重载？
Java中有各种不同的类和代码块类型，让我们逐个解释它们：
普通类：是最基本的类类型，用于创建对象。它可以包含字段、方法、构造方法等。 1 2 3 public class MyClass { }
构造方法：是包含在类中的一组语句块，没有使用任何关键字。它在对象每一次创建时执行，可以用于初始化对象。1 2 3 4 5 6 7 8 9 public class MyClass { MyClass() { } { } }
内部类：内部类是定义在另一个类内部的类。它有访问外部类成员的权限，并且可以用于实现一些封装和逻辑组织。 1 2 3 4 5 public class OuterClass { class InnerClass { } }
外部类： 外部类是普通的顶级类，不嵌套在其他类中。 1 2 3 public class OuterClass { }
静态代码块： 使用 static 关键字，包含在类中，用于在类加载时执行初始化操作。它仅执行一次。 1 2 3 4 5 6 public class MyClass { static { } }
静态内部类：是定义在另一个类内部的类，使用 static 修饰。与非静态内部类不同，它不依赖于外部类的实例。 1 2 3 4 5 public class OuterClass { static class StaticInnerClass { } }
静态 static
静态变量（Static Variables）：被声明为 static 的成员变量，属于类而不是类的实例。它被所有类的实例共享，只有一个副本存在于内存中。 1 2 3 4 5 public class Counter { private static int count = 0 ; public static void increment () { count++; } }
静态方法（Static Methods）：被声明为 static 的方法，它不需要实例化类就可以直接通过类名调用。静态方法不能访问非静态成员，也无法使用 this 关键字。
静态代码块（Static Blocks）：是包含在类中的静态块，它在类加载时执行，并且只执行一次。通常用于初始化静态变量或执行一些静态的初始化操作。
静态内部类（Static Inner Classes）：在类中使用 static 关键字修饰的内部类。静态内部类与外部类实例无关，可以直接通过外部类名访问。
内部类与静态内部类的区别？
静态内部类相对与外部类是独立存在的，在静态内部类中无法直接访问外部类中变量、方法。如果要访问的话，必须要new一个外部类的对象，使用new出来的对象来访问。但是可以直接访问静态的变量、调用静态的方法；
普通内部类作为外部类一个成员而存在，在普通内部类中可以直接访问外部类属性，调用外部类的方法。
如果外部类要访问内部类的属性或者调用内部类的方法，必须要创建一个内部类的对象，使用该对象访问属性或者调用方法。
如果其他的类要访问普通内部类的属性或者调用普通内部类的方法，必须要在外部类中创建一个普通内部类的对象作为一个属性，外同类可以通过该属性调用普通内部类的方法或者访问普通内部类的属性。
如果其他的类要访问静态内部类的属性或者调用静态内部类的方法，直接创建一个静态内部类对象即可。
静态变量、静态代码块、普通代码块和构造方法的执行顺序？
静态变量（静态成员变量）：在类加载时按照定义的顺序依次执行初始化，不论该变量在类中定义的位置如何，只会初始化一次。
静态代码块（Static Blocks）：静态代码块在类加载时执行，优先于普通代码块和构造方法。静态代码块只会执行一次。
构造代码块（普通初始化块）：构造代码块在对象实例化时执行，在构造方法之前执行。每次创建对象都会执行一次。
构造方法（Constructor）：构造方法在对象创建时执行，用于初始化对象。构造代码块执行完毕后执行。
子类继承父类，且都包含静态方法、构造方法，那么静态变量、静态代码块、普通代码块和构造方法的执行顺序？
final在java中的作用，有哪些用法?
被final修饰的类不可以被继承
被final修饰的方法不可以被重写
被final修饰的变量不可以被改变.如果修饰引用,那么表示引用不可变,引用指向的内容可变.
被final修饰的方法,JVM会尝试将其内联,以提高运行效率
被final修饰的常量,在编译阶段会存入常量池中.
Java中的继承是单继承还是多继承？
super() 与 this() 表示什么？
super表示当前类的父类对象，This表示当前类的对象。super() 和 this() 都是特殊的方法调用语句，用于调用构造器，并且都只能在构造器中使用，不能在普通方法中使用。另外，调用构造器时不能形成循环调用，即不能在同一个构造器中同时调用 super() 和 this()。
super()：用于调用父类的构造器。在子类的构造器中使用 super() 可以显式调用父类的构造器，并且必须作为子类构造器的第一条语句出现。如果子类构造器没有显式调用 super()，则会默认调用父类的无参构造器。 1 2 3 4 5 6 public class Child extends Parent { public Child () { super (); System.out.println("Child constructor" ); } }
this()：用于调用当前类的其他构造器。在一个类的构造器中使用 this() 可以调用同一类中的其他构造器，并且必须作为构造器的第一条语句出现。 1 2 3 4 5 6 7 8 9 10 11 12 13 public class MyClass { private int value; public MyClass () { this (0 ); System.out.println("Default constructor" ); } public MyClass (int value) { this .value = value; System.out.println("Parameterized constructor" ); } }
抽象类（Abstract Class）：
特点 ：抽象类是一种不能被实例化的类，通常用于定义其他类的结构和行为。它可以包含抽象方法（只有方法签名，没有具体实现），以及普通的方法和字段。一个类只能继承一个抽象类。可以包含构造函数，可以有访问修饰符（public、private、protected）的方法。子类必须实现抽象类中的所有抽象方法，除非子类也是抽象类。使用场景 ：当需要创建一个类，并在其中定义一些方法的行为，但不希望该类被实例化时，可以使用抽象类。抽象类也适合用于在类层次结构中作为其他类的基类，提供通用方法和字段，而具体实现交给其子类。抽象方法的方法体不需要使用 {}，抽象方法是指没有具体实现的方法。只需在方法签名后面加上分号即可，不需要提供方法体。 1 2 3 4 5 6 7 8 public abstract class AbstractClass { public abstract void abstractMethod () ; public void concreteMethod () { System.out.println("This is a concrete method." ); } }
普通类与抽象类有什么区别？
抽象的方法是否可同时是静态的,是否可同时是本地方法（native），是否可同时被 synchronized修饰？
abstract 和 final 同时用来修饰同一个类或方法？abstract修饰符，表示这个类是抽象类，不能被实例化，可以包含抽象方法。final修饰符，表示这个类是最终类，不能被其他类继承。public abstract修饰符，表示这个方法是抽象方法，只有声明没有实现，需要在子类中实现。abstract final不能同时修饰类或方法。public abstract final也是不符合Java语法的组合。需要根据具体的需求和设计来选择适当的修饰符。
是否可以从一个静态方法内部发出对非静态方法的调用？
接口（Interface）：
特点：接口是一种完全抽象的类别，其中只包含方法的签名，但没有方法的实际实现。类可以实现多个接口，但接口不能包含字段或非抽象方法（在Java 8之后，引入了默认方法和静态方法）。接口就是某个事物对外提供的一些功能的声明，是一种特殊的java类，接口弥补了java单继承的缺点。
使用场景：当不同类需要共享某些行为，但它们属于不同的类层次结构时，接口是一个很好的选择。接口允许类定义一组规范，以确保实现类必须提供接口中定义的所有方法。可以使用接口来实现多态性，允许不同的类实现相同的接口并具有不同的行为。
接口有什么特点？
接口与抽象类！？
接口和抽象类都是为了实现代码的重用和提供一致的编程接口而设计的。然而，接口更多地用于定义规范和合同，以确保实现类提供特定的行为，而抽象类更多地用于提供一些通用的方法和行为实现。
抽象类和接口都用于实现多态性和提供一致的编程接口。它们通常用于大型项目中的类层次结构设计和代码组织。
在设计框架或库时，接口是一个有用的工具，因为它可以定义规范和标准，并允许用户通过实现接口来提供自定义行为。
抽象类用于将一些通用方法和字段提取到一个父类中，以便子类可以继承和共享这些功能。
抽象类和接口的区别?
抽象类：1. 抽象方法，只有行为的概念，没有具体的行为实现。使用abstract关键字修饰，没有方法体。子类必须重写这些抽象方法。2. 包含抽象方法的类，一定是抽象类。3. 抽象类只能被继承 ，一个类只能继承一个抽象类。
接口：1. 全部的方法都是抽象方法，属性都是常量 2. 不能实例化，可以定义变量。3. 接口变量可以引用具体实现类的实例 4. 接口只能被实现 ，一个具体类实现接口，必须实现全部的抽象方法 5. 接口之间可以多实现 6. 一个具体类可以实现多个接口，实现多继承现象
抽象类和接口有什么异同？
接口是否可继承接口？抽象类是否可实现接口？抽象类是否可继承具体类？
Anonymous Inner Class(匿名内部类)是否可以继承其它类？是否可以实现接口？
内部类可以引用它的包含类（外部类）的成员吗？有没有什么限制？
匿名类，匿名内部类。
匿名类：
概念： 匿名类是指没有明确命名的类，通常用于创建一个实现某个接口或继承某个类的对象。
语法： 匿名类的语法形式是通过 new 关键字创建一个对象的同时实现接口或继承类，并在花括号内定义类的实现。 1 2 3 SomeInterface obj = new SomeInterface () { };
使用场景： 匿名类通常用于创建简单的、一次性的类实例，不需要为其定义专门的类名。
匿名内部类：
概念： 匿名内部类是指定义在其他类内部、没有类名的类。通常使用它来实现接口或继承类，并在类的内部进行实现。语法： 匿名内部类的语法形式与匿名类相似，但它通常在其他类的方法内部定义，而不是在类的成员变量或其他地方。 1 2 3 4 5 6 7 public class SomeClass { public void doSomething () { SomeInterface obj = new SomeInterface () { }; } }
使用场景： 匿名内部类通常用于在方法内部创建一个实现某个接口或继承某个类的临时对象，它有助于简化代码结构，避免为一次性的需求专门定义一个新的类。
Java的四种引用，强弱软虚
强引用：是平常中使用最多的引用，强引用在程序内存不足（OOM）的时候也不会被回收 1 String str = new String ("str" );
软引用：在程序内存不足时，会被回收，使用方式： 1 2 3 SoftReference<String> wrf = new SoftReference <String>(new String ("str" ));
弱引用：只要JVM垃圾回收器发现了它，就会将之回收，使用方式： 1 WeakReference<String> wrf= newWeakReference<String> (str);
虚引用：虚引用的回收机制跟弱引用差不多，但是它被回收之前，会被放入ReferenceQueue中。注意哦，其它引用是被JVM回收后才被传入ReferenceQueue中的。由于这个机制，所以虚引用大多被用于引用销毁前的处理工作。还有就是，虚引用创建的时候，必须带有ReferenceQueue，使用例子： 1 PhantomReference<String> prf = newPhantomReference<String>(newString("str" ),newReferenceQueue<>());
？？？上诉所说的几类引用，都是指对象本身的引用，而不是指 Reference 的四个子类的引用
注解 Annotation
4种标准元注解是哪四种？
@Target 修饰的对象范围
@Retention 定义 被保留的时间长短
@Documented 描述-javadoc
@Inherited 阐述了某个被标注的类型是被继承的
final、finalize()、finally
性质不同：1. final为关键字；2. finalize()为方法；3. finally为区块标志，用于try语句中；
作用：
final为用于标识常量的关键字，final标识的关键字存储在常量池中（在这里final常量的具体用法将在下面进行介绍）；
finalize()方法在Object中进行了定义，用于在对象“消失”时，由JVM进行调用用于对对象进行垃圾回收，类似于C++中的析构函数；用户自定义时，用于释放对象占用的资源（比如进行I/0操作）；
finally{}用于标识代码块，与try{}进行配合，不论try中的代码执行完或没有执行完（这里指有异常），该代码块之中的程序必定会进行；且finally{}中的 return也会比 try{}中的更早返回！！
Java中的异常体系是怎样的？
Error表示非常严重的错误，比如 java.lang.StackOverFlowError 和 Java.lang.OutofMemoryError，通常这些错误出现时，仅仅想靠程序自己是解决不了的，可能是虚拟机、磁盘、操作系统层面出现的问题了，所以通常也不建议在代码中去捕获这些Error，因为捕获的意义不大，因为程序可能已经根本运行不了了。
Exception表示异常，表示程序出现Exception时，是可以靠程序自己来解决的比如NullPointerException、legalAccessException等，我们可以捕获这些异常来做特殊处理。
运行时异常(不受检异常)：RuntimeException类及其子类表示JVM在运行期间可能出现的错误。比如说试图使用空值对象的引用（NullPointerException）、数组下标越界（ArrayIndexOutBoundException）。此类异常属于不可查异常，一般是由程序逻辑错误引起的，在程序中可以选择捕获处理，也可以不处理。
编译异常(受检异常)：Exception中除RuntimeException极其子类之外的异常。如果程序中出现此类异常，比如说IOException、FileNotFoundException、SQLException，必须对该异常进行处理，否则编译不通过。在程序中，通常不会自定义该类异常，而是直接使用系统提供的异常类。
如何自定义一个异常
异常的处理机制有几种？
try catch finally，try里有return，finally还执行么？
throw与thorws区别
位置不同
throws 用在函数上，后面跟的是异常类，可以跟多个；而 throw 用在函数内，后面跟的是异常对象。
功能不同：
throws 用来声明异常，让调用者只知道该功能可能出现的问题，可以给出预先的处理方式；throw 抛出具体的问题对象，执行到 throw，功能就已经结束了，跳转到调用者，并将具体的问题对象抛给调用者。也就是说 throw 语句独立存在时，下面不要定义其他语句，因为执行不到。
throws 表示出现异常的一种可能性，并不一定会发生这些异常；throw 则是抛出了异常，执行 throw 则一定抛出了某种异常对象。
两者都是消极处理异常的方式，只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
在Java的异常处理机制中，什么时候应该抛出异常，什么时候捕获异常?
异常相当于一种提示，如果我们抛出异常，就相当于告诉上层方法，我抛了一个异常，我处理不了这个异常，交给你来处理，而对于上层方法来说，它也需要决定自己能不能处理这个异常，是否也需要交给它的上层。
所以我们在写一个方法时，我们需要考虑的就是，本方法能否合理的处理该异常，如果处理不了就继续向上抛出异常，包括本方法中在调用另外一个方法时，发现出现了异常，如果这个异常应该由自己来处理，那就捕获该异常并进行处理。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 public class ExampleService { public void lowerLevelOperation () throws SpecificException { throw new SpecificException ("Something went wrong at lower level" ); } public void higherLevelOperation () throws HigherLevelException { try { lowerLevelOperation(); } catch (SpecificException e) { System.out.println("Caught specific exception: " + e.getMessage()); throw new HigherLevelException ("Exception at higher level" , e); } } public static void main (String[] args) { ExampleService service = new ExampleService (); try { service.higherLevelOperation(); } catch (HigherLevelException e) { System.out.println("Caught higher level exception: " + e.getMessage()); } } }
Java 泛型、、
在Java中的泛型简单来说就是：在创建对象或调用方法的时候才明确下具体的类型
使用场景：操作集合的时候，List lists = new ArrayList<>();
泛型是会擦除的，那为什么反射能获取到泛型的信息呢？
泛型实例：组件为了做到足够的通用性，是不知道「用户」传入什么类型参数进来的，所以在这种情况下用泛型就是很好的实践。要写组件，还是离不开Java反射机制(能够从运行时获取信息)，所以一般组件是泛型 + 反射 来实现的。 1 2 3 4 5 6 7 8 9 public abstract class BaseDao <T> { public BaseDao () { Class clazz = this .getClass(); ParameterizedType pt = (ParameterizedType) clazz.getGenericSuperclass(); clazz = (Class) pt.getActualTypeArguments()[0 ]; System.out.println(clazz); } }
1 2 3 4 5 6 public class UserDao extends BaseDao <User> { public static void main (String[] args) { BaseDao<User> userDao = new UserDao (); } }
泛型中extends和super的区别
Java对象创建过程？new一个对象的步骤？
？？？检查类符号引用：首先，JVM 会检查 new 关键字后面的类符号引用，确保在常量池中能找到对应的类。？？？2. 加载类：如果在常量池中找到了类符号引用，JVM 就会加载这个类，包括加载、连接（验证、准备、解析）和初始化阶段。
(1. )类加载检查：JVM 首先检查是否已经加载并验证了这个类的字节码。如果没有，JVM会通过类加载器（ClassLoader）加载这个类，并进行验证，确保其符合Java语言规范。这个过程可能包括解析类的依赖关系，解析字段和方法，以及进行类型检查。
分配内存：JVM 会根据类的定义，在堆内存中为对象分配内存空间。这个内存空间包括对象的所有成员变量。这个过程包括选择内存分配方式（如指针碰撞、空闲列表、TLAB）、分配内存并进行内存清零。
初始化对象：分配完内存空间后，JVM 会将对象的除对象头外的内存空间初始化为默认值（基本数据类型为 0，引用类型为 null）。最后，JVM 会设置对象的对象头，包括哈希码、GC 信息等元信息。
调用构造方法：执行对象的初始化逻辑，包括对成员变量进行赋值、执行一些初始化操作等。
返回对象引用：最后，new 操作符会返回一个指向新创建对象的引用，通过这个引用可以在程序中操作对象的属性和调用对象的方法。
这些步骤是创建一个对象的基本流程，无论是通过 new 关键字创建对象，还是通过反射、序列化等方式创建对象，都要经历这些步骤。
Java 反射 ？
除了使用new创建对象之外，还可以使用 Java 反射可以创建对象，谁的效率高？
用 new 关键字创建对象到底是编译时的还是运行时的方式？有什么区别？
java反射的作用
哪里会用到反射机制？
jdbc就是典型的反射，hibernate，struts等框架使用反射实现的。 1 Class.forName('com.mysql.jdbc.Driver.class' );
在 Spring 中使用反射机制：目的是为了实现框架的灵活性和可扩展性，使得开发人员能够通过配置和注解等方式，实现各种功能而无需修改源代码：
依赖注入：Spring 使用反射来实现依赖注入，即通过在配置文件或注解中声明依赖关系，Spring 在运行时动态地注入对象之间的依赖关系。通过反射，Spring 能够实例化和初始化对象，以及在运行时处理依赖注入。
Bean 的自动装配： Spring 的自动装配机制依赖于反射，它能够根据一定的规则自动将 Bean 与其他 Bean 进行关联。通过反射，Spring 可以动态地识别和连接相应的 Bean。
AOP（面向切面编程）： 在 Spring 中，AOP 是通过动态代理和反射来实现的。通过反射，Spring 能够在运行时动态地创建代理对象，并在方法执行前后执行额外的逻辑。
Bean 的生命周期管理： Spring 容器可以通过反射来实现对 Bean 的生命周期的管理，包括实例化、初始化、销毁等。
动态代理：Spring 使用动态代理和反射来实现一些特定的功能，如事务管理。通过动态代理，Spring 能够在运行时创建代理对象，将横切逻辑织入到目标对象中。
处理注解：Spring 使用反射来处理注解，包括扫描类路径上的注解、解析注解的属性值等。通过反射，Spring 能够在运行时获取和处理注解信息。
反射机制的优缺点
优点：
能够运行时动态获取类的实例，提高灵活性；
与动态编译结合
缺点：
使用反射性能较低，需要解析字节码，将内存中的对象进行解析。解决方案：1、通过setAccessible(true)关闭JDK的安全检查来提升反射速度；2、多次创建一个类的实例时，有缓存会快很多; 3、ReflflectASM工具类，通过字节码生成的方式加快反射速度
相对不安全，破坏了封装性（因为通过反射可以获得私有方法和属性）
反射的实现方式：
获取想要操作的类的 Class 对象，他是反射的核心，通过 Class 对象我们可以任意调用类的方法。以下是常用的方法：
使用 Class.forName 静态方法(最安全/性能最好) 1 2 3 4 5 try { Class<?> myClass = Class.forName("com.example.MyClass" ); } catch (ClassNotFoundException e) { e.printStackTrace(); }
使用 ClassLoader 的 loadClass 方法： 也可以加载类并返回 Class 对象。 1 2 3 4 5 6 ClassLoader classLoader = getClass().getClassLoader();try { Class<?> myClass = classLoader.loadClass("com.example.MyClass" ); } catch (ClassNotFoundException e) { e.printStackTrace(); }
使用 .class 语法： 在已知类的情况下，可以直接获取该类的 Class 对象。 1 Class<?> myClass = MyClass.class;
使用对象的 getClass 方法： 可以返回该对象的 Class 对象。 1 2 MyClass myObject = new MyClass ();Class<?> myClass = myObject.getClass();
调用 Class 类中的方法，获取类的结构信息。
Class 类：反射的核心类，可以获取类的属性，方法等信息。
Field 类：Java.lang.reflec 包中的类，表示类的成员变量，可以用来获取和设置类之中的属性值。
Method 类： Java.lang.reflec 包中的类，表示类的方法，它可以用来获取类中的方法信息或者执行方法。
Constructor 类： Java.lang.reflec 包中的类，表示类的构造方法。 1 2 3 4 5 6 7 8 9 Class clazz = Class.forName("reflection.Person" );Method[] method = clazz.getDeclaredMethods(); Field[] field = clazz.getDeclaredFields(); Constructor[] constructor = clazz.getDeclaredConstructors(); for (Constructor c : constructor) System.out.println(c.toString());
将获取到的类信息用于实际的操作，例如创建对象、调用方法、获取和设置字段的值等。
利用反射动态创建对象实例.
1 2 3 4 5 6 7 8 Class clazz = Class.forName("reflection.Person" );Person p = (Person) clazz.newInstance();Constructor c = clazz.getDeclaredConstructor(String.class,String.class,int .class); Person p1 = (Person) c.newInstance("李四" ,"男" ,20 );
深拷贝和浅拷贝
你了解动态代理吗？??
代理模式是设计模式之一。代理模型有静态代理和动态代理。
静态代理需要自己写代理类，实现对应的接口，比较麻烦，在【编译期间】就确定好代理关系。
动态代理这一技术在实际或者框架原理中是非常常见的，在【运行期间】确定好代理关系。
动态代理有什么用：它是一种设计模式，用于在不修改原始对象的情况下，通过代理对象来间接访问原始对象，并在访问前后执行额外的操作。
动态代理中的对象：
目标对象：待增强的对象
代理对象：增强过后的对象，也就是我们使用的对象
两种实现方式：
JDK动态代理（反射）其实就是运用了反射的机制，会帮我们实现接口的方法，通过invokeHandler对所需要的方法进行增强；
目标对象 implement 目标接口
代理对象 implement 目标接口
目标对象和代理对象是平级关系
CGLIB代理（继承）则用的是利用ASM框架，通过修改其字节码生成子类来处理。
代理对象 extend 目标对象
目标对象和代理对象是父子关系
动态代理的应用：功能增强、控制访问。
SpringAOP
Spring整合Mybaits管理Mapper接口，不用写实现类，只写接口就可以执行SQL
面向对象设计中五大设计原则 SOLID、、
单一职责原则（SRP）： 每个类或模块应该有且仅有一个引起它变化的原因，即一个类或模块应该只负责一种类型的任务或功能。这样可以提高代码的内聚性和可维护性，减少代码的复杂度。
开放封闭原则（OCP）： 软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。即通过扩展现有的代码来实现新的功能，而不是修改已有的代码。这样可以降低修改已有代码带来的风险，并提高系统的稳定性。
里氏替换原则（LSP）：子类必须能替换父类并出现在父类能够出现的任何地方，而不影响程序的正确性。即子类应该完全实现父类的方法，并且遵循父类的约定和契约。
接口隔离原则（ISP）： 不应该强迫客户端依赖它们不需要的接口。接口应该小而专一，应该根据实际需要定义多个接口，而不是一个臃肿的接口。这样可以降低类之间的耦合度，提高系统的灵活性和可维护性。
依赖倒置原则（DIP）：高层模块不应该依赖于低层模块，它们都应该依赖于抽象。抽象不应该依赖于具体实现细节，具体实现细节应该依赖于抽象。这样可以降低模块之间的耦合度，提高系统的灵活性和可扩展性。
常用的设计模式、、
策略模式 ：定义了算法族，分别封装起来，让它们之间可以相互替换，此模式让算法的变化独立于使用算法的的客户。
使用场景：如果代码有多个 if…else 等条件分支，并且每个条件分支，可以封装起来替换的，我们就可以使用策略模式来优化。
模式实现：一个接口或者抽象类，里面两个方法(一个方法匹配类型，一个可替换的逻辑实现方法)、不同策略的差异化实现(即，不同策略的实现类)、使用策略模式
模式使用：我们借助 spring 的生命周期，使用 ApplicationcontextAware 接口，把对用的策略，初始化到 map 里面。然后对外提供 resolveFile 方法即可。
责任链模式 ：实际上是一种处理请求的模式，它让多个处理器(对象节点)都有机会处理该请求，直到其中某个处理成功为止。责任链模式把多个处理器串成链，然后让请求在链上传递。
使用场景：当你想要让一个以上的对象有机会能够处理某个请求的时候，就使用责任链模式。责任链上，每个对象的差异化处理，如本小节的业务场景，就有参数校验对象、安全校验对象、黑名单校验对象、规则拦截对象
模式实现：一个接口或者抽象类、每个对象差异化处理、对象链(数组)初始化(连起来)
这个接口或者抽象类，需要：有一个指向责任下一个对象的属性、一个没置下一个对象的set方法、给子类对象有异化实现的方法(如以下代码的doFiter方法)
模版方法模式 ：定义一个操作中的算法的骨架流程，而将一些步骤延迟到子类中，使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。它的核心思想就是:定义一个操作的一系列步骤，对于某些暂时确定不下来的步骤，就留给子类去实现，这样不同的子类就可以定义出不同的步骤。
模式实现：一个抽象类，定义骨架流程(抽象方法放一起)确定的共同方法步骤，放到抽象类(去除抽象方法标记)。不确定的步骤，给子类去差异化实现
观察者模式：行为模式，一个对象(被观察者)的状态发生改变，所有的依赖对象(观察者对象)都将得到通知，进行广播通知。
它的主要成员就是观察者和被观察者。
被观察者(0bserverable):目标对象，状态发生变化时，将通知所有的观察者。
观察者(observer):接受被观察者的状态变化通知，执行预先定义的业务。
使用场景:完成某件事情后，异步通知场景。如，登陆成功，发个M消息等等。
模式实现：一个被观察者的类Observerable、多个观察者Observer、观察者的差异化实现、经典观察者模式封装:EventBus实战
工厂模式 ：
工厂模式一般配合策略模式一起使用。用来去优化大量的if..else..或switc…cas…条件语句。
定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
单例模式：确保一个类只有一个实例，并提供一个全局访问点
工厂模式和抽象工厂的区别
简单工厂模式：
简单工厂模式是一种创建型设计模式，它通过一个工厂类来封装对象的创建过程，用户只需要通过工厂类来获取所需的对象，而无需直接调用对象的构造方法。
简单工厂模式只包含一个工厂类和多个产品类，工厂类根据用户的请求返回不同的产品对象。
简单工厂模式适用于对象类型较少、不需要频繁变化的情况下，对于新增产品类型或者修改产品构造方法时，需要修改工厂类的代码。
抽象工厂模式：
抽象工厂模式也是一种创建型设计模式，它通过一个抽象工厂接口和多个具体工厂类来创建一组相关或者相互依赖的对象，而无需指定具体的类。
抽象工厂模式包含抽象工厂接口、具体工厂类、抽象产品接口和具体产品类，每个具体工厂类负责创建一组相关的产品对象。
抽象工厂模式适用于需要创建一组相关或者相互依赖的产品对象，并且对产品的具体类型和实现进行解耦的情况下，当需要新增产品类型时，只需要添加新的具体工厂类和对应的产品类，无需修改现有代码。
综上所述，简单工厂模式主要用于创建单一类型的对象 ，工厂类负责根据用户的请求返回相应的产品对象；而抽象工厂模式主要用于创建一组相关或者相互依赖的产品对象 ，通过抽象工厂接口和具体工厂类来实现对象的创建，并且对产品的具体类型和实现进行解耦，适用于产品类型频繁变化的情况。
手写单例模式
懒汉式单例模式：只有在需要时才会创建实例 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 public class Singleton { private static Singleton instance; private Singleton () { } public static Singleton getInstance () { if (instance == null ) { synchronized (Singleton.class) { if (instance == null ) { instance = new Singleton (); } } } return instance; } }
饿汉式单例模式：如果需要在类加载时就创建实例，可以直接在静态变量中初始化 1 2 3 4 5 6 7 8 9 public class Singleton { private static Singleton instance = new Singleton (); private Singleton () { } public static Singleton getInstance () { return instance; } }
对序列化和反序列化的理解？
序列化：把内存中的对象转换为字节流，以便实现存储和运输
反序列化：根据从网络或文件获取的对象的字节流，根据字节流中保存的对象描述信息和状态，重新构建一个新的对象
序列化的目的是为了解决网络通信中的对象传输的问题，把当前jvm进程中的对象跨网络传输到另一个jvm进程中并恢复；为保证通信双方对对象的可识别，会把对象先转换为通用的解析格式如：json，xml、、再转换为字节流进行运输
实现方法：序列化对象实现Serializable接口，并再对象中添加serialVersionUID字段。
什么时候用assert
Java有没有goto
？？？拦截器与过滤器？
过滤器（Filter）：
过滤器是 Servlet 规范中定义的一种组件，用于对请求进行预处理、后处理以及过滤。过滤器可以在请求进入 Servlet 之前进行预处理，也可以在响应返回客户端之前进行后处理。过滤器主要用于对请求和响应进行修改、验证、记录日志等操作。
过滤器可以通过在 web.xml 配置文件中进行配置，也可以通过注解 @WebFilter 来声明。过滤器需要实现 javax.servlet.Filter 接口，并实现其中的 init、doFilter 和 destroy 方法。
过滤器可以对所有的请求进行过滤，例如对 URL 模式进行匹配，也可以通过编程方式动态地添加或移除过滤器。
拦截器（Interceptor）：
拦截器是 Spring 框架提供的一种机制，用于对请求进行预处理和后处理。拦截器是基于面向切面编程（AOP）的思想，可以对控制器方法进行拦截，对请求进行前置处理、后置处理、异常处理等操作。
拦截器是 Spring MVC 框架的一部分，通过实现 HandlerInterceptor 接口来定义拦截器，并通过配置文件或者 Java 配置类进行声明和注册。
拦截器可以精确地对指定的控制器方法进行拦截，可以在请求处理之前或之后进行操作，并且可以对 Model 和 View 进行修改或者增强。
区别，主要体现在以下几个方面：
所处框架 ：实现方式 ：javax.servlet.Filter 接口，并实现其中的 init、doFilter 和 destroy 方法。过滤器可以通过 web.xml 配置文件中进行配置，也可以通过注解 @WebFilter 来声明。HandlerInterceptor 接口，并实现其中的 preHandle、postHandle 和 afterCompletion 方法。拦截器的声明和注册通常是通过配置文件或者 Java 配置类来完成。功能特性 ：使用场景 ：
日志、、
函数式接口、、
函数式接口具有以下主要特点：
函数式接口的引入使得 Java 可以更加方便地支持函数式编程风格，包括：
函数式接口在实际应用中有很多场景，例如：
集合有什么。
Collection包结构，与Collections的区别
说说 List, Set, Map三者的区别
Java 的 List？
ArrayList 10 的大小，并将元素添加到数组中。使用ArrayList在每一次add的时候，会先去计算数组空间；如果空间是够的，直接追加上去；如果不够，那就得扩容。1.5倍 ，新容量的计算方式为(oldCapacity * 3)/2 + 1 即原容量的1.5倍再加1，创建一个新的数组[newData]。然后使用System.arraycopy方法（底层为native方法实现）将旧数组[elementData]中的元素复制到新数组中。这是一个高效的底层数组拷贝操作，避免了逐个元素复制的开销。最后，将新数组[newData]替换为ArrayList的内部数组[elementData]。遍历 的需求比增删要多，即便是增删也是往往在List的尾部添加就OK了。像在尾部添加元素，ArrayList的时间复杂度也就O(1)。
LinkedList增删 操作时，LinkedList 可能更具优势.
Array与ArrayList有什么不一样？
ArrayList 的 遍历;
使用 for 循环： 1 2 3 for (int j = 0 ; j < list.size(); j++) { System.out.println(list.get(j)); }
使用增强型 for 循环（for-each 循环）： 1 2 3 for (Integer num : list) { System.out.println(num); }
使用迭代器（Iterator）： 1 2 3 4 5 Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext()) { Integer num = iterator.next(); System.out.println(num); }
ArrayList 的 remove、、
根据索引删除元素；删除元素后，后面的元素会向前移动，列表的大小会减少。
根据对象删除元素：remove(Object o) 方法可以删除列表中第一次出现的指定对象。 1 list.remove(Integer.valueOf(5 ));
使用迭代器删除元素：使用 Iterator 遍历 ArrayList，并使用迭代器的 remove 方法安全地删除元素。 1 2 3 4 5 6 7 Iterator<Integer> iterator = list.iterator(); while (iterator.hasNext()) { Integer num = iterator.next(); if (num == 5 ) { iterator.remove(); } }
**ConcurrentModificationException**异常：在遍历过程中直接调用 remove() 可能会引起并发修改异常。这是因为在遍历过程中修改了集合结构，导致迭代器的检测机制检测到并抛出异常。为避免，可采用以下方法：
在迭代过程中不修改集合的结构，可以通过复制集合或者使用迭代器的 remove 方法进行安全的删除操作。
在多线程环境下，可以使用线程安全的集合类（如 ConcurrentHashMap）或者采用同步机制（如使用 synchronized 关键字或者使用 Lock）来保证集合的线程安全性。
ArrayList如何实现线程安全？
使用Collections.synchronizedList方法：这将返回一个线程安全的 List 包装器。通过这种方式，对 synchronizedList 的所有操作都会在内部被同步，从而确保线程安全。如果写入操作较为频繁，可能需要权衡使用 synchronizedList 或者其他并发集合类，具体根据业务需求来决定。 1 List<Type> synchronizedList = Collections.synchronizedList(new ArrayList <Type>());
使用CopyOnWriteArrayList类：java.util.concurrent 包下的类，它通过在修改操作时复制整个数组来实现线程安全 。这意味着在写入操作时，它会创建一个新的数组，从而不影响正在进行的读取操作。如果读取操作频繁而写入操作较少，CopyOnWriteArrayList 可能是更好的选择，因为它对于并发读取操作而言性能较好。 1 List<Type> threadSafeList = new CopyOnWriteArrayList <Type>();
CopyOnWriteArrayList的底层原理是怎样的
首先CopyOnWriteArraylst内部也是用过数组来实现的，在向CpyOnWriteAraist添加元素时，会复制一个新的数组，写操作在新数组上进行，读操作在原数组上行
并且，写操作会加锁，防止出现并发写入丢失数据的问题
写操作结束之后会把原数组指向新数组
CopyOnWriteArraylist允许在写操作时来读取数据，大大提高了读的性能，因此适合读多写少的应用场，但会占内存，同时可能读到的数据不是实时最新的教据（写线程操作结束后才能读到新数据），所以不适合实时性要求很高的场景
Vector 你了解吗？
set 集合
HashSet（Hash 表）
HashSet、HashMap 和 Hashtable 的关系。
HashSet 使用 HashMap 作为底层实现，用于存储不重复的元素。HashMap 是键值对的存储结构，而 HashSet 只存储键。Hashtable 也是键值对的存储结构，类似于 HashMap，但是是同步的，因此适合于多线程环境。HashMap 实现了 Map 接口。Hashtable 实现了 Map 接口以及 Dictionary 接口（在 Java 1.0 和 1.1 版本中使用较多，现已被 Map 接口取代）。HashMap 和 Hashtable 允许键和值为 null，而 HashSet 只允许一个 null 元素。HashMap 而不是 Hashtable，因为 Hashtable 的同步性会带来额外的性能开销。如果需要在多线程环境下使用，也可以考虑使用 Collections.synchronizedMap() 方法来创建一个同步的 HashMap。
TreeSet
TreeSet()是使用二叉树的原理对新 add()的对象按照指定的顺序排序（升序、降序），每增加一个对象都会进行排序，将对象插入的二叉树指定的位置。
Integer 和 String 对象都可以进行默认的 TreeSet 排序，而自定义类的对象是不可以的， 自己定义的类必须实现 Comparable 接口，并且覆写相应的 compareToTo()函数，才可以正常使用。
在覆写 compare()函数时，要返回相应的值才能使 TreeSet 按照一定的规则来排序
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
LinkHashSet（ HashSet+LinkedHashMap）
Map 了解多少？
HashMap
hashmap通过put(key,value)存储，通过get(key)获取。当传入key时，hashmap会调用hashcode()方法计算出hash值，根据 hash 值将 value 保存在 bucket 里
实现原理：其实就是有个 Entry 数组，Entry 保存了 key 和 value。当你要塞入一个键值对的时候，会根据一个 hash 算法计算 key 的 hash 值，然后通过数组大小 n-1 & hash 值之后，得到一个数组的下标，然后往那个位置塞入这个 Entry。（hashmap的底层是哈希表，哈希表的实现是数组+链表+红黑树）
为了解决 hash 冲突的问题，采用了链表法
在 JDK 1.7 及之前链表的插入采用的是头插法，即在链表的头部插入新的 Entry。在 JDK 1.8 的时候，改成了尾插法，并且引入了红黑树。当链表的长度大于 8 且数组大小大于等于 64 的时候，就把链表转化成红黑树，当红黑树节点小于 6 的时候，又会退化成链表。
为什么 JDK 1.8 要对 HashMap 做红黑树这个改动？主要是避免 hash 冲突导致链表的长度过长，这样 get 的时候时间复杂度严格来说就不是 O(1) 了，因为可能需要遍历链表来查找命中的 Entry。
为什么定义链表长度为 8 且数组大小大于等于 64 才转红黑树？不要链表直接用红黑树不就得了吗？因为红黑树节点的大小是普通节点大小的两倍，所以为了节省内存空间不会直接只用红黑树，只有当节点到达一定数量才会转成红黑树，这里定义的是 8（泊松分布）
为什么节点少于 6 要从红黑树转成链表？也是为了平衡时间和空间，节点太少链表遍历也很快，节约内存。
HashMap 默认大小为16，负载因子的大小为 0.75。
HashMap的大小只能是2次幂的，假设你传一个10进去，实际上最终HashMap的大小是16（具体的实现在tableSizeFor可以看到）把元素放进HashMap的时候，需要算出这个元素所在的位置（hash）。在HashMap里用的是位运算来代替取模，更加高效。HashMap的大小只能是2次幂时，才能合理用位运算替代取模。
负载因子的大小决定着哈希表的扩容和哈希冲突。比如默认的HashMap大小为16，负载因子为0.75，这意味着数组最多只能放16*0.75=12个元素，每次put元素进去的时候，都会检查HashMap的大小有没有超过这个阈值，一旦超过12，则哈希表需要扩容。如果把负载因子调高了，哈希冲突的概率会增高，同样会耗时（查找速度变慢了）
put ：首先对key做hash运算，计算出该key所在的index。如果没碰撞，直接放到数组中，如果碰撞了，需要判断目前数据结构是链表还是红黑树，根据不同的情况来进行插入。假设key是相同的，则替换到原来的值。最后判断哈希表如果满了，扩容。get ：还是对key做hash运算，计算出该key所在的index，然后判断是否有hash冲突。假设没有冲突直接返回，假设有冲突则判断当前数据结构是链表还是红黑树，分别从不同的数据结构中取出。Jdk1.7 到 Jdk1.8 HashMap 发生了什么变化(底层)?
1.7中底层是数组+链表，1.8中底层是数组+链表+红黑树，加红黑树的目的是提高HashMap插入和查询整体效率
1.7中链表插入使用的是头插法，1.8使用的是尾插法，因为1.8中插入key和value时需要判断链表元素个数，所以需要遍历链表统计链表元素个数，所以正好就直接使用尾插法
1.7中哈希算法比较复杂，存在各种右移与异或运算，1.8中进行了简化，因为复杂的哈希算法的目的就是提高散列性，来提供HashMap的整体效率，而1.8中新增了红黑树，所以可以适当的简化哈希算法，节省CPU资源
hash 函数的优化：
1.8后，在put元素的时候传递的Key，先算出正常的哈希值，然后与高16位做异或运算，产生最终的哈希值。相当于把高位和低位的特征进行组合，结果得到的数组位置的散列度一定会更高，可以增加了随机性，减少了碰撞冲突的可能性。 1 2 3 4 static final int hash (Object key) { int h; return (key == null ) ? 0 : (h = key.hashCode()) ^ (h >>> 16 ); }
HashMap 扩容 resize() ：默认是扩原来的2倍（因为HashMap的大小只能是2次幂），扩的是数组不是链表。
1.7版本：
先生成长度为原来2倍的新数组
遍历老数组中的每个位置上的链表上的每个元素
取每个元素的key，并基于新数组长度，计算出每个元素在新数组中的下标
头插法将元素添加到新数组中去
所有元素转移完了之后，将新数组赋值给HashMap对象的table属性
1.8版本：
先生成新数组，长度是老数组的2倍
遍历老数组中的每个位置上的链表或红黑树
如果是链表，则直接将链表中的每个元素里新计算下标，并添加到新数组中去
如果是红黑树，则先遍历红黑树，先计算出红黑树中每个元素对应在新数组中的下标位置：统计每个下标位置的元素个数，如果该位置下的元素个数超过了8，则生成一个新的红黑树，并将根节点的添加到新数组的对应位置；如果该位置下的元素个数没有超过8，那么则生成一个链表，并将链表的头节点添加到新数组的对应位置、
所有元素转移完了之后，将新数组赋值给HashMap对象的table属性
Java8为什么将HashMap的插入方法改为了尾插法？
头插法，即新插入的元素会插入到链表的头部，会产生以下问题：
破坏了链表元素的插入顺序：由于头插法是将新插入的元素插入到链表的头部，这样就导致链表的顺序与元素插入的顺序相反，不利于一些需要按照插入顺序遍历的场景。
容易引起链表环形问题：由于头插法需要修改链表头 ，这会导致在并发环境下，触发resize()时多个线程同时修改新数组的桶节点的链表头，可能会引起链表环形问题，使得链表无法正确遍历或者出现死循环的情况。
尾插法，即新插入的元素会插入到链表的尾部，这样可以解决很多问题并且有以下优点：。
提高查询效率：尾插法使得链表元素的插入顺序与元素插入的顺序一致，从而方便了元素的查找和遍历操作，提高了HashMap的查询效率。
避免链表环形问题：尾插法是将新插入的元素插入到链表的尾部，不需要修改链表头，因此可以避免在并发环境下多个线程修改链表头导致的链表环形问题。
1.8中插入key和value时需要判断链表元素个数，所以需要遍历链表统计链表元素个数，所以正好就直接使用尾插法
Java8及以后的版本插入操作的平均时间要比Java8之前的版本快，差距在1ms左右，这是由于Java8将HashMap的插入方法改为了尾插法，避免了链表环形问题的发生，同时优化了哈希算法和查询效率，从而提高了HashMap的性能。
LinkedHashMap？
TreeMap？
Hashtable、HashMap、TreeMap？
Hashtable
不允许使用 null 键或 null 值。
使用场景：1、当需要确保数据的线程安全，且在多线程环境中共享 Map 时，可以考虑使用 Hashtable。2、由于其性能相对较低，推荐在遗留代码中或者特定要求线程安全的小规模数据集合中使用。
HashMap
允许一个 null 键和多个 null 值。
使用场景： 1、在非多线程环境中，或者在读多写少的场景下（可以通过外部同步来解决线程安全问题），HashMap 是一个优选，因为它提供了更好的性能。 2、当需要快速查找、插入和删除键值对时，特别是在数据量较大的情况下。
当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的，但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁，并不对整个数据进行锁定。
TreeMap
key不能为null
使用场景：1、当需要一个总是保持排序状态的 Map 时，TreeMap 是最合适的选择。它适用于需要频繁地进行有序遍历或范围搜索的场景。 2、 在需要根据键进行排序的应用中，如时间线索引、自然排序的目录结构等。3、 当数据结构的大小频繁变动，且需要保持有序状态时，TreeMap 通常比维护一个 ArrayList 之后再排序要高效。
ConcurrentHashMap？
ConcurrentHashMap是线程安全的Map实现类，它在juc包下的。线程安全的Map实现类除了ConcurrentHashMap还有一个叫做Hashtable。当然了，也可以使用Collections来包装出一个线程安全的Map，但无论是Hashtable还是Collections包装出来的都比较低效（因为是直接在外层套synchronize）；
ConcurrentHashMap 本质上是一个 HashMap，因此功能和 HashMap 一样，但是ConcurrentHashMap 在 HashMap 的基础上，提供了并发安全的实现。并发安全的主要实现是通过对指定的 Node 节点加锁，来保证数据更新的安全性
底层数据结构
加锁的方式
红黑树
Red-Black Tree是一种自平衡的二叉搜索树，它通过一些附加的信息（颜色标记）保持树的平衡。这种平衡性质确保了在最坏情况下对于各种基本动态集合操作（插入、删除、查找）的性能都有较好的上界，保证了树的高度是对数级别的。
在Java中，TreeMap 和 TreeSet 类使用红黑树来实现有序 映射和有序 集合。
红黑树具有以下几个特征：
节点颜色： 每个节点都带有颜色，可以是红色或黑色。
根节点和叶子节点： 根节点和所有叶子节点（NIL节点）都是黑色的。
相邻节点颜色： 相邻的节点不能都是红色。也就是说，红色节点不能直接相连，黑色节点可以相连。
从任一节点到其每个叶子的所有路径都包含相同数目的黑色节点。
红黑树插入和删除：都可能导致树失去平衡，因此需要通过旋转和重新着色等操作来维护平衡性质。
插入操作：
将节点插入： 将新节点插入到红黑树的合适位置，通常是按照二叉搜索树的插入规则。
新节点着色为红色： 插入的新节点着色为红色，以便更容易维护平衡性质。
重新着色和旋转： 根据父节点、祖父节点、叔叔节点等之间的颜色关系，可能需要进行以下操作：
情况1： 如果父节点是黑色，那么不需要做额外操作，树仍然保持平衡。情况2： 如果父节点是红色而叔叔节点也是红色，可以通过颜色翻转来保持平衡。情况3： 如果父节点是红色而叔叔节点是黑色，并且当前节点是父节点的右子节点，可以通过左旋转和右旋转来保持平衡。情况4： 如果父节点是红色而叔叔节点是黑色，并且当前节点是父节点的左子节点，可以通过右旋转来保持平衡。
删除操作：
执行普通的二叉搜索树删除操作： 将要删除的节点从树中删除，并根据子节点的情况进行适当的替换。
重新着色和旋转： 删除操作可能破坏了红黑树的平衡性质，因此可能需要进行以下操作：
情况1： 如果删除的节点或替代节点是红色，只需将替代节点着色为黑色。情况2： 如果删除的节点是黑色，而替代节点是红色，可以将替代节点着色为黑色。情况3： 如果删除的节点和替代节点都是黑色，可能需要通过重新着色和旋转来保持平衡。
Java 集合使用泛型的好处。
可以确保类型安全，避免强制类型转换，提高代码的可读性和可维护性，能够在编译时错误检测。
“泛型” 意味着编写的代码可以被不同类型的对象所重用。
泛型类
泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。
类型通配符 一般是 使用 ? 代替具体的类型参数。 例如 List<?> 在逻辑上是List, List 等所有 List<具体类型实参>的父类。 1 2 3 4 5 6 7 8 9 public class Box <T> { private T t; public void add (T t) { this .t = t; } public T get () { return t; } }
类型擦除
Java 中的泛型基本上都是在编译器这个层次来实现的，在生成的字节代码中是不包含泛型中的类型信息的。 和 List<?> 等类型在编译时会被擦除为原始类型 List。JVM 看到的只是 List，而由泛型附加的类型信息对 JVM 是不可见的。这个过程就称为类型擦除。
类型擦除的基本过程是找到用来替换类型参数的具体类，一般是 Object。如果指定了类型参数的上界的话，则使用这个上界。编译器会将代码中的类型参数都替换成具体的类。这种替换的行为是泛型在 Java 中实现的一部分，它确保了泛型代码在运行时不会受到泛型类型信息的影响，从而保持了 Java 的向后兼容性。 1 2 3 4 5 6 7 8 9 10 11 12 public class MyClass <T> {} public class MyClass {} public <T> void myMethod (T item) {} public void myMethod (Object item) {}
??单例Bean和单例模式？什么是 spring 的内部 bean？
SpringBean生命周期原理。
实例化Bean：反射的方式创建对象
设置对象属性（依赖注入）：populateBean(),循环依赖的问题(三级缓存)
处理Aware接口：接着，Spring会检测该对象是否实现了xxxAware接口，并将相关的xxxAware实例注入给Bean。invokeAwareMethod(完成BeanName,BeanFactory,BeanClassLoader对象的属性设置）
如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的就是Spring配置文件中Bean的id值；
如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()方法，传递的是Spring工厂自身。
如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文；
BeanPostProcessor：如果想对Bean自定义处理，那么可以让Bean实现了BeanPostProcessor接口，那将会调用postProcessBeforeInitialization(Object obj, String s)方法。
InitializingBean 与 init-method：如果Bean在Spring配置文件中配置了 init-method 属性，则会自动调用其配置的初始化方法。
调用BeanPostProcessor的后置处理方法:若存在与 bean 关联的任何 BeanPostProcessors，则将调用 postProcessAfterInitialization()方法。
获取到完整的对象，可以通过getBean的方式来进行对象的获取
DisposableBean：当Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用其实现的destroy()方法；
destroy-method：最后，如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法
Spring中Bean是线程安全的吗
Spring 是如何解决循环依赖问题的？https://www.bilibili.com/video/BV1Mc411S7B7?p=12&vd_source=ff210768dfaee27c0d74f9c8c50d7274
三级缓存的作用是什么？Spring 中哪些情况下，不能解决循环依赖问题？
缓存的放置时间、删除时间，，https://www.bilibili.com/video/BV1Mc411S7B7?p=14&vd_source=ff210768dfaee27c0d74f9c8c50d7274
Spring AOP
AOP 可以用于的一些常见场景：
权限控制： AOP 可以用于在方法执行前或执行后添加权限控制的逻辑，例如检查用户是否有足够的权限执行某个操作。这样可以避免将权限检查逻辑散布在业务代码的各个地方。事务控制： AOP 可以用于管理事务，例如在方法执行前开启事务，在方法执行后根据执行结果决定是提交事务还是回滚事务。这样可以确保事务的一致性和可靠性。日志记录： AOP 可以用于添加日志记录逻辑，例如在方法执行前记录方法的输入参数，方法执行后记录返回结果。这样可以方便地进行日志管理和分析。性能监控： AOP 可以用于添加性能监控逻辑，例如在方法执行前记录开始时间，在方法执行后记录结束时间，计算方法的执行时间。方便进行性能分析和优化。异常处理： AOP 可以用于添加异常处理逻辑，例如捕获方法执行过程中的异常并进行统一处理。这样可以减少业务代码中的异常处理逻辑，提高代码的清晰度。缓存管理： AOP 可以用于添加缓存管理逻辑，例如在方法执行前检查是否有缓存命中，如果有直接返回缓存结果，否则执行方法并将结果缓存起来。
AspectJ？Spring AOP和AspectJ AOP有什么区别?
AOP是一种思想，AspectJ是一种实现。SpringAOP中已经集成了AspectJ，AspectJ应该算得上是Java生态系统中最完整的AOP框架了。
SpringAOP是属于运行时增强，而Aspect是编译时增强。 SpringAOP基于代理(Proxying)，而AspectJ基于字节码操作(BytecodeManipulation)。
什么是 Aspect（切面）？
在SpringAOP中，关注点和横切关注的区别是什么？什么是连接点呢？切入点是什么？什么是通知呢，有哪些类型呢?
关注点是应用中一个模块的行为，一个关注点可能会被定义成一个我们想实现的一个功能。
横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日志，安全和数据传输。
连接点代表一个应用程序的某个位置，在这个位置我们可以插入一个AOP切面，它实际上是个程序执行SpringAOP的位置。
切入点（JoinPoint）是一个或一组连接点，通知将在这些位置执行。可以通过表达式或匹配的方 式指明切入点。
通知（Advice）是个在方法执行前或执行后要做的动作（特定 JoinPoint 处的 Aspect 所采取的动作），实际上是程序执行时要通过SpringAOP框架触发的代码段。Spring切面可以应用五种类型的通知:
Before：这类 Advice 在 joinpoint 方法之前执行，并使用@Before 注解标记进行配置。
After Returning：这类型 Advice 在连接点方法正常执行后执行，并使用@AfterReturning 注解标记进行配置。
After Throwing：这些类型的 Advice 仅在 joinpoint 方法通过抛出异常退出并使用 @AfterThrowing 标记配置时执行。
After (finally)： 在连接点方法之后执行，无论方法退出是正常还是异常返回，并使用 @After 注解标记进行配置。
Around：在连接点之前和之后执行，并使用@Around 注解标记进行配置。
AOP 有哪些实现方式？
静态代理：使用 AOP 框架提供的命令进行编译，在编译阶段就可生成 AOP 代理类，因此也称编译时增强；
编译时编织（特殊编译器实现）
类加载时编织（特殊的类加载器实现）。
动态代理：在运行时在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。
Spring AOP and AspectJ AOP 有什么区别？
什么是编织（Weaving）？
如何理解 Spring 中的代理？
??? SpringAOP的底层实现
总: aop概念，应用场景，动态代理
分: bean的创建过程中有一个步骤可以对bean进行扩展实现，aop本身就是IOC 的一个扩展功能，所以在BeanPostProcessor的后置处理方法中来进行实现
在工作中实际用到过AOP优化代码吗？？？
Spring DAO
Spring事务管理：
Spring框架提供的一种事务管理机制，它简化了事务管理的操作，并提供了对不同事务管理器的统一接口。两种方式：
声明式事务：通过在方法上使用 @Transactional 注解来声明事务。这种方式更为常用，允许开发者将精力集中在业务逻辑上，而不需要关心事务的开始、提交或回滚。 1 2 3 4 @Transactional public void myTransactionalMethod () { }
编程式事务：通过编写代码手动管理事务的开始、提交或回滚。虽然不太常用，但在一些特殊情况下可能会用到。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 @Autowired private PlatformTransactionManager transactionManager;public void myProgrammaticMethod () { DefaultTransactionDefinition def = new DefaultTransactionDefinition (); TransactionStatus status = transactionManager.getTransaction(def); try { transactionManager.commit(status); } catch (Exception e) { transactionManager.rollback(status); throw e; } }
Spring事务是如何回滚的？
即：Spring事务管理是怎么实现的？
总：spring的事务是由aop来实现的，首先要生成具体的代理对象，然后按照aop的整套流程来执行具体的操作逻辑，正常情况下要通过通知来完成核心功能，但是事务不是通过通知来实现的，而是通过一个TansactionInterceptor 来实现的，然后调用invoke()实现具体的逻辑
？？？分：
Spring中的事务是如何实现的
Spring事务传播机制https://www.bilibili.com/video/BV1Mc411S7B7?p=18&vd_source=ff210768dfaee27c0d74f9c8c50d7274
Spring事务什么时候会失效?
Spring中常见的设计模式。
单例模式 ：Spring默认情况下，容器中的Bean是单例的，即每个容器中的Bean只有一个实例。有助提高性能和减少资源消耗原型模式：指定作用域为prototype
工厂模式 ：Spring通过工厂模式实现了IOC（Inversion of Control）容器，使得对象的创建和管理被委托给了Spring容器。 BeanFactory代理模式 ：Spring AOP就是通过代理模式实现的。AOP允许开发者在不修改原始代码的情况下，插入和控制横切关注点，如日志、事务等。责任链模式：使用aop时先生成一个拦截器链
模板方法模式 ： 在Spring中，JdbcTemplate 和 RedisTemplate 等模板类使用了模板方法模式，将通用的任务实现在模板方法中，而将具体实现留给子类。观察者模式：Spring的事件机制是基于观察者模式的。通过定义事件和监听器，应用程序可以订阅感兴趣的事件，从而实现松耦合的通信机制。
策略模式：Spring的资源加载、事务管理等功能用了策略模式，通过定义一组算法族分别封装起来，并使它们可以相互替换。
适配器模式：SpringAOP中通知（Advice）就是一种适配器模式的应用。通知包装了一个切面逻辑，使得它可以在切点（Join Point）上执行。
装饰者模式：BeanWrapper
适配器模式：Adapter
什么是 Spring Boot？起步依赖和自动配置： 使用starter启动器能够自动依赖其他组件，减少了Maven配置的繁琐性；Spring Boot根据当前类路径和jar包自动配置bean，例如，添加spring-boot-starter-web启动器即可拥有web功能，无需额外的配置。因此，Spring Boot 可以帮助我们以最少的工作量，更加健壮地使用现有的 Spring功能。
为什么要用SpringBoot？
独立运行和简化部署： Spring Boot内嵌了各种servlet容器（如Tomcat、Jetty、Undertow），使得应用能够独立运行，无需打成war包部署到外部容器。通过打包成可执行的jar包，所有依赖包都在一个jar包内，简化了部署和运维。简化配置和自动配置： 使用starter启动器能够自动依赖其他组件，减少了Maven配置的繁琐性。Spring Boot根据当前类路径和jar包自动配置bean，例如，添加spring-boot-starter-web启动器即可拥有web功能，无需额外的配置。无代码生成和XML配置： Spring Boot的配置过程中无需代码生成，也不需要XML配置文件，通过条件注解实现自动配置，进一步简化了项目配置。
应用监控和健康检测： Spring Boot提供了一系列端点用于监控服务和应用，实现健康检测等功能。
减少开发、测试时间和努力： 提供快速启动开发的默认值，减少了开发和测试的时间和工作量。
使用JavaConfig避免XML配置： 倡导使用JavaConfig替代XML配置，提高了代码的可读性和维护性。
提供意见发展方法： Spring Boot提供了一套推荐的开发方法，使得团队更容易达成共识，提高了代码的一致性和规范性。
基于环境的配置： 支持基于环境的配置，通过传递环境参数（例如-Dspring.profiles.active={environment}），可以在不同环境中灵活配置应用程序。
如何创建 Spring Boot Projects ？
Spring Initiatlizr 让创建 Spring Boot 项目变的很容易，通过 start.spring.io 创建。
手动设置一个 Maven 项目为 Spring Boot 项目：
添加 Spring Boot 依赖： 在 Maven 项目的 pom.xml 文件中，添加 Spring Boot 的依赖。通常，你可以添加 spring-boot-starter 或其他特定的 Starter 依赖，具体依赖根据项目需求而定。 1 2 3 4 5 6 7 8 <dependencies > <dependency > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-starter</artifactId > </dependency > </dependencies >
添加 Spring Boot 插件： 在 pom.xml 中添加 Spring Boot Maven 插件。插件用于打包和运行 Spring Boot 应用程序。 1 2 3 4 5 6 7 8 <build > <plugins > <plugin > <groupId > org.springframework.boot</groupId > <artifactId > spring-boot-maven-plugin</artifactId > </plugin > </plugins > </build >
创建 Spring Boot 主类： 在项目中创建一个包含 main 方法的主类，该类用于启动 Spring Boot 应用程序。这个类通常被注解为 @SpringBootApplication。添加其他 Spring Boot 配置： 根据项目需求，配置其他 Spring Boot 特性，如数据源、JPA、Web 支持等。可以通过配置文件（application.properties 或 application.yml）或 Java 配置类进行配置。
Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？
Spring Boot中常用注解及其底层实现
@Bean注解:用来定义Bean，类似于XML中的bean>标签，Spring在启动时，会对加了@Bean注解的方法进行折，将方法的名字做为beanName，并通过执行方法得到bean对象
Bean处理
@Autowired：依赖注入
@Component：泛指组件
@Controller、@Service、@Repository
@RestController
@Configuration
Http请求：@GetMapping、@PostMapping、@PutMapping、@DeleteMapping
前后端参数传递：
@RequestParam：用在方法的参数前面，获取请求中表单类型的key=value格式的数据
@PathVariable：路径变量，参数与大括号里的名字一样要相同
@RequestBody：获取请求body中的数据，常用于搭配@PostMapping请求来提交对象数据
@ResponseBody：表示该方法的返回结果直接写入HTTP response body中，格式为json
读取配置
@value：直接读取各种配置源的属性名
@ConfigurationProperties：读取配置信息并与 bean 绑定
@PropertySource：指定加载自定义的配置文件
参数校验
Bean字段验证注解：@Null、@Min()、，，？？
？？@Valid：用于标注验证对象的级联属性
？？@Validated：Spring提供的注解，于SpringMVC一起使用标注方法参数需要检查
统一异常处理
@ControllerAdvice：注解定义全局异常处理类，包含@Component所以可以被Spring扫描到
@ExceptionHandler：注解声明异常处理方法，表示遇到这个异常，就执行标注的方法
JPA数据持久化
@Entity：声明数据库实体类
@Table：设置表明
@ld：声明一个字段为主键
@GeneratedValue：声明主键的生成策略
@Column：声明字段，经常用于属性名和表字段的映射
@Transient：指定不需要持久化的字段
@Lob：声明某个字段为大字段
@Enumerated：声明枚举类型的字段
@Modifying：加在DAO方法上，提示是修改操作
@Transactional
作用于类上：表示所有该类的public 方法都配置相同的事务属性信息
作用于方法上：当类配置了@Transactional，方法也配置了@Transactional，方法的事务会覆盖类的事务配置信息
测试处理
@ActiveProfiles：常作思于测试类上，用于声明生效的 Spring 配置文件
@Test：声明一个方法为测试方法
@Transactional：被声明的测试方法的数据会回滚，避免污染测试数据
@WithMockUser：Spring Security 提供的，用来模拟一个真实用户，并且可以赋予权限
配置启动
@SpringBootApplication注解: 这个注解标识了一个SpringBoot工程，它实际上是另外三个注解的组合:
@Conditional
@ConditionalOnBean：配置了某个特定的Bean
@ConditionalOnMissingBean：没有配置特定的Bean
@ConditionalOnClass：Classpath里有指定的类
@ConditionalOnMissingClass：Classpath里没有指定的类
@ConditionalOnExpression：给定的SpEL表达式计算结果为true
@ConditionalOnJava：Java的版本匹配特定值或者一个范围值
@ConditionalonIndi：参数中给定的INDI位置必须存在一个，如果没有给参数，则要有JNDIInitialContext
@ConditionalOnProperty：指定的配置属性要有一个明确的值
@ConditionalOnResource：Classpath里没有指定的资源
@ConditionalOnWebApplication：这是一个Web应用程序
@ConditionalOnNotWebApplication：这不是一个Web应用程序
？？说说SpringBoot自动配置 。@ConditionalXXX进行判断的。比如Redis的配置类就会有@ConditionalOnClass({RedisOperations.class})的配置，说明当前环境下如果有RedisOperations.class这个字节码，才会去加载Redis的配置类。
？？Spring Boot 中自动装配机制的原理。@SpringBootApplication 注解就可以实现自动装配。@EnableAutoConfiguration 。自动装配的实现主要依靠三个核心关键技术。
Spring Boot 属性源
你对SpringBoot starter的理解？
常用的starter。
Spring Boot是如何启动Tomcat的
？？？Spring Boot中的监视器是什么？如何在 Spring Boot 中禁用 Actuator 端点安全性？
如何使用Spring Boot实现异常处理？
SpringBoot 实现热部署有哪几种方式？
如何实现 Spring Boot 应用程序的安全性？
Spring Boot 支持哪些日志框架？推荐和默认的日志框架是哪个？
Spring Boot 2.X 有什么新特性？与 1.X 有什么区别？
SpringBoot 集成 Mybatis 的过程
如何对Spring Boot应用进行测试？
Spring Boot 项目结构
Spring Boot 项目通常遵循一种约定大于配置的原则，并提供了一种建议的项目结构，使得开发者可以更轻松地组织和管理项目。以下是一个常见的 Spring Boot 项目结构示例： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 my-spring-boot-project |-- src | |-- main | |-- java | | |-- com | | |-- example | | |-- MySpringBootApplication.java | | |-- controller | | |-- HomeController.java | | |-- service | | |-- MyService.java | |-- resources | |-- application.properties | | |-- static | | |-- templates |-- target |-- pom.xml
src/main/java: 存放 Java 源代码。com.example.MySpringBootApplication: Spring Boot 应用程序的主类，包含 main 方法，用于启动应用程序。com.example.controller: 存放控制器类，处理 HTTP 请求。com.example.service: 存放服务类，处理业务逻辑。src/main/resources: 存放资源文件。application.properties: Spring Boot 应用程序的配置文件，用于配置各种属性。static: 存放静态资源文件，如 CSS、JavaScript 等。templates: 存放模板文件，如 Thymeleaf 模板。target: Maven 构建目录，包含编译后的类文件和构建产物。pom.xml: Maven 项目的配置文件，定义项目的依赖和构建配置。
最后聊下你是怎么看这块源码的？？？
什么是 Spring Cloud？
使用 Spring Cloud 有什么优势？
高可用性： 分布式架构能够提高系统的可用性。通过将系统划分为多个服务并分布在不同的节点上，即使某个节点或服务出现故障，整个系统仍然能够继续运行。扩展性： 分布式系统可以更容易地进行横向扩展。通过增加节点或服务，系统可以更好地处理增加的负载，提高性能和吞吐量。容错性： 分布式系统能够通过冗余和备份机制来提高容错性。即使某个节点或服务出现故障，备份节点或服务可以接管工作，保证系统的正常运行。灵活性： 分布式系统能够更好地支持异构性，即不同类型的硬件、操作系统和编程语言。这使得系统更加灵活，能够选择最适合特定任务的技术栈。资源共享： 分布式系统可以充分利用多个节点的计算和存储资源，实现资源的共享和最优化利用。降低单点故障风险： 分布式系统通过将系统划分为多个部分，降低了单点故障的风险。即使某个节点或服务出现问题，其他部分仍然可以继续运行。地理分布： 分布式系统支持地理分布，使得服务可以部署在不同的地理位置，提高服务的可用性和响应速度。提高性能： 分布式系统可以通过并行计算和分布式存储来提高性能。任务可以同时在多个节点上执行，加速处理过程。
使用 Spring Boot 开发分布式微服务时，我们面临以下问题
Spring Cloud 中的五大组件。
Eureka（服务注册与发现）： 服务注册与发现框架。它用于管理各个微服务的状态，以实现服务之间的通信和发现。Ribbon（负载均衡）： Ribbon 是一个基于 HTTP 和 TCP 的客户端负载均衡工具，在服务消费者的请求中自动实现负载均衡，从而分摊到多个服务提供者上。Feign（声明式服务调用）： Feign 是一个声明式的伪 HTTP 客户端，它使得编写 HTTP 客户端变得更加简单。通过 Feign，开发者只需使用注解方式就可以轻松地调用服务，而不用手动处理 HTTP 请求和响应。Hystrix（熔断器）： 一种延迟和故障容错库，用于隔离访问远程服务、第三方库或者服务的点，防止故障蔓延到整个系统，从而提高系统的弹性和可用性。Zuul（API 网关）： Zuul 是 Netflix 提供的一个基于 JVM 路由和服务端的负载均衡器，用于构建微服务架构中的 API 网关，对外统一提供服务访问入口，并提供了路由、负载均衡、熔断、安全等功能。
服务注册和发现是什么意思？Spring Cloud 如何实现？
负载平衡的意义什么？
什么是 Hystrix？？？
什么是微服务
什么是服务熔断？服务降级？
说说 RPC 的实现原理
REST 和RPC对比
微服务的优点缺点?说下开发项目中遇到的坑?
Spring Cloud 和 Dubbo 有哪些区别?
Eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别？
Ribbon和Feign的区别？
Spring Cloud Gateway?
什么是 Ribbon负载均衡？
全局过滤器的作用也是处理一切进入网关的请求和微服务响应，与路由过滤器GatewayFilter的作用一样。
区别在于GatewayFilter通过配置定义，可以自由的指定作用的范围，配置自定义参数，使用灵活，但处理逻辑是固定的，难以自定义GatewayFilter；
而GlobalFilter可以自己写代码实现，实现需要的业务逻辑，需要自定义过滤器时大多会选择 GlobalFilter。
