java基础刷题知识点总结.docx

java基础刷题知识点总结
基础
1. object类的方法有哪些
clone() protect 创建并返回一个对象的副本
equals()用来比较某个对象是否与调用此方法的对象相等
finalize() protect
getClass() 返回一个对象的运行时类
hashCode()返回一个对象的hash值
notify()唤醒在此对象监听器上等待的单个线程。如果有多个，则随机唤醒一个
notifyAll()唤醒在此对象监听器上等待的所有线程
registerNatives() 本地私有方法，在类初始化是会调用此方法
toString() 返回当前对象的字符串表示
wait()使当前线程处于等待直到其他线程调用这个对象的notify或notifyAll方法或者超过指定的时间量
2. 接口和抽象类的区别
1. 首先描述接口和抽象类的特性
抽象类：是子类通用特性的集合
接口:是抽象方法的集合l
从某种意义上说抽象类包含了接口的所有功能。但是通过实现接口可以实现多继承
下面列出接口和抽象类的区别
参数
抽象类
接口
默认的实现方法
可以有默认的实现方法
接口是完全抽象的，根本不存在默认的实现方法
实现
子类使用extends关键字来继承抽象类。如果子类不是抽象类，他必须提供抽象类中所有申明的方法的实现
子类使用implements关键字来实现接口。子类必须提供接口中所有申明的方法的实现

接口还有可以继承子接口
构造器
可以有构造器，但是不能实例化
不能有构造器
与正常java类的区别
除了不能实例化，没什么区别
不是通一个概念
访问修饰符
抽象方法可以有public,protected,default这些修饰符
接口只能是public
main方法
抽象类可以有main方法，并且可以运行
接口没有
多继承
不能实现
通过实现接口可以实现多继承
添加新方法
如果你抽象类中增加新的方法，你可以提供默认的实现，没有必要改变继承该抽象的类的子类
如果往接口中添加新的方法，子类必须在原来的基础上修改并实现新的方法
什么时候用抽象类和接口
1.如果一些方法必须提供默认的实现，就必须用抽象类，比如在dao层，每个类都有增删查改这几个操作，我们可以把这些操作写在抽象类里，并让抽象类提供默认的实现。
否则的话用接口
2. 假如要实现多继承，则必须要用接口,java不支持多继承但是可以通过实现多个接口来解决
3. 如果基本功能在不断改变，那么就用抽象类。如果不断改变基本功能并且使用接口，子类就必须不停的更改

03.抽象类是否有构造方法
抽象类有构造方法 只是抽象类不能够实例化
4.Final finally finalize()方法的区别
5.Sleep()和wait()的区别
① 这两个方法来自不同的类分别是，sleep来自Thread类，和wait来自Object类。
sleep是Thread的静态类方法，谁调用的谁去睡觉，即使在a线程里调用b的sleep方法，实际上还是a去睡觉，要让b线程睡觉要在b的代码中调用sleep。
② 锁: 最主要是sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。
sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源，其他线程可以占用CPU。一般wait不会加时间限制，因为如果wait线程的运行资源不够，再出来也没用，要等待其他线程调用notify/notifyAll唤醒等待池中的所有线程，才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)可以用时间指定使它自动唤醒过来，如果时间不到只能调用interrupt()强行打断。
Thread.sleep(0)的作用是“触发操作系统立刻重新进行一次CPU竞争”。
③ 使用范围：wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，配合synchronized实现等待通信机制，而sleep可以在任何地方使用。
   synchronized(x){ 
      x.notify() 
     //或者wait() 
   }

6.short s=1;s=1+s;会报错吗?short s=1;s+=1;会报错吗?
(1) 报incompatible types错误。不相容的类型错误
(2) 不报错。因为s+=1相当于s=(E)(s+1),其中E为s的类型
7.Overload和override的区别

Overload是重载，它是一个类中多态性的一种表现。
Override是重写，它是子类与父类多态性之间的一种表现。
重载是指在定义多个名字相同的方法。但这些方法的返回值类型，参数类型，参数顺序，参数个数必须有一个不同，但是不能只是返回值类型不同的，因为这会使得jvm在调用方法时，不知道该调用谁
重写是覆盖掉父类的方法并重新定义一个新的方法，新的方法的返回值类型，参数类型，参数个数，参数顺序都必须跟父类中的方法保持一致。

以下是这两种定义的具体注意事项
（1）Overload 重载
1.方法的返回值类型，参数的类型，个数，顺序存在不同
2.但不能只有返回值类型
3.是针对一个类而言的
（2）override重写
1.方法的返回值类型，参数的类型，个数，顺序必须一致
2．是针对父类与子类而言的
3.定义为final的方法不能重写
4.重写的方法不能缩小包的访问权限
5.包访问权限为private的方法不能重写，否则只是在子类中定义一个新的方法
8.Java中hashtable和hashmap的区别
1．Hashtable不允许插入空的键值对，否则报错
2．Hashtable是线程安全的，所有方法均是同步的;HashMap是线程是线程不安全的。
3．HashTable效率比hashmap低

9.throw和throws的区别
1.throw表示一种抛出的动作,throws表示一种状态,代表方法可能列出的抛出异常
2.throw用于方法体,throws用于方法头
3.throw只能抛出一个异常.throws后申明多个异常
10.内存溢出和内存泄漏的区
内存溢出(out of memory),是指程序在申请内存时,没有足够的内容供其使用.例如要申请一个对象却已经没有能够容纳这个对象的内存
内除泄露(memory leak)是指程序在申请内存后,无法释放掉已经申请的内存.如果频繁的出现内存泄露,最后内存会用尽而导致内存溢出.
11.String，StringBuffer 和 StringBuilder的区别
可变/不可变?
String是不可变的,因为其内部的字符数组是final的,所以长度是固定的,连接字符串时实际上是创建了新的字符串对象
StringBuilder,StringBuffer是可变的,因为都继承了abstractStringBuilder ,而abstractStringBuilder其内部是动态数组,长度不够时会自动扩容

StringBuilder是线程不安全的,StringBuffer是线程安全的,stringBuilder的效率比Strin gBuffer高
12.抽象类和接口类中方法的访问权限有哪些?
在jdk1.8中，抽象类的成员变量，抽象方法和非抽象方法默认都是default的,意味着抽象方法的访问权限可以为default,protected,public。据说以前都是protected
接口类的成员变量永远都是public static final 成员方法永远都是public
13.Class.forname()与ClassLoader.loadClass()？
Class.forname():是一个静态方法,最常用的是Class.forname(String className);根据传入的类的全限定名返回一个Class对象.该方法在将Class文件加载到内存的同时,会执行类的初始化.
　　如: Class.forName("com.wang.HelloWorld");
　　ClassLoader.loadClass():这是一个实例方法,需要一个ClassLoader对象来调用该方法,该方法将Class文件加载到内存时,并不会执行类的初始化,直到这个类第一次使用时才进行初始化.该方法因为需要得到一个ClassLoader对象,所以可以根据需要指定使用哪个类加载器.
　　如:ClassLoader cl=.......;cl.loadClass("com.wang.HelloWorld");
14.char[][]如何创建
char[][] ch1=new char[2][3]; //对
char[2][3] ch2=new char[][]; //错
char[2][] ch3 = new char[][3];//错
char[][] ch5 = new [2]char[3];//错
char[][] ch6=new char[2][];//对
char[][] ch7=new char[][3];//错
char[][] ch8=new char[][];//对
char[] ch9[]=new char[2][3];//对

16.关于类的修饰符
对于外部类 public default[默认] final abstract
对于成员内部类 public protected default[默认] private static final abstract
对于局部内部类 default[默认] final abstract
17. 标识符的组成
Java标识符由数字、字母、下划线(_)、美元符号($)或人民币(¥)组成，首位不能是数字。并且Java关键字不能作为标识符
protected abstract class $NEW{}//ok
protected abstract class ￥NEW{}//ok

17. 线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，线程的切换不由线程本身来决定（协同式调度）。这就是平台独立的原因。

18. 接口类中 可以有静态方法，但是不能有静态的抽象方法
public interface InterfaceObject {
int i=1;
void print();
static void printf(){ //ok
return ;
};

static void printff(); //error
}
19. 抽象方法一定是类的成员方法，不能是类方法
20.分母和分子只要一个是浮点数 算出来的结果也为浮点数
System.out.println(1/2.0);//0.5
System.out.println(1.0/2);//0.5
21.向上转型和向下转型
子类转型成父类是向上转型，反过来说，父类转型成子类就是向下转型
22.local variable==局部变量
23.方法的重写（override）两同两小一大原则：
方法名相同，参数列表相同
子类返回类型小于等于父类方法返回类型（子类重写方法的返回值类型必须为父类方法的返回值类型 或父类方法返回值类型的子类类型），
子类抛出异常小于等于父类方法抛出异常（子类重写方法抛出的异常类型 只能是父类方法抛出的类型  或父类方法抛出的异常类型的子类类型），
子类访问权限大于等于父类方法访问权限（父类方法是用 protected 修饰的  子类就只能用 public 修饰 而不能用private 修饰）。
24.finally语句块在什么时候不会执行
当try/catch语句块中有System.exit(0)时，不会执行finally语句块
25.如果finally和try/catch中都有return语句怎么办？
首先会执行try/catch中的return语句中的表达式，但是不一定直接从此处返回，要看情况。执行完try/catch中return语句中的表达式后会执行finally语句块；如果finally中有return，就从finally中的return直接返回，此时try/catch中的return会忽略，但是finally中没有return的话，就会先执行finally语句块，再从try/catch中的return返回
26.在类的静态方法内部可以通过创建一个本类对象来访问私有成员

27.import java.util.*; 和 import java.util.concurrent.*;的区别
import java.util.*; 导入的是uti直接子包下的所有类；不会导入util.concurrent.*下的类。
import java.util.concurrent.*;导入的是util.concurrent直接子包下的所有类
28.关系模型到对象模型的匹配关系
表对应类
表中的字段对应类的属性
表中的记录对应类的实例对象

29. 匿名内部类不能够私自定义构造方法 
30. 接口可以有静态方法，但是静态方法不能是抽象的
31. Super和this关键字可以随便用，但是如果用来调用构造方法，必须放在构造方法的第一行。但是都不能在static方法和static代码块内使用
32. 构造方法只能被访问权限修饰符修饰，不能被其他关键字修饰
33. Integer i01 =59;int i02 =59;=>i01==i02为true
34. 类可以实现多个接口，接口可以继承（或扩展）多个接口

35.JSP九大内置对象
Request,response,application,config,session,page,pageContext,out,exception

36.Java一维数组有两种初始化方法
1.静态初始化
int array[] = new int[]{1,2,3,4,5}
或者
int array[] = {1,2,3,4,5}
需要注意的是，写成如下形式也是错误的
int array[] = new int[5]{1,2,3,4,5}
2.动态初始化
int array[] = new int[5];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;

37.对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
,其最小内存值和Survivor区总大小分别是（）
解析：-Xmx10240m：代表最大堆
 -Xms10240m：代表最小堆
 -Xmn5120m：代表新生代
 -XXSurvivorRatio=3：代表Eden:Survivor = 3    根据Generation-Collection算法(目前大部分JVM采用的算法)，一般根据对象的生存周期将堆内存分为若干不同的区域，一般情况将新生代分为Eden ，两块Survivor；    计算Survivor大小， Eden:Survivor = 3，总大小为5120,3x+x+x=5120  x=1024
答：最小内存值为10240m,Survivor区总大小为2x=2048m

38.静态包含，动态包含
静态包含：<@include file=””/>
动态包含：<jsp include page=””/>

39. 默认使用Unioncode编码，即不论什么语言都是一个字符占两个字节
40. Java的class文件编码为UTF-8，而虚拟机JVM编码为UTF-16
41.在向上转型的过程中，父类引用了子类的对象，子类不能够重写父类的静态方法，加@Override注解会报错。如果子类还是申明了一个和父类一样的静态方法，只能说是子类申明了一个新的方法，把父类的隐藏了，但不意味着这是重写。当父类的引用调用静态方法时，调用的还是父类的的。所以静态方法和普通方法在调用上是存在区别的。
例：阅读以下程序并写出运行结果：

结果：98.0 9
41.虽然double类型大于int,但是double类型接收int值，会报错。因为它们属于两个不同的类型，一个浮点型，一个整形

42. 垃圾回收算法

43.创建线程的3种方法
Thread,Runnable,Callable。
Callable 需要实现call方法，并且线程执行结束会有返回值
44.静态内部类可以访问外部类的静态成员（数据+方法），包括私有的，但是不能访问外部类的实例成员。非静态内部类可以访问外部类的所有成员，包括私有的

45. 构造方法想要调用当前类的另外一个构造方法，必须用this关键字，其必须写在构造方法的第一行
46. violatile,synchronized的区别
47.|,&没有短路效果，||，&&有短路效果
48.子类可以继承父类所有的成员变量和方法，只是子类无法访问其私有的方法和属性而已
49.Error ,Exception的区别
Error，Exception都是Throwable的子类。
Error，他代表和虚拟机相关的问题。比如应用程序崩溃，虚拟机错误，内存空间不足，方法调用栈溢出。从而导致应用程序中断运行，而这些错误都不是应用程序自身所能解决和恢复的，所以建议终止程序运行。
Exception,是指应用程序能够自己解决并能使程序恢复运行的错误。例如ClassCastException，,IOException,ArrayOutIndexException,SQLException等。这种异常推荐捕获
50. 检查异常和非检查时异常
1.UnCheckExcpetion就是RuntimeException类及其子类以及Error。比如NullPointerException,
ClassCastException,IllegalArgumentException，IndexOutOfBoundsException异常等
对于这类异常可以不捕获
2.CheckException就是除了RuntimeException及其子类的其他Exception实现类。如IOException,ClassNotFoundException,SQLException等等。这类异常必须捕获
51.常见的对称加密，非对称加密，单向散列函数加密算法
对称加密算法：DES,3DES,RC2,RC4,AES
非对称加密算法：RSA,DSA,ECC
单向散列函数加密算法：md5,sha

RSA是非对称加密，在运行速度上是低于对称加密的
它的安全性是基于大素数分解，
在TLS/SSL协议中，RSA的公钥长度一般为1024位/2048位

52. 什么是对称加密，非对称加密
答：
对称加密算法是一个简单的加密算法，加密和解密的秘钥是一样的，但是这种加密算法虽然简单但是比较高效。秘钥越长，加解密的时间越长。
缺点就是如何将秘钥通过网络发送给需要解密消息的人，有很大的风险被截获。所以在这种场景下衍生出了非对称加密算法
非对称加密算法是一个非常安全的加密方法。他采用了一对密码，私钥和公钥。公钥是可以对外公开的，消息是通过公钥加密，只有私钥才能解密。只要不把私钥泄露出去就一切安全
53. synchronized和Lock的区别
答:Lock实现了synchronized的同步功能，并且还包含了中断锁等候和定时锁等候。意思就是线程A获得对象Obj的锁后，线程B在等待指定的时间后依旧没获得锁，会自动放弃该锁。
由于synchronized是jvm层面实现的，所以系统可以监控锁的释放与否。而lock是代码层面实现的，系统无法自动释放锁，需要我们自己在finally子句中显示的释放锁lock.unlock()
。Lock锁的范围具有局限性，块范围；而synchronized可以锁住类，对象，块加锁
54. object类拥有一组对象监视器方法，wait(),notify(),notifyAll()，他们配合synchronized关键字来实现等待通信机制。在Condition接口中也提供了类似Object的监视器方法await(),singnal(),singnalAll()来配合lock实现等待通信机制
55. 泛型及泛型擦除
泛型指的是集合的参数化类型，就是集合中的元素类型，指定了参数化类型使得在对集合操作时只能够使用指定的类型。
类型擦除，是指在编译阶段，编译器会把java代码中的参数化类型擦除。
56. Object clone()方法
57.Java中隐藏和覆盖
覆盖指示的是父类的实例方法被子类重写后，导致父类的实例方法被子类覆盖。
隐藏是相对于父类的属性（静态和普通）和静态方法而言。子类如果申明了和父类一样的成员变量，父类的成员变量只是隐藏了。当父类的引用指向的是子类对象时，调用的成员变量还是父类的；
子类如果申明了和父类一样的静态方法，即方法名相同，参数列表相同，同上调用的还是父类的。
注意方法重写和覆盖的格式：
重写是针对父类成员方法和子类成员方法之间。隐藏是指父类静态成员方法和子类静态成员方法之间以及属性之间
原因：如果父类方法是static，子类方法是成员的，或者父类方法是成员的，子类方法是static，这是错误的写法，编译就会报错，说明表示的既不是重写也不是覆盖。

58. Java中对字段（静态和普通）属性，final,static,private方法是静态绑定，成员方法是动态绑定

59.System.out.println默认调用的是String.valueOf()方法
该方法判断传入对象，如果是null则直接输出null否则调用toString()方法
String.valueOf源码
public static String valueOf(Object obj) {
return (obj == null) ? "null" : obj.toString();
}
60.类的继承和多态
创建子类会调用父类构造方法 但是不会创建父类对象
· a.子类方法不能缩小父类方法的访问权限（可以扩大），而且子类不能抛出比父类方法更多的异常，其必须抛出和父类方法抛出的相同的异常，或者子类方法抛出的异常类是父类方法抛出的异常类的子类。
· b.父类的静态方法不能被子类覆盖为非静态方法。同样，父类的非静态方法不能被子类覆盖为静态方法
· c.子类可以定义与父类的静态方法同名的静态方法，以便在父类中隐藏父类的静态方法。子类覆盖静态方法和覆盖一般方法的区别是，运行时，JVM把静态方法和所属类绑定，而将一般方法和所属实例绑定。
· d.父类的私有方法不能被子类覆盖。虽然不会出现编译错误，但是实际上子类并没有从父类继承这个方法，所以，其并没有覆盖关系。
· e.父类的抽象方法通过子类实现父类的抽象方法或者子类重新声明父类的抽象方法来实现覆盖。
·
· f.父类的非抽象方法可以被覆盖为抽象方法
·
61.null
1. 在编译和运行时期，将null强制转换成任何引用类型都是可行的，在运行时期都不会抛出空指针异常。
2. 当你直接将null赋值给基本类型，会出现编译错误。但是如果将null赋值给包装类object，然后将object赋给各自的基本类型，编译器不会报，但是你将会在运行时期遇到空指针异常。这是Java中的自动拆箱导致的
3. 任何含有null值的包装类在Java拆箱生成基本数据类型时候都会抛出一个空指针异常
4. 如果使用了带有null值的引用类型变量，instanceof操作将会返回false
62. <init>和<clinit>方法

区别
· <clinit>：在jvm第一次加载class文件时调用，包括静态变量初始化语句和静态块的执行
· <init>:在实例创建出来的时候调用，包括调用new操作符；调用Class或Java.lang.reflect.Constructor对象的newInstance()方法；调用任何现有对象的clone()方法；通过java.io.ObjectInputStream类的getObject()方法反序列化。
（1）<clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块之前的变量，点贵在他之后的变量，在前面的静态语句块中可以赋值但不能访问。
public class Test{
static{
i = 0; //给变量赋值可以正常通过
System.out.println(i); //这句编译器会提示“非法向前引用”
}
static int i = 1;
}
（2）<clinit>()方法与类的构造函数（或者说实例构造器中的()方法）不同， 它不需要显示的调用父类构造器，虚拟机会保证在子类的()方法执行之前，父类的<clinit>()方法已经执行完毕。因为在虚拟机中第一个被执行的<clinit>()方法的类肯定是java.lang.Object。
（3）由于父类的<clinit>()方法先执行，也就意味着父类中定义的静态语句块要优先于子类类的变量赋值操作。
（4）<clinit>()方法对于类或者接口来说并不是必须的，如果一个类没有静态语句块，也就没有变量的赋值操作，那么编译器可以不为这个类生成<clinit>()方法。
（5）接口中不能使用静态语句块，但仍然可以有变量初始化的赋值操作，因此接口与类一样都会生成<clinit>()方法。但接口与类不同，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也一样不会执行接口的<clinit>()方法。
（6）虚拟机会保证一个类的<clinit>()方法在多线程环境中被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的<clinit>()方法中有耗时很长的操作，就可能造成多个线程阻塞。

设计模式：
1.说出你知道的设计模式有哪些？
2.单例模式：

懒汉（懒加载），饿汉（立即加载），双重锁校验，枚举，静态内部类
懒汉：

饿汉:

双重锁校验：

枚举：

静态内部类

框架：
1.怎么理解spring ioc容器
2.Spring的核心是什么
依赖注入和aop
3.spring事务传播特性
事务属性的种类：   传播行为、隔离级别、只读和事务超时

a)   传播行为定义了被调用方法的事务边界。

PROPERGATION_MANDATORY
表示方法必须运行在一个事务中，如果当前事务不存在，就抛出异常
PROPAGATION_NESTED
表示如果当前事务存在，则方法应该运行在一个嵌套事务中。否则，它看起来和PROPAGATION_REQUIRED 看起来没什么俩样
PROPAGATION_NEVER
表示方法不能运行在一个事务中，否则抛出异常
PROPAGATION_NOT_SUPPORTED
表示方法不能运行在一个事务中，如果当前存在一个事务，则该方法将被挂起
PROPAGATION_REQUIRED
表示当前方法必须运行在一个事务中，如果当前存在一个事务，那么该方法运行在这个事务中，否则，将创建一个新的事务
PROPAGATION_REQUIRES_NEW
表示当前方法必须运行在自己的事务中，如果当前存在一个事务，那么这个事务将在该方法运行期间被挂起
PROPAGATION_SUPPORTS
表示当前方法不需要运行在一个是事务中，但如果有一个事务已经存在，该方法也可以运行在这个事务中

b)   隔离级别
在操作数据时可能带来 3 个副作用，分别是脏读、不可重复读、幻读。为了避免这 3 中副作用的发生，在标准的 SQL 语句中定义了 4 种隔离级别，分别是未提交读、已提交读、可重复读、可序列化。而在 spring 事务中提供了 5 种隔离级别来对应在SQL 中定义的 4 种隔离级别，如下：
隔离级别
意义
ISOLATION_DEFAULT
使用后端数据库默认的隔离级别
ISOLATION_READ_UNCOMMITTED
允许读取未提交的数据（对应未提交读），可能导致脏读、不可重复读、幻读
ISOLATION_READ_COMMITTED
允许在一个事务中读取另一个已经提交的事务中的数据（对应已提交读）。可以避免脏读，但是无法避免不可重复读和幻读
ISOLATION_REPEATABLE_READ
一个事务不可能更新由另一个事务修改但尚未提交（回滚）的数据（对应可重复读）。可以避免脏读和不可重复读，但无法避免幻读
ISOLATION_SERIALIZABLE
这种隔离级别是所有的事务都在一个执行队列中，依次顺序执行，而不是并行（对应可序列化）。可以避免脏读、不可重复读、幻读。但是这种隔离级别效率很低，因此，除非必须，否则不建议使用。

c)    只读
如果在一个事务中所有关于数据库的操作都是只读的，也就是说，这些操作只读取数据库中的数据，而并不更新数据，那么应将事务设为只读模式（ READ_ONLY_MARKER ） , 这样更有利于数据库进行优化 。
因为只读的优化措施是事务启动后由数据库实施的，因此，只有将那些具有可能启动新事务的传播行为(PROPAGATION_NESTED 、 PROPAGATION_REQUIRED 、 PROPAGATION_REQUIRED_NEW) 的方法的事务标记成只读才有意义。
如果使用 Hibernate 作为持久化机制，那么将事务标记为只读后，会将 Hibernate 的 flush 模式设置为FULSH_NEVER, 以告诉 Hibernate 避免和数据库之间进行不必要的同步，并将所有更新延迟到事务结束。
d)   事务超时
如果一个事务长时间运行，这时为了尽量避免浪费系统资源，应为这个事务设置一个有效时间，使其等待数秒后自动回滚。与设
置“只读”属性一样，事务有效属性也需要给那些具有可能启动新事物的传播行为的方法的事务标记成只读才有意义。
网络:
1.Iso 7层模型
物理层，数据链路层，网络层，传输层，会话层，表现层，应用层
2. TCP，udp的区别
3.TCP连接和断开，3次握手，4次挥手的过程

数据库：
1. 索引的理解
索引可以提高查询速度。
为某个字段添加索引，其实就是为某个字段添加一种特殊的数据结构，它包含了字段的值，并且字段的值是经过排序的，以及字段所对应的行的地址。当通过索引进行查找时，数据库搜索引擎可以估算出记录的大概位置，然后再根据二分查找的思想向左或向右移动来查找出对应的记录，比通常的全表扫描效率高很多。
那是不是每个字段都该加索引呢？
不对。首先a.创建索引和维护索引都需要花费一定的时间，而且这个时间是随着记录数的增加而增加的b.索引需要占用物理空间，除了数据表占物理空间外，索引还要占，如果是聚簇索引所占用的空间会更多c.每次insert,update,delete，索引都要重新计算，增加了维护的时间，降低了性能
那该给哪些字段加索引？
A. 给经常需要搜索的列创建索引
B. 给需要连接的列添加索引
C. 需要经常分组和排序的列添加索引。
D. 给经常需要按某个指定范围的来查询的列添加索引
Tip:对于那些存在大量重复值的字段没必要添加索引，没什么太大用处

索引的分类：
A. 唯一索引 不允许出现两行具有相同索引值的索引
B. 主键索引 某一列或列的组合用来唯一标识一行
C. 聚集索引 行的物理顺序和逻辑顺序是一样的

2.事物的隔离级别
√: 可能出现    ×: 不会出现

脏读
不可重复读
幻读
Read uncommitted
√
√
√
Read committed
×
√
√
Repeatable read
×
×
√
Serializable
×
×
×

脏读：即一个事物读取到另一个事物尚未提交的数据
不可重复读：事务A读取了某数据，然后事务B对其进行修改，事务A再次读取时发现数据不一致
幻读和不可重复度都是指读取了另一个事务已经提交了的数据。所不同的是不可重复读查询的都是同一个数据项，而幻读针对的是一批数据整体（比如数据的个数）

幻读是指当前事务不是独立执行发生的一种现象。比如事务A对表中的所有行的数据都做了更改
3.事务的四大特性
原子性 一致性 持续性 隔离性
算法与数据结构

1. 稳定和不稳定的排序算法有哪些?
稳定：冒泡，直接插入，归并，基数排序
不稳定：快排，堆排，选择，希尔
2. 时间复杂度，空间复杂度
类别
排序方法
时间复杂度
空间复杂度
稳定性
平均
最好
最坏
辅助存储
插入算法
直接插入
O(n2)
O(n)
O(n2)
O(1)
稳定
希尔排序
O(n1.3)
O(n)
O(n2)
O(1)
不稳定
选择算法
直接选择
O(n2)
O(n)
O(n2)
O(1)
不稳定
堆排
O(nlog2n)
O(nlog2n)
O(nlog2n)
O(1)
稳定
交换算法
冒泡排序
O(n2)
O(n)
O(n2)
O(1)
稳定
快速排序
O(nlog2n)
O(nlog2n)
O(n2)
O(nlog2n)
不稳定
归并算法
O(nlog2n)
O(nlog2n)
O(nlog2n)
O(1)
稳定
基数排序
O(d(r+n))
O(d(rd+n))
O(d(r+n))
O(d(rd+n))
稳定
在基数排序中，r代表关键字的基数，d代表长度，n代表关键字的个数

3.什么排序算法在什么场景下是最优的，一般用哪个排序是最快的

操作系统
1. 进程和线程的区别
进程是程序在给定的活动空间和初始环境条件下的，在一个处理机上的执行过程。
它是cpu进行资源分配和调度的基本单位。
它具有4个特性。动态性，独立性，并发性，异步性
动态性是指程序是静态的，进程是动态的，因为它会被cpu调度执行。程序只是一种的描述
独立性是指进程是可以独立运行的，是cpu进行资源分配和调度的基本单位
并发性是指线程之间是可以并发执行的
异步性是指线程总是各自独立按不可预知的速度的向前推进/进程是异步执行的

线程出现以后，线程变成了cpu调度和运行的基本单位，进程已经不是可运行的实体，他只是拥有分配的资源。而线程本身不占有太多的资源（如寄存器，栈等），主要是和同一个进程的其他线程共享