java 基础知识点
1.面向对象的特性：封装，继承，多态(Overload和Override)
2.基础数据类型：整形：int、long、short、byte；浮点型：double、folat；字符型：char；布尔型：boolean
3.缓存池：
public class Main_1 {
public static void main(String[] args) {
Integer a = 1;
Integer b = 2;
Integer c = 3;
Integer d = 3;
Integer e = 321;
Integer f = 321;
Long g = 3L;
System.out.println(c == d);//true，缓存池
System.out.println(e == f);//false，不在缓存池
System.out.println(c == (a + b));//true
System.out.println(c.equals(a + b));//true
System.out.println(g == (a + b));//true
System.out.println(g.equals(a + b));//false
System.out.println(g.equals(a + h));//true
}
4.String：String 被声明为 final，因此它不可被继承。
5.StringBuilder、StringBuffer：StringBuilder 不是线程安全的
StringBuffer 是线程安全的，内部使用 synchronized 进行同步
6.参数传递：Java 的参数是以值传递的形式传入方法中，而不是引用传递。
public class PassByValueExample {
public static void main(String[] args) {
Dog dog = new Dog("A");
System.out.println(dog.getObjectAddress()); // Dog@4554617c
func(dog);
System.out.println(dog.getObjectAddress()); // Dog@4554617c
System.out.println(dog.getName()); // A
}
private static void func(Dog dog) {
System.out.println(dog.getObjectAddress()); // Dog@4554617c
dog = new Dog("B");
System.out.println(dog.getObjectAddress()); // Dog@74a14482
System.out.println(dog.getName()); // B
}
如果在方法中改变对象的字段值会改变原对象该字段值，因为改变的是同一个地址指向的内容
class PassByValueExample {
public static void main(String[] args) {
Dog dog = new Dog("A");
func(dog);
System.out.println(dog.getName()); // B
}
private static void func(Dog dog) {
dog.setName("B");
}
7.访问权限：Java 中有三个访问权限修饰符：private、protected 以及 public，如果不加访问修饰符，表示包级可见。
protected 用于修饰成员，表示在继承体系中成员对于子类可见
8.抽象类与接口：抽象类和普通类区别是抽象类不能被实例化，需要继承抽象类才能实例化其子类。
一个类可以实现多个接口，但是不能继承多个抽象类，接口的字段只能是 static 和 final 类型的，接口的成员只能是 public 的
9.hashCode:hashCode() 返回散列值，而 equals() 是用来判断两个对象是否等价。等价的两个对象散列值一定相同，但是散列值相同的两个对象不一定等价。
==:基本数据类型:比较的是他们的值;引用类型:比较的是他们在内存中的存放地址
" == "是比较两个变量栈中的内容是否相等，而与之相对应的"equals"则是比较堆中的内容是否相等
hashCode:如果a=b，则h(a) = h(b);如果a!=b，则h(a)与h(b)可能得到相同的散列值。
a.hashCode()==b.hashCode() 则 a.equals(b)可真可假;a.hashCode()！= b.hashCode() 则 a.equals(b)为假。
public static void main(String[] args) {
int int1 = 12;
int int2 = 12;
Integer Integer1 = new Integer(12);
Integer Integer2 = new Integer(12);
Integer Integer3 = new Integer(127);
Integer a1 = 127;
Integer b1 = 127;
Integer a = 128;
Integer b = 128;
String s1 = "str";
String s2 = "str";
String str1 = new String("str");
String str2 = new String("str");
System.out.println("int1==int2:" + (int1 == int2)); //true
System.out.println("int1==Integer1:" + (int1 == Integer1)); //true
System.out.println("Integer1==Integer2:" + (Integer1 == Integer2)); //false
System.out.println("Integer3==b1:" + (Integer3 == b1)); //false
System.out.println("a1==b1:" + (a1 == b1)); //true
System.out.println("a==b:" + (a == b)); //false
System.out.println("s1==s2:" + (s1 == s2)); //true
System.out.println("s1==str1:" + (s1 == str1)); //false
System.out.println("str1==str2:" + (str1 == str2)); //false
}
10.深拷贝，浅拷贝：拷贝实现:实现Cloneable接口，否则报java.lang.CloneNotSupportedException错误。
浅拷贝:拷贝对象和原始对象的引用类型引用同一个对象;
深拷贝：对每一个引用对象重写clone方法或者通过对象序列化实现深拷贝（推荐使用）
11.static：静态变量：又称为类变量，也就是说这个变量属于类的，类所有的实例都共享静态变量
静态方法必须有实现，也就是说它不能是抽象方法（abstract）
初始化顺序：父类（静态变量、静态语句块）=》子类（静态变量、静态语句块）=》父类（实例变量、普通语句块）
=》父类（构造函数）=》子类（实例变量、普通语句块）=》子类（构造函数）
12.反射：
13.异常：NullPointerException 空指针异常
ArithmeticException 算术异常，比如除数为零
ClassCastException 类型转换异常
ConcurrentModificationException同步修改异常，遍历一个集合的时候，删除集合的元素，就会抛出该异常
IndexOutOfBoundsException 数组下标越界异常
NegativeArraySizeException 为数组分配的空间是负数异常
Error和Exception都实现了Throwable接口，Error指的是JVM层面的错误，比如内存不足OutOfMemoryError
Exception 指的是代码逻辑的异常，比如下标越界OutOfIndexException
14.泛型：
15.&和&&的区别：长路与&：两侧，都会被运算；短路与&&：只要第一个是false，第二个就不进行运算了
16.堆和栈：stack栈是存放基本类型(int, float, boolean 等等)、引用(对象地址)、方法调用；heap堆是存放对象的和常量池
17.char：char是16位的，占两个字节汉字通常使用GBK或者UNICODE编码，也是使用两个字节；所以可以存放汉字
18.进程和线程：进程是内存中的一个程序，线程是进程的最小执行单元，一个进程可以有多个线程
19.sleep，wait，join的区别：
sleep：当前线程将睡眠 n 毫秒，线程进入阻塞状态。当睡眠时间到了，会解除阻塞，进行运行状态，等待 CPU 的到来，不释放对象锁
wait：线程停止，并释放对象锁，必须使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程
join：等线程执行完再执行主线程
20.ThreadLocal：
21.内存泄露：
静态变量的生命周期和应用程序一致，所有的对象Object也不能被释放，因为他们也将一直被Vector等应用着。
各种连接，数据库连接，网络连接，IO连接等没有显示调用close关闭，不被GC回收导致内存泄露
监听器的使用，在释放对象的同时没有相应删除监听器的时候也可能导致内存泄露。
22.Java 与 C++ 的区别
Java 是纯粹的面向对象语言，所有的对象都继承自 java.lang.Object，
C++ 为了兼容 C 即支持面向对象也支持面向过程。
Java 通过虚拟机从而实现跨平台特性，但是 C++ 依赖于特定的平台。
Java 没有指针，它的引用可以理解为安全指针，而 C++ 具有和 C 一样的指针。
Java 支持自动垃圾回收，而 C++ 需要手动回收。
Java 不支持多重继承，只能通过实现多个接口来达到相同目的，而 C++ 支持多重继承。
Java 不支持操作符重载，虽然可以对两个 String 对象支持加法运算，但是这是语言内置支持的操作，不属于操作符重载，而 C++ 可以。
Java 的 goto 是保留字，但是不可用，C++ 可以使用 goto。
Java 不支持条件编译，C++ 通过 #ifdef #ifndef 等预处理命令从而实现条件编译。
23.事务：事务简单来说：一个 Session 中所进行所有的操作，要么同时成功，要么同时失败
原子性（Atomicity）：事务作为一个整体被执行 ，要么全部执行，要么全部不执行
一致性（Consistency）：保证数据库状态从一个一致状态转变为另一个一致状态
隔离性（Isolation）：多个事务并发执行时，一个事务的执行不应影响其他事务的执行
持久性（Durability）：一个事务一旦提交，对数据库的修改应该永久保存
24.事务的隔离级别：
读未提交（READ UNCOMMITTED）：最低级别的隔离，通常又称为dirty read，它允许一个事务读取另一个事务还没 commit 的数据，
这样可能会提高性能，但是会导致脏读问题；
读已提交（READ COMMITTED）：在一个事务中只允许对其它事务已经 commit 的记录可见，该隔离级别不能避免不可重复读问题；
可重复读（REPEATABLE READ）：在一个事务开始后，其他事务对数据库的修改在本事务中不可见，直到本事务 commit 或 rollback。
但是，其他事务的 insert/delete 操作对该事务是可见的，也就是说，该隔离级别并不能避免幻读问题。在一个事务中重复 select 的结果一样，除非本事务中 update 数据库。
序列化（SERIALIZABLE）：最高级别的隔离，只允许事务串行执行。
25.乐观锁和悲观锁：
悲观锁：假定会发生并发冲突，屏蔽一切可能违反数据完整性的操作，悲观锁是一种利用数据库内部机制提供的锁的方式，也就是对更新的数据加锁，
这样在并发期间一旦有一个事务持有了数据库记录的锁，其他的线程将不能再对数据进行更新了，这就是悲观锁的实现方式。
我们使用了 select…for update 的方式，这样就通过开启排他锁的方式实现了悲观锁
优点与不足：悲观并发控制实际上是“先取锁再访问”的保守策略，为数据处理的安全提供了保证。但是在效率方面，处理加锁的机制会让数据库产生额外的开销，
还有增加产生死锁的机会；另外，在只读型事务处理中由于不会产生冲突，也没必要使用锁，这样做只能增加系统负载；还有会降低了并行性，一个事务如果锁定了某行数据，
其他事务就必须等待该事务处理完才可以处理那行数
乐观锁：假设不会发生并发冲突，只在提交操作时检查是否违反数据完整性。
使用版本号时，可以在数据初始化时指定一个版本号，每次对数据的更新操作都对版本号执行+1操作。并判断当前版本号是不是该数据的最新的版本号
26.谈谈对spring的理解：spring可以实现java模块化开发，贯穿表现层，业务层，逻辑层，实现了各个层之间的解耦合关系。核心有三点：
控制反转（IOC）：传统的java 开发模式中，当需要一个对象时，我们会自己使用 new 或者 getInstance 等直接或者间接调用构造方法创建一个对象。
而在spring 开发模式中，spring 容器使用了工厂模式为我们创建了所需要的对象，不需要我们自己创建了，直接调用spring 提供的对象就可以了，这是控制反转的思想
面向切面编程（AOP）：在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程中，我们将一个个的对象某些类似的方面横向抽成一个切面， 对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。
AOP 底层是动态代理，如果是接口采用JDK 动态代理，如果是类采用CGLIB 方式实现动态代理。AOP 底层是动态代理，如果是接口采用JDK 动态代理，如果是类采 用 CGLIB 方式实现动态代理。
依赖注入（DI）：Spring 使用 JavaBean 对象的 set 方法或者带参数的构造方法为我们在创建所需对象时将其属性自动设置所需要的值的过程，就是依赖注入的思想
27.Spring事务：加到Service层 @Transactional
28.java注解：
@controller 控制器：用于标注控制层，相当于struts中的action层。
@service：服务层用于标注服务层，主要用来进行业务的逻辑处理。
@repository DAO层（Repo层）：用于标注数据访问层，也可以说用于标注数据访问组件，即DAO组件。
@Autowired 注入实例表示被修饰的类需要注入对象,spring会扫描所有被@Autowired标注的类,然后根据 类型 在ioc容器中找到匹配的类注入。
29.java表单重复提交常用解决办法：
通过前端解决：让提交按钮只触发一次，提交按钮变灰
后端：生成随机token对比；数据库唯一判断；