java

Java 是从C++语言改进重新设计

-1.JDK各个版本新特性

JDK5~JDK10 ==========

0.运算符

：带符号右移。正数右移高位补0，负数右移高位补1。比如：

4 >> 1，结果是2；-4 >> 1，结果是-2。-2 >> 1，结果是-1。

：无符号右移。无论是正数还是负数，高位通通补0。

&是位运算符，表示按位与运算，&&是逻辑运算符，表示逻辑与（and）。

1.java跨平台原理

由于操作系统指令集不完全一致，需要在不同平台写不同的代码
java只需要在不同操作系统上安装不同的虚拟机jvm

2.基础

1.1 覆写/重载

当子类定义了和父类在方法名称、返回值类型、参数类型及个数完全相同的方法的时候，称为方法的覆写。

重载是指不同的函数使用相同的函数名，但是函数的参数个数或类型不同。调用的时候根据函数的参数来区别不同的函数。

1.2 基本类型转化

八种基本数据类型

整数类型：byte（1字节） short（2字节） int（4字节） long（8字节）
浮点类型：float（4字节） double（8字节）
字符类型：char（2字节）可以存储一个汉字
一个中文汉字占2byte(字节)的空间,所以可以存储一个汉字
java中规定一个字符（不管是数字，字母，汉字）都占两个字节（byte）
int x = ‘1’-‘0’; // x=1
布尔类型：boolean(1)

long l = 449;
int a = (int) 333f;
float f = (float) 13.1;
int c = (int) 4L;
int x = (int) 3d;
double d = 1.45;
double e = 111f;
double f2 = 333L;

1.3 枚举

但枚举类使用enum定义后在编译后默认继承了java.lang.Enum类

enum声明类继承了Serializable和Comparable两个接口。且采用enum声明后，该类会被编译器加上final声明（同String），故该类是无法继承的。

枚举类的内部定义的枚举值就是该类的实例（且必须在第一行定义，当类初始化时，这些枚举值会被实例化）。

枚举类除了可以实现接口外，还可以在枚举类中定义抽象方法，这样每个枚举的对象只要分别实现了此抽象方法即可。

枚举其实就是特殊的常量类，且构造方法被默认强制是私有。

public enum  ConstantFile {
  USA("美国",1),
  CHINA("中国",2);
  private String name;
  private int index;
  private ConstantFile(String name,int index){
    this.name=name;
    this.index=index;
  }
  //get set方法
}

枚举配合switch使用

switch (SexEnum.getSexEnumByCode(sex)){
    case MAN:
        System.out.println("this is a man");
        break;
    default:
        System.out.println("maybe it's an alien");
        break;
}

1.4 引用类型

https://www.cnblogs.com/alias-blog/p/5793108.html

1.5 关键字列表(依字母排序共51组):

abstract, assert,boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum,extends, final, finally, float, for, if, implements, import, instanceof, int, interface, long, native, new,package, private, protected, public, return, short,static, strictfp, super,switch, synchronized,this, throw, throws, transient,
try, void, volatile, while
保留字列表 (依字母排序共14组) : Java保留字是指现有Java版本尚未使用但以后版本可能会作为关键字使用。
byValue, cast, false, future, generic, inner, operator, outer, rest, true, var , goto ，const,null

1.6

1.7 作用域

private并不是绝对安全的,对用户常规使用java的一种约束

关键字        当前类       同一package        子孙类       其他package 
public          √            √               √            √ 
protected       √            √               √            × 
default         √            √               ×            × 
private         √            ×               ×            ×

1.8 final

• 被声明为final作用于类的成员变量,必须在定义时或者构造器中进行初始化赋值，而在以后的引用中只能读取，不可修改。

final变量如果是静态的，要么定义时初始化，要么在静态代码块中初始化。final变量如果不是静态的，要么定义时初始化，要么在非静态代码块中初始化。

• 被声明为final的方法也同样只能使用，不能重载
• 如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。

一个类不能同时被声明为abstract抽象类的和final的类。

同时可见执行顺序是：静态代码块->非静态代码块->构造函数

String为什么是final的

1. 设计成final，JVM才不用对相关方法在虚函数表中查询，而直接定位到String类的相关方法上，提高了执行效率
2. 保证安全

1.9 switch

switch支持int和枚举类型，可以用char,byte,short,int类型，但是不支持long类型，因为
byte取值范围-128~127
int的取值范围为（-2147483648~2147483647）
short的取值范围为-32768~32767，占用2个字节
long类型数据范围为-9223372036854774808~9223372036854774807
当long转为int是会造成精度损失

只支持整型例如int以及包装类Integer,byte/short/char能够隐式转换为int,
long/float/double/String不能隐式的转为int,所以不能用作switch表达式

jdk1.7之后String可以放入switch,请注意兼容性!!!调用的hashcode

1.10 可变参数

可变参数必须放置在参数列表的最后。（提倡同学们尽量不用可变参数编程）

1.11 构造方法

• 默认构造方法可以没有参数，也可以有参数，但是每个参数都必须有默认值。
• 如果没有默认的构造方法，编译器才会为类生成一个无参的缺省构造方法，不是总是生成的，是有条件的。
• 方法是可以和类名同名的，和构造方法唯一的区别就是，构造方法没有返回值。
• 构造函数必须与类同名

1.12 this,super

1）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。
2）super()和this()类似,区别是，super从子类中调用父类的构造方法，this()在同一类内调用其它方法。
3）super()和this()均需放在构造方法内第一行。
4）尽管可以用this调用一个构造器，但却不能调用两个。
5）this()和super()不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。
6）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。
7）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。

3. 类加载过程

编译，即把我们写好的java文件，通过javac命令编译成字节码byte code，也就是我们常说的.class文件。
javac 一次可同时编译数个 Java 源文件
javac.exe 能指定编译结果要置于哪个目录（directory）
运行，则是把编译声称的.class文件交给Java虚拟机(JVM)执行。
类加载过程 即是指JVM虚拟机把.class文件中类信息加载进内存，JVM在执行某段代码时，遇到了class A， 然而此时内存中并没有class A的相关信息，于是JVM就会到相应的class文件中去寻找class A的类信息，并加载进内存中，并进行解析生成对应的class对象，这就是我们所说的类加载过程。JVM不是一开始就把所有的类都加载进内存中，而是只有第一次遇到某个需要运行的类时才会加载，且只加载一次。
>>>>参考文章<<<<

• 加载：类加载过程的一个阶段：通过一个类的完全限定查找此类字节码文件，并利用字节码文件创建一个Class对象
• 验证：目的在于确保Class文件的字节流中包含信息符合当前虚拟机要求，不会危害虚拟机自身安全。主要包括四种验证，文件格式验证，元数据验证，字节码验证，符号引用验证。
• 准备：为类变量(即static修饰的字段变量)分配内存并且设置该类变量的初始值即0(如static int i=5;这里只将i初始化为0，至于5的值将在初始化时赋值)，这里不包含用final修饰的static，因为final在编译的时候就会分配了，注意这里不会为实例变量分配初始化，类变量会分配在方法区中，而实例变量是会随着对象一起分配到Java堆中。
• 解析：主要将常量池中的符号引用替换为直接引用的过程。符号引用就是一组符号来描述目标，可以是任何字面量，而直接引用就是直接指向目标的指针、相对偏移量或一个间接定位到目标的句柄。有类或接口的解析，字段解析，类方法解析，接口方法解析(这里涉及到字节码变量的引用，如需更详细了解，可参考《深入Java虚拟机》)。
• 初始化：类加载最后阶段，若该类具有超类，则对其进行初始化，执行静态初始化器和静态初始化成员变量(如前面只初始化了默认值的static变量将会在这个阶段赋值，成员变量也将被初始化)。

3.1 java程序初始化顺序

1父类优先于子类
2静态变量/对象优先,只初始化一次
3按照顺序初始化

父类静态变量-父类静态代码块（并列优先级，按出现的先后顺序执行，且只有第一次加载时执行）
->子类静态变量-子类静态代码块(同上)
->父类普通代码块，父类普通成员字段（并列优点级，按代码中出现先后顺序执行）
->父类构造函数
->子类代码块-父类构造方法
->子类构造

3.2 内部类

内部类详解
https://www.runoob.com/w3cnote/java-inner-class-intro.html

4. 继承

class Base{ }
class Derived extends Base{ }
Base x = new Derived();
System.out.println(x instanceof Derived); //true
System.out.println(x instanceof Base); //true

5.接口和抽象类

抽象方法: 只有声明,没有实现.如果一个类含有抽象方法,那么这个类是抽象类,
抽象类必须在类前用abstract修饰

public abstract class 类名{
    //可以有非final修饰的成员变量
    //可以有普通成员方法
    //抽象方法  ↓
    [public] abstract void fun();
}

interface C extends A, B {}.
一个类可以实现多个接口
class D implements A,B,C{} | | 使用场景 | 功能需要累计,充当公共类 | 功能不需要累加 | | 方法 | public/protected修饰
可以有构造方法 | public abstract 方法；
不允许构造方法 | | 成员变量 | 抽象类中的成员变量可以是各种类型的 | 常量用public static final修饰,必须赋初始值 |

特殊:
接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；java8 中接口中可以有静态

接口不是继承于Object https://blog.csdn.net/xidiancoder/article/details/78011148
abstract类继承于Object?

6.Object类中的方法

6.1 clone()方法

返回一个Object的复制,返回的是一个新的对象,而不是一个引用
1)实现clone需要继承Cloneable接口(标识接口)
2)重写Object类的clone方法
3)在方法中调用Object o = super.clone();实现浅复制
浅拷贝仅仅复制所拷贝的对象，而不复制它所引用的对象。
对象的 clone 方法默认是浅拷贝，若想实现深拷贝需要重写 clone 方法实现属性对象
的拷贝。
详解:啊
深拷贝,浅拷贝
clone 方法详解

6.2 finalize()

垃圾回收器回收时会调用这个方法,可以覆写对其他资源的回收(文件关闭)
不建议重写

6.3 public native int hashCode();

为了配合基于散列的集合一起正常运行，这样的散列集合包括HashSet、HashMap以及HashTable。
根据一定的规则将与对象相关的信息（比如对象的存储地址，对象的字段等）映射成一个数值，这个数值称作为散列值

6.4 getClass()

getClass()方法是获得调用该方法的对象的类；
getClass().getName()可以得到该类的路径；
getClass().newInstance() 获取新的实例
子类获得是子类得class

6.5 notify和notifyAll/wait

下面多线程里讲解

6.6 toString/equals/hashCode

1. 如果两个对象相等(equal)，那么他们一定有相同的哈希值。
2. 如果两个对象的哈希值相同，但他们未必相等(equal)。

   6.7 为什么重写了 equals 方法，还要重写 hashCode 方法？

   https://blog.csdn.net/xyh269/article/details/69171545

   6.8 ==和equals区别

   Object类中的equals方法和“==”是一样的，比较是比较他们的栈内存中存储的内存地址。而String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，他们比较的是值是不是相等。
   1）对于==
   如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
   如果作用于引用类型的变量，则比较的是所指向的对象的地址
   2）对于equals方法

   public boolean equals(Object obj) {    //Object中父类的equals方法
   return (this == obj);
   }

注意：equals方法不能作用于基本数据类型的变量
如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

7.什么是反射

Reflection（反射），用在Java身上指的是可以于运行时加载、探知、使用编译期间完全未知的classes。换句话说，Java程序可以加载一个运行时才得知名称的class，获悉其完整构造（但不包括methods定义），并生成其对象实体（newInstance）或对其fields设值，或唤起（invoke）其methods方法。

Java 反射，就是在运行状态中
获取任意类的名称、package信息、所有属性、方法、注解、类型、类加载器等
获取任意对象的属性，并且能改变对象的属性
调用任意对象的方法
判断任意一个对象所属的类
实例化任意一个类的对象

通过反射我们可以实现动态装配，降低代码的耦合度；动态代理等。反射的过度使用会严重消耗系统资源

Class c = Class.forName("类名");
类名 ob = (类名)c.newInstence();

如何获取class
1)如上面示例
2)列名.class
3)示例.getClass();

获取父类名
getClass().getName();
this.getSuperClass().getName();
java创建对象的4个方法
1)new
2)反射出示例,如上示例
3)通过clone方法
4)反序列化的方式创建对象(待完善)

8. static

不可以修饰方法内的变量
静态方法
静态方法是属于类的，在加载类时，程序就会为静态方法分配内存
非静态方法，在对象创建的时候程序才会为其分配内存

9.

10. java实现排序

• Arrays.sort()和Collections.sort()
• 使用Comparable接口 Comparable接口定义了compareTo方法，用于对象之间的比较
• 使用Comparator接口 Comparator可以用于比较没有实现Comparable的类的对象

11.泛型的理解

可把泛型比作一个黑盒子，我们不考虑盒子具体里面是什么类型，我们关注的是对盒子的处理， 此时我们不针对具体对象编程，给了一个类型，把它应用到泛型，就具有了泛型的特性
不能使用基本数据类型

12.异常

12.1 Java中的异常有哪几类?分别怎么使用?

执行异常（RuntimeException）
检查异常（Checked Exceptions）FileNotFoundException/ClassNotFoundException

• Exception ：受检查的异常，这种异常是强制我们catch或throw的异常。你遇到这种异常必须进行catch或throw，如果不处理，编译器会报错。比如：IOException。
• RuntimeException：运行时异常，这种异常我们不需要处理，完全由虚拟机接管。比如我们常见的NullPointerException，我们在写程序时不会进行catch或throw。

当用多个catch语句时，catch语句块在次序上有先后之分。从最前面的catch语句块依次先后进行异常类型匹配，这样如果父异常在子异常类之前，那么首先匹配的将是父异常类，子异常类将不会获得匹配的机会，也即子异常类型所在的catch语句块将是不可到达的语句。所以，一般将父类异常类即Exception老大放在catch语句块的最后一个
JDK7语法糖 try-with-resource
当一个外部资源的句柄对象（比如FileInputStream对象）实现了AutoCloseable接口，那么就可以将上面的板式代码简化为如下形式：

public static void main(String[] args) {
    try (FileInputStream inputStream = new FileInputStream(new File("test"))) {
        System.out.println(inputStream.read());
    } catch (IOException e) {
        throw new RuntimeException(e.getMessage(), e);
    }
}

12.2 throw 和 throws 的区别？

throw
表示方法内抛出某种异常对象
如果异常对象是非 RuntimeException 则需要在方法申明时加上该异常的抛出 即需要加上 throws 语句 或者 在方法体内 try catch 处理该异常，否则编译报错
执行到 throw 语句则后面的语句块不再执行

throws：
方法的定义上使用 throws 表示这个方法可能抛出某种异常
需要由方法的调用者进行异常处理

12.3 finally

只要执行了try或者catch，就一定会执行 finally
finally肯定会执行,并且执行finally中的return语句

忽然找到finally不执行的情况
1)在try语句执行之前就出现异常
2)try中有System.exit(0);

finally 块必须对资源对象、流对象进行关闭，有异常也要做 try-catch。
说明：如果 JDK7 及以上，可以使用 try-with-resources 方式。

13. java 序列化

序列化：将 Java 对象转换成字节流的过程。
反序列化：将字节流转换成 Java 对象的过程。

当 Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。
序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。

某个类可以被序列化，则其子类也可以被序列化
声明为 static 和 transient 的成员变量，不能被序列化。static 成员变量是描述类级别的属性，transient 表示临时数据
反序列化读取序列化对象的顺序要保持一致

https://blog.csdn.net/meism5/article/details/90413987

14.内联函数

https://www.nowcoder.com/test/question/done?tid=20663142&qid=63350#summary

public final void method1() {     
   //TODO something     
}

15.编码问题

15.1java与中文

默认使用unicode编码

String str = "你好";
Sysout(str.length+"="+str.getBytes().length);
//output:2 = 4

字符串中查找中文代码

//1.判断字节长度与字符串长度
str.getBytes().length ==str.length()
//2.第二步,正则匹配
String regEx = "[\u4e00-\u9fa5]";
Pattern p = Pattern.compile(regEx);
Matcher m = p.matcher(str);
while(m.find()){
    Sysout(m.group(0)+"");
}

判断char是不是中文

/**
     * 判断一个字符是否是汉字
     * PS：中文汉字的编码范围：[\u4e00-\u9fa5]
     * @param c 需要判断的字符
     * @return 是汉字(true), 不是汉字(false)
     */
    public static boolean isChineseChar(char c) {
        return String.valueOf(c).matches("[\u4e00-\u9fa5]");
    }

15.2默认编码

不管在编译前java文件使用何种编码，在编译后成class后，他们都是一样的——Unicode编码表示。
文件中有几个类编译后就有几个class文件

16. 继承

成员变量不具备多态性，通过引用变量来访问其包含的实例变量，系统总是试图访问它编译时类型所定义的成员变量，而不是运行时类型所定义的成员变量

17. java对象,byte[]转化

https://blog.csdn.net/idealemail/article/details/53993872

18. 多线程及并发问题

>>>>其他文章

19. JDBC事务

• 属于java事务的一种
• 有Connection发起,并由它控制

20. BIO、NIO、AIO 有什么区别？

BIO：线程发起IO请求，不管内核是否准备好IO操作，从发起请求起，线程一直阻塞，直到操作完成。
NIO：线程发起IO请求，立即返回；内核在做好IO操作的准备之后，通过调用注册的回调函数通知线程做IO操作，线程开始阻塞，直到操作完成。
AIO：线程发起IO请求，立即返回；内核做好IO操作的准备之后，做IO操作，直到操作完成或者失败，通过调用注册的回调函数通知线程做IO操作完成或者失败。

BIO是一个连接一个线程。
NIO是一个请求一个线程。
AIO是一个有效请求一个线程。

JDK类包

Math类

Math.round(-1.5) 等于多少
扩展JDK中的java.lang.Math类
round:返回四舍五入，负.5小数返回较大整数，如-1.5返回-1。
ceil:返回小数所在两整数间的较大值，如-1.5返回-1。 取小数两边的大的整数
tail:返回小数所在两整数间的较小值，如-1.5返回-2。
Math.round(1.4)=1
Math.round(-1.4)=-1
Math.round(1.5)=2
Math.round(-1.5)=-1
Math.round(1.6)=2
Math.round(-1.6)=-2

File类

File教程
file.listFiles()展示所有文件变为数组
f.getAbsolutePath()获取绝对路径

String类

String s = new String(“xyz”);
创建了2个String Object
https://www.cnblogs.com/dangzhenjiuhao/p/4585389.html

IO流

1.Java IO是采用的是装饰模式，即采用处理流来包装节点流的方式，来达到代码通用性。
2.处理流和节点流的区分方法，节点流在新建时需要一个数据源（文件、网络）作为参数，而处理流需要一个节点流作为参数。
3.处理流的作用就是提高代码通用性，编写代码的便捷性，提高性能。
4.节点流都是对应抽象基类的实现类，它们都实现了抽象基类的基础读写方法。其中read（）方法如果返回-1，代表已经读到数据源末尾。

输入和输出都是从程序的角度来说的。
输入流：数据流向程序；
输出流：数据从程序流出。

按处理单位:字节流和字符流
字节流：一次读入或读出是8位二进制；Stream是字节流  ,8bit传输,继承于InputStream,OutputStream
字符流：一次读入或读出是16位二进制。Reader，Writer是字符流。16bit,会用到缓存,

按功能功能:节点流和处理流
节点流：直接与数据源相连，读入或写出；处理流：与节点流一块使用，在节点流的基础上，再套接一层。

https://blog.csdn.net/meism5/article/details/89453354
https://blog.csdn.net/qq_36762677/article/details/88555815

拷贝文件使用字符流还是字节流?

如果拷贝的文件不确定是字符流,有可能有字节流(图片,声音,视频),未考虑通用性,使用字节流

Date

SimpleDateFormat 是线程不安全的类，一般不要定义为 static 变量，如果定义为
static，必须加锁，或者使用 DateUtils 工具类。
正例：注意线程安全，使用 DateUtils。亦推荐如下处理：

private static final ThreadLocal<DateFormat> df = new ThreadLocal<DateFormat>() { 
    @Override 
    protected DateFormat initialValue() { 
        return new SimpleDateFormat("yyyy-MM-dd"); 
    } 
};

说明：如果是 JDK8 的应用，可以使用 Instant 代替 Date，LocalDateTime 代替 Calendar，
DateTimeFormatter代替Simpledateformatter，官方给出的解释：simple beautiful strong
immutable thread-safe。

Collections集合<—点击链接

List/Queue/Set/Stack都继承自Collection接口

Optional 类 JDK8

来防止 NPE 问题。.

Runtime类

1.查看cpu个数

int cpus = Runtime.getRuntime().availableProcessors();

2.通过代码执行操作系统相关命令

try {
    Process process = Runtime.getRuntime().exec("ipconfig");
    InputStream in = process.getInputStream();
    byte[] buf = new byte[1024];
    int length = -1;

    while (-1!=(length = in.read(buf))){
        System.out.println(new String(buf,0,length));
    }
} catch (IOException e) {
    e.printStackTrace();
} finally{
    in.close();
    proc.waitFor();
}

java web

1.拦截器和过滤器的区别?

1、拦截器是基于java反射机制的，而过滤器是基于函数回调的。
2、过滤器依赖于servlet容器，而拦截器不依赖于servlet容器。
3、拦截器只能对Action请求起作用，而过滤器则可以对几乎所有请求起作用。
4、拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。
5、在Action的生命周期中，拦截器可以多次调用，而过滤器只能在容器初始化时被调用一次。

2.Struts2框架的核心控制器,作用

StrutsPrepareAndExecuteFilter。
2）作用：
负责拦截由/*
指定的所有用户请求，
当用户请求到达时，
该Filter会过滤用户的请求。

3.servlet与jsp

https://blog.csdn.net/qq_36762677/article/details/84198090

servlet采用java编写的服务端程序,运行与web服务器中的servlet容器,使用流程:
1) 向servlet发起请求
2) web服务器接受请求,交给相应的容器,创建HttpServletRequest和HttpServletReponse
3) 容器根据url找到对应的servlet,针对请求创建一个线程
4) 容器调用servlet的service()方法,将生成的动态页面相应给容器,在此之前调用init,之后调用destory方法并只调用一次
5) 容器把相应消息组装成http返回给客户端,删除2)中的两个对象
jsp中注释的有<%— 与 —%>
在WEB-INF目录下，必须存放的文件web.xml

4.转发和重定向

redirect：请求重定向：客户端行为，本质上为2次请求，地址栏改变，前一次请求对象消失。
forward：请求转发:服务器行为，地址栏不变。

请求转发：forword 一次请求，地址栏不变。比如你要问小李借钱，小李说没钱，但是小李帮你从小王那借了钱。这样你还在原地，只开了一次口，就借到了钱。 请求重定向：redirect 两次请求，地址栏变。 同样是问小李借钱，小李说没钱，但是小李告诉你小王有钱，但是小李不帮你借，只告诉你小王在哪，这时你就得去小王家借钱，最终借到了钱。这样你换了一个地方，并且开了两次口才借到了钱。
redirect：请求重定向：客户端行为，本质上为2次请求，地址栏改变，前一次请求对象消失。举例：你去银行办事（forward.jsp），结果告诉你少带了东西，你得先去公安局办(index.html)临时身份证,这时你就会走出银行，自己前往公安局，地址栏变为index.html.

5.AJAX

再不刷新页面的情况下通过服务器进行少量数据的交互来提高交互性,降低了服务器的网络负载,使响应时间缩短.
AJAX是客户端技术,核心是javascript对象XmlHttpRequest,支持异步请求的技术

6.数据库连接池工作机制

数据库连接是珍贵且有限的
服务器启动时创建一定数量的池连接,并一直维持不少于这个数量的连接,当程序访问数据库时,从池中获取一个连接,而不是创建一个新的连接,如果当前没有空闲连接,则会在连接池中创建一定数量的连接

7.Web service

是一个平台独立的，低耦合的，自包含的、基于可编程的web的应用程序，可使用开放的XML（标准通用标记语言下的一个子集）标准来描述、发布、发现、协调和配置这些应用程序，用于开发分布式的互操作的应用程序。 [1]
Web Service技术， 能使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件， 就可相互交换数据或集成。依据Web Service规范实施的应用之间， 无论它们所使用的语言、 平台或内部协议是什么， 都可以相互交换数据。Web Service是自描述、 自包含的可用网络模块， 可以执行具体的业务功能。Web Service也很容易部署， 因为它们基于一些常规的产业标准以及已有的一些技术，诸如标准通用标记语言下的子集XML、HTTP。Web Service减少了应用接口的花费。Web Service为整个企业甚至多个组织之间的业务流程的集成提供了一个通用机制

8. get和post的区别

都是http请求方式,对应不同的操作,

1. get请求提交的信息会在地址栏展示,post不会
2. get请求传输数据有浏览器限制
3. post安全性更高

9. session和cookie

都是会话跟踪技术
cookie在浏览器客户端记录信息,确定用户身份,cookie不能超过4K
session在服务器端记录信息确定用户身份,但是session是依赖cookie的,sessionId需要存放在客户端,会占用服务器端性能,但是安全性高

使用场景:
登录重要信息放入session
购物车类放入cookie

计算机网络

测试

1.junit

junit用法，before,beforeClass,after, afterClass的执行顺序
https://www.cnblogs.com/GrimMjxCl/p/9296634.html

设计模式

https://www.jianshu.com/p/61b67ca754a3

编码规约

1. 命名

• 抽象类命名使用 Abstract 或 Base 开头；异常类命名使用 Exception 结尾；测试类
  命名以它要测试的类的名称开始，以 Test 结尾。
• 数组定义如下：String[] args
• 枚举类名建议带上 Enum 后缀，枚举成员名称需要全大写，单词间用下划线隔开。
• 各层命名规约
  • A) Service/DAO 层方法命名规约
    • 1） 获取单个对象的方法用 get 做前缀。
    • 2） 获取多个对象的方法用 list 做前缀。
    • 3） 获取统计值的方法用 count 做前缀。
    • 4） 插入的方法用 save（推荐）或 insert 做前缀。
    • 5） 删除的方法用 remove（推荐）或 delete 做前缀。
    • 6） 修改的方法用 update 做前缀。
  • 领域模型命名规约
    • 1） 数据对象：xxxDO，xxx 即为数据表名。
    • 2） 数据传输对象：xxxDTO，xxx 为业务领域相关的名称。
    • 3） 展示对象：xxxVO，xxx 一般为网页名称。
    • 4） POJO 是 DO/DTO/BO/VO 的统称，禁止命名成 xxxPOJO。

• 常量的使用

  2. 并发处理

• 获取单例对象需要保证线程安全，其中的方法也要保证线程安全

• 线程资源必须通过线程池提供，不允许在应用中自行显式创建线程。
• 并发其他规约

3. 异常处理

• 对大段代码进行 try-catch，这是不负责任的表现。