1.JDK = JRE + JAVA开发库

2.JRE = JVM + JAVA 核心类库

3.java的保留字： const ， goto 保留字的意思是java并没有使用，以后可能会使用

4.java中的关键字：（main不是关键字）
class ，inteface ，byte ，short ，int ，long ，char ， float ，double ， Boolean ，
void ， true ，false ，null ， if ，else ，switch ， case ，default ， while ， do ，for ，break ，continue ，return

5.java内存分为栈和堆内存：
1.栈内存：在函数中定义的一些基本变量和对象的引用变量都在，栈内存主要存放的是基本类型的数据和八大基本数据类型（注意没有string基本类型，new出来的String对象一般是放在堆中的。如果是 String s =“xxx”; 这种,那就是放在常量池中.）
2.堆内存：存放所有new创建的对象和数组的数据 new xxx（“aaa”）

6.面向对象的特征：封装，继承，多态，是一种以事物为中心的编程思想

7.方法的特征：方法重载，方法递归，方法内存分配

8.面向对象的程序设计：是一种程序开发的方法

9.java为什么要实例化：即 内存地址的使用，实例化之后，才能将对象放在内存中，提供在限定的范围内调用

10.在一个文件中只能有一个public class，想在一个文件中定义多个类则只能写一个public class ，其他类只能用class定义

11.String a = null ， String b = new String（“123”）； system.out.print( a.equals(b) ) --》输出的结果不为false而是报空指针异常，因为空值不能调用方法

12.为什么要用字符流读取文本文件： 因为编码不一致，中文会出现乱码，中文乱码是因为编码没有对应，需要解读只能用字符流解决

break：结束当前循环并退出循环体，break 还可退出switch语句
continue：结束本次循环，进行下一次循环

14.标识符：由数字，字母，下划线（-），美元符号，首位不可为数字

15.对象初始化的方式（五种）：new时创建，静态工厂new Instance， 反射Class.forName() ，clone方式，反序列化

16.byte的值在 -128 ~ 127 之间，整数超多之后变负数，例如：128 = -128

throws是写在方法上面向上抛出异常，表示可能发生异常，向上抛出
throw是写在方法内，自行解决异常：throw new ErrorException(ErrorCode.SYS_ERROR_PARAM);

21.Throwable（可投的）是Exception和Error的父类
/ RuntimeException(运行时异常，非检查异常，无需自己不抓)： NullpointeException ArrayIndexOutOfBound ArithmeticException NumberFormatException
/
/Exception(异常)------
/
Throwable-------- \CheckedException (检查异常，非运行时异常，应该捕获或抛出)：IOException FileNotFoundException SqlException

\Error(非检查异常，程序无法处理的错误； 可恢复但很难)：内存溢出，动态链接异常，虚拟机错误

Collection和Collections的区别
collection是集合类的上级接口，继承于它的接口主要有set和list
collections是针对集合类的一个帮助类，他提供一系列静态方法实现对各种集合的搜索，排序，线程安全

17.构造函数的特点：
1.跟类名一致 2.无返回值：修饰符 + 函数名 {} 3.在对象初始化时调用，即是 new 时 Car car = new Car （）
4.如果不写构造函数，就会默认有个无参构造函数，子类不可继承

18.单例模式：三大类共23种设计模式
创建模式（5种）： 工厂方法，抽象工厂，单例，建造者，原型模式 ~
结构模式（7种）： 适配器 ，装饰器，代理，外观，桥接，组合，享元
行为模式（11种）：策略，模板方法，观察者，迭代，责任链，命令，备忘录，状态，访问者，中介者，解释器

19.java程序初始化的执行顺序：
父类静态变量 -> 父类静态代码块 -> 子类静态变量 -> 子类静态代码块 -> 父类非静态变量 -> 父类非静态代码块
-》 父类构造方法 -》 子类非静态变量 -》 子类非静态代码块 -》子类构造方法

23.servlet 是线程不安全的

成员变量有默认初始值 float - 0.0f double - 0 Boolean - false 引用类型 - null
变量需要赋值，否则编译错误

26.Base base = new Son（）； =》编译看左边，运行看右边，意思就是编译时候，看有没有该方法，运行的时候 结果看new 的对象是谁，就调用谁

非静态成员变量不能被静态方法调用
静态成员变量，静态方法可直接通过类名/对象名 调用，非静态方法，必须通过对象名去调用

27.能被类直接调用，说明是静态的，有static关键词

22.static修饰的变量属于类，只能定义在类中的方法外，因为类加载他就加载了

28.在静态方法中是没有this关键字，静态方法只能访问静态的成员变量和静态

1. 1        2       3
   

for（ 条件1 ； 条件2 ； 条件3 ）{
4
语句
} ===》执行顺序： 条件1 -》 条件2 -》语句 -》 条件3 -》 条件2 -》语句 -》 条件3 -》条件2 【1243 243 243】

32.数据库三范式：
1.列不可分 2.行可以唯一区分，也就是 主键约束 3. 表的非主属性不能依赖与其他表的非主属性，也就是外键约束

34.git和svn区别：
svn是集中式管理的版本控制器，而git是分布式的版本控制器
svn按文件存储，git把内容按元素数据存储
GIT分支和SVN的分支不同：svn会发生分支遗漏的情况，而git可以同一个工作目录下快速的在几个分支间切换，很容易发现未被合并的分支，简单而快捷的合并这些文件。
弊端：
svn：所有的版本数据都存在一个中央服务器上，用户的本地只有自己以前同步的版本，如果不联网的话，用户就看不到历史版本，也无法切换版本验证问题，或在不同分支工作，而且，所有数据都保存在单一的服务器上上面，有很大的风险这个服务器会损坏，这样就会丢失所有的数据，当然可以定期备份
git：（每个人都拥有全部的代码，安全隐患（万一这个人跑路了）），所有版本信息仓库全部同步到本地的每个用户，这样就可以在本地查看所有版本历史，可以离线在本地提交，只需要连网时push到相应的服务器或者其他用户那里，由于每个用户那里保存的都是所有的版本数据，只要有一个用户的设备没问题就可以恢复所有的数据。但增加了本地存储空间的占用
区别：svn是集中放在中央服务器中，而工作的时候，用得都是自己的电脑，所以首先要从中央服务器得到最新的版本，然后工作，完成工作以后，需要把自己做完的活推送到中央服务器，svn是必须联网才能工作
git没有中央仓库，每个人的电脑就是一个完整的版本控制器，工作的时候不需要联网，因为版本都在自己电脑上，协同的方法是这样的：比如说自己在电脑上改了文件a，其他人在电脑上改了文件a，这时候你两之间只需要把各自的修改推送给对方，就可以互相看到对方的修改了
35.什么是RPC远程调用
远程调用协议，通过网络从远程计算机上请求服务，无需了解底层的技术，为通信程序之间携带信息数据如 TPC和UDP,使开发网络分布式的多线程程序更容易

36.i++实际是3个连续的步骤组成的： t = i; t = t+1; i=t 也就是：1.读取userCount的值，并将它保存在某个临时储存装置中；2.递增这个值 ；3.将递增的值写回到userCount中

37.这也是可能触发的线程不安全：假设有一个线程负责读取和递增userCount的值。在它有机会存储递增的值之前，另一个线程会读取它，并且得到的是旧值。当第二个线程最终得到机会写入userCount时，它会替换掉第一个线程的递增值。两个非原子的操作在不同的线程中运行，却操作同一个数据，其中的交叉就称作线程冲突。

38.静态内部类与内部类的区别：
静态内部类 不需指向外部类的引用， 非静态内部类需持有外部类的引用
静态内部类可有 静态成员（方法，属性）， 非静态。。不能有
静态内部类 不能访问外部类的非静态方法，只能访问静态成员，而 非静态内部类两者都可以访问
静态内部类直接实例化， 非静态内部类需要 通过外部类实例化 生成内部类对象
静态内部类才可声明 静态方法，静态方法不可使用非静态变量

49.静态代码块：（不是静态方法） 用static声明，只执行一次 例如：static{…}
构造块：类中直接用{}定义，每创建对象时执行 例如：{…}

内部类可以是静态static的，也可用public，default，protected，和private修饰
外部类的修饰只能是 public ，abstract ，final

52.成员变量用 static修饰 和不用 static修饰的区别：
1.两个变量的生命周期不同
*（非静态）成员变量随对象创建而存在，随对象被回收而获释
*静态变量随类的加载而加载，随类的消失而消失
2.调用的方式不同
*（非静态）成员变量只能被对象调用
*。。。。。。。。。。。被对象，类调用
3.别名不同
*成员变量也称为 实例变量
*静态变量也称为 类变量
4.存储位置不同
*（非静态）成员变量数据存储在 堆内存 的 对象中
*静态变量存在 方法去的 静态区

39.java的原生类（即八大基本数据类型），但不包括数组

42.使用final修饰基本变量类型，其值不能改变，final 修饰引用类型，栈内存中的引用不能改变，但是所指向的（new）堆中的对象是可变的

43.WEB开发中实现会话跟踪实现： session，cookic，地址重写，隐藏域（hidden）

x=1 y=2 z=3 y+= z–/++x 值为3 ： 因为全为int类型，所以3/2也为int类型，不为1.5而是1. 另外z–是运算完后再减就跟for循环里面的一样是最后一步，++x是先增加再运算

45.形式参数可被视为 localvariable（本地 局部变量）

46.类中的成员变量放在 堆中，方法中的局部变量存放 在栈中（可参考 堆与栈的那篇）

47.在WEB应用程序的文件与目录结构中，web.xml是放置在 WEB-INF目录

48.在WEB应用程序中，（web容器）负责将 http请求转换为httpServlectRequest对象

50.Object类无copy()方法

51.类的析构函数是 一个对象被 （撤消）时自动调用

53.float f = 3.4 错误： 因为3.4是双精度，应改为float f = （float）3.4

54.short s1 = 1 s1 = s1 + 1 ； short s1 = 1 s1+=1
第一错：因为1是int，赋值给short 需强转 第二对：因为s1+=1相当于s1 = （short）（s1+1）

55.装箱：若给一个Integer对象赋一个int值，会调用Interger类的静态方法Valueof，如果字面值在-128到127之间，那么就不会 new新的Interger对象，引用常量池中的对象
例如；Interger a = new Interger（3） Interger b = 3 int c=3 -> ab = false ac =true
例如：Interger f1 = 100, f2 = 100, f3 = 150, f4 = 150 f1f2 =true f3f4 =false

56.基础类型与包装类的区别：
*基本类型是直接用来存储值，放在栈中方便快速使用， 包装类是类放在堆中
*基本类型不是对象因此无方法， 包装类是类所有有方法
*基本类型直接赋值即可， 包装类用来new创建，实例化
*基本类型初始值不为null， 包装类初始值为null

57.字符串如何转换为int类型
1) int Num = Integer.parsetInt(“123”);
2) int Num = Integer.valueOf(“123”);

int i= 0，interger y=new Interger（0）；当i==y时 y会自动拆箱成int类型然后比较值；当y.equals(i)时，调用equals后，i会自动装箱成interger类，然后比较

59.Sql优化（提高sql执行速度）：
查询语句尽量用索引，不要进行全表查询
避免在 where语句中对 字段进行 null判断 ，不使用 != 或者 <> 或者 or
in 和 not in 也慎用会导致全表扫描，尽量使用 between
避免使用 like查询， 会导致全表查询

60.如果两个对象相同，则对象的hashCode相同

45、两个对象值相同(x.equals(y) == true)，但却可有不同的hash code，这句话对不对?
对。
如果对象要保存在HashSet或HashMap中，它们的equals相等，那么，它们的hashcode值就必须相等。

62.如何实现对象克隆：
1.实现cloneable接口并重写Object类中的clone方法
2.实现Serializable接口，通过对象的序列化和反序列化实现克隆

一个“.java”源文件中可包含多个类（不是内部类），但是只能有一个公开类（public class）且文件名须和公开类类名完全一致
内部类可引用它包含类（外部类）的成员吗？有什么限制？
可以，包括私有成员，若要访问外部类局部变量，此时局部变量必须用final修饰，否则无法访问

64.反射技术类位于java.lang.reflect（反射）包中，
实现类有：Field , Method ，Construct ，Array（提供动态创建数组） ， Class

Hashtable继承Dictionary类，Hashset继承AbstractSet，TreeMap继承AbstractMap
HashMap实现了Map接口，其余都是实现接口

import不是jsp的指令，而是属性

解决表单提交中文乱码：request.setCharacterEncoding(“utf-8”)

68.实现servlet的单线程：<%@page isThreadSafe=“false”%>

jsp的运行原理：
第一次访问jsp页面时，向一个servlet容器发送请求，servlet容器先要把jsp页面转为servlet代码，在编译成.class文件再调用，再访问jsp时，直接调用

70.为什么重写equals（）方法后必须重写hashCode（）方法?
hashCode也是用来比较两个对象是否相等的，如果两个对象的hashcode值相同，那可认为两个对象是同一个对象
一般如果使用java中的map对象进行存储时，他会自动调用hashcode方法来比较对象，所以如果我们对equals方法进行重写，建议一定要对hashcode方法，以保证相同的hash值
它的重写主要针对map，set集合类型使用：
1.map set集合类型存放的对象必须是唯一的
2.集合类型判断两个对象是否相等，并判断equals是否相等，如果equals返回true，还要再判断hashcode返回值是true，只有两者返回true，才认为两对象相等
3.由于Object的hashcode返回的是对象的hash值，所以即使equals返回的，集合也可能判断两个对象不相等，所以必须重写，以保证当equal返回true，hashcode的返回true

116.set里元素是不能重复的，那么用iterator（）方法来区分重复与否

最有效率的算出2乘17（移位运算）：17<<1 或 2<<4 +2
因为：2*17 = 34 所以： 010001代表17 右移动1位 100010 就是 34了

java和JavaScript的区别：
js是基于对象， java是面向对象的
js是动态语言， java不是
js是解释性语言 java是编译性语言

73.jq是什么：
jq是js封装的一个库，可兼容不同浏览器，提高开发效率

74.如何设定jq异步调用还是同步调用？
调用的ajax函数，async属性
$.ajax{
async: true //表示异步
false // 表示同步
}

ajax（异步刷新）
可实现局部刷新，再不更新整个页面的情况下刷新某些数据
（发送异步请求，返回json数据给前端）
【再不刷新页面的前提下，发送异步请求到后台，并获取后台返回的json数据】
（在springMvc中加responebody）

76.jq 与 js的区别：
js是一种脚本语言
jq能做的js定能做，js能做的jq不一定能做

        jq的ready（）                                   与                   js的load（）
加载时机：$（document）.ready()                                                window.onload() (包括图片)只需要等待网页dom结构加载完毕，就能执行js代码                 需等待网页全部加载完毕，然后再执行js代码执行次数：   可执行多次，不会覆盖                                                只能执行一次，如果有第二次则覆盖第一次

#和KaTeX parse error: Expected 'EOF', got '#' at position 9: 符号的区别 #̲是预编译防止sql注入（例如 …是sql拼接
方法在单个参数的时候，#可以忽略不写@param（“”） ，$符号必须写
单个参数用上if for标签时写@param（“”）

resultType 和resultMap的区别
resultType 不支持字段的别名 — 可定义vo类
resultMap 支持字段的别名，支持orm（对象关系映射）

线程类问题：************************************************************************************************************************************************
79.
进程：执行中的程序 线程：程序中单独顺序的控制流
一个进程可包含一个或多个线程至少一个线程

java的Daemon线程，setDaemon（）—》即是把线程设置为守护线程，则必须在start之前（必须要在启动之前）设置

81.实现多线程：同步代码块和同步方法，均用Synchronized关键字
同步代码块：Synchronized（xxxxx）， 同步方法：Synchronized 写在方法头上 public synchronized void run() {} 或者 synchronized（this）{}

线程的状态：
1.创建（主程序）：创建Thread的实例（未被启动） 例：Thread thread = new Thread（）
2.就绪：调用start（）方法，线程启动，等待cpu的调度
3.运行：执行run（）方法，即线程已获得cpu资源正执行任务，线程将一致运行到结束
4.阻塞：让出cpu暂停线程【既有 sleep（）—>被唤醒后进入就绪状态，wait（），suspend（）{被另一半线程阻塞的 方法}–》调用resume（）恢复】
5.终止：自然终止–运行run方法后终止； 异常终止–调用stop（）方法终止

线程状态转换： <------
初始----> 就绪 ----->运行 ----->结束/异常终止
^ |
| V
|++++++++ 阻塞

实现并启动线程：
1.继承Thread类，重写run方法，用start方法启动线程（ new A().start ）
2.实现Runnable接口，实现run方法，用new Thread( new A() ).start()启动
例子：
1.继承Thread类 2.实现Runnable接口
public class java_thread extends Thread{ public class java_thread implements Runnable{
public static void main(String args[]) public static void main(String args[]) {
{ (new Thread(new java_thread())).start();
(new java_thread()).start(); System.out.println("main thread run ");
System.out.println("main thread run "); }
} public void run()
public synchronized void run() {
{ System.out.println("sub thread run ");
System.out.println("sub thread run "); }
} }

两种方式创建线程：
1.继承Thread类的实际操作方式：
步骤：
1.继承Thread类 2.重写run方法（线程执行时就是执行类中的run方法中代码）
3.创建线程对象 4.调用start方法，启动线程
例子：
1)第一步.创建一个类MyThread继承Thread
public class MyThread extends Thread{ //1.继承Thread类
@Override
public void run（）{ //2.重写run方法
for（int i = 0； i<10 ; i++）{
system.out.print(“线程执行了” + i + “次”)
super.run();
}
}
}

     2)第二步.创建另一个类Text1public class  Text1{public static void main(string [] args){sys("开始main函数");MysThread m = new MyThread("A")//3.创建对象MyThread.start();// 4.调用start方法，启动线程sys("结束main函数")}}2.实现Runnable接口的方式创建线程步骤：  1.实现Runnable接口                  2.重写run方法3.创建线程对象，并传入Runnable对象  4.调用start方法，启动线程例子：1)第一步：创建MyRunnable类实现Runnable接口Public class MyRunnable  implements  Runnable{ //1.实现@overridepublic void run（）{ // 2.重写run方法 }}2)第二步：新建Test2类public class Test2{public static void  main（string 【】 args）{sys（"开始main函数"）Thread t = new Thread（new MyRunnable（））//传入Runnable对象，既有run方法的那个类  // 创建对象，传入Runnable对象t.start();//调用start方法可改写成 ：MyRunnable  r1 = new  MyRunnable（“A”）MyRunnable  r2 = new  MyRunnable（“B”）Thread t1 = new Thread（r1）Thread t2 = new Thread（r2）t1.start（）；  t2.start();   //来进行Runnable 的对象传递}}

sleep（）和yield（）有什么区别？
1.sleep（）方法声明抛出interruptedException（中断异常），而yieId（）方法无声明异常
2.线程执行sleep（）方法转入阻塞状态，执行yieId（）方法后转入就绪状态
3.sleep（）方法比yieId()方法具有更好的可移植性

86.wait（）和notify（）的区别：
wait（） ， notify（），notifyAll（）都不属于Thread类，而是属于Object基础类
也就是每个对象都有wait（），notify（），notifyAll（），因为每个对象都有锁，锁是每个对象的基础，使用这些方法的时候用上锁也是最基础的

87.resume（）方法负责重新开始被 suspend（）方法中断的线程

88.wait():导致当前的线程等待，直到其他线程调用此对象的notify（）/ notifyAll（）方法

89.notifyAll():唤醒在此对象监视器上等待的所有线程，注意并不是给所有唤醒线程一个对象锁，而是让他们竞争

90.notify(): 唤醒在此对象监视器上等待的单个线程，不能确切唤醒某个线程，而是由jvm确定唤醒哪个线程，而且不说按优先级

91.sleep（）: 休眠当前线程/主要是为了暂停当前线程把cpu让给其他线程

92.Thread.sleep() 和 Object.wait()都可抛出一个检查异常 （checkExption）

wait() 和 sleep()区别:
1.sleep()方法，我们首先要知道该方法是属于Thread类中的，而wait()方法则属于Object类中的，sleep（）方法导致了线程暂停执行指定时间，让出cpu给其他的线程
但他的监控状态依然保持着，当指定的时间到了会自动恢复运行状态
2.wait()方法是导致当前线程等待，直到其他线程调用此对象的notify（）/notifyAll（）时唤醒

 sleep不释放对象锁（也就是上面的监视状态依旧保持），wait释放对象锁

死锁只能避免，无法解决
避免的方法就是：
1.互斥（某时刻只能进一个线程）
2.同步（在互斥的基础上，让线程拥有先后顺序）

编写线程不安全的例子：
public class xxx implement Runnable{
private int num = 50; //50车票
public void run(){
// synchronized(this) { 如果需要线程安全则将 synchronized(this) {}包住for循环
for (int i = 0;i < 50; i ++){
if(num > 0){
try{
Thread.sleep(100);
system.out.print(Thread.currentThread().getName() + “抢到了第” + num + “号车票”)
}catch(Exception e){
e.printStackTrace();
}
}
}
}
}

public static void main (String [] args){
//创建三个线程，模拟三人抢票
Runnable count = new Count（）
new Thread（count,“A”）.start();
new Thread(count,“B”).start();
new Thread(count,“C”).start();
}

例子：模拟三个窗口卖票
public class MyThread extend Thread{ // 继承thread类
int ticket = 50 ； // 票数 // static int ticket = 50 —》 如何让它共用一个ticket，一起卖50张呢？ 将ticket改为static 共同的就可以了
public MyThread（）{} //添加构造函数
public MyThread（string name）{
this.setName(name);
} //添加构造函数

 @overridepublic void run(){//重写run方法while（ticket > 0）{ticket --;sys("卖了一张票" + “剩下” + ticket + “张”)}}
}
public class Test1{public static void main（string [] args）{//创建线程定义卖票窗口MyThread  m1 = new MyThread（“1号窗口”）；MyThread  m2 = new MyThread（“2号窗口”）；MyThread  m3 = new MyThread（“3号窗口”）；//启动线程卖票m1.start();m2.start();m3.start();}
}
此时输出的三个窗口每个窗口都会卖50张，也就是3个窗口就共输150张，不符合条件，因为每newyige对象就新分配了 ticket张数，所以new 3 三个就为150张

为什么需要锁（并发控制）？
在多用户环境中，在同一时间可能有多个用户更新相同的记录，这会发生冲突—并发

让线程停止执行的方法有：sleep（），wait（） ，synchronized（），stop（），yieid()–当前正在被服务的线程可能觉得cpu的服务质量不够好，于是提前退出

继承Thread类与实现Runnable接口的区别：
1.继承Thread类中用的是同一个对象，所以要将属性或方法改为static的，且在同步时Synchronized（）中填的必须是“当前类.class”，
且用同步方法private synchronized void tell() {} 时需要在private synchronized间加上static --》private static synchronized void tell() {}

2.实现Runnable接口中，因为创建了一个Runnable对象 MyRunnable B = new MyRunnable(),然后再在后面创建的对象中引入了这个Runnable对象 Thread t = new Thread（B）,所以用的都是同一个Runnable对象，所以属性和方法都无需加static且在用同步时synchronied（）中填的可以是this

---

String，StringBuilder，StringBuffer区别:
String是不可变的字符串，它的底层是一个用final修饰的字符数组
在修改字符串时使用StringBuilder，StringBuffer
StringBuilder是线程不安全的，运行效率高，StringBuffer是线程安全的
例子：如果一个字符串变量是在方法内定义，则只可能有一个线程访问不存在不安全的所以用stringBuilder
如果要在类里面定义成员变量，并且这个类的实例对象会在多线程环境下使用则用stringBuffer

"编译时异常"必须显示处理，"运行时异常"交给虚拟机

事务的四大特征：
原子性，一致性，隔离性，持久性

分表分库：分表：两种切分：纵向切分和横向切分分库：可将一个模块做为一个数据库【垂直分库】
1.纵向切分 （把不常用的字段分到独立一张表，用统一id关联，外键） 例如商品表和商品详情表这样的分割c1 c2 c3 c4 --c1 c2 c3\c1 c4
2.横向切分 （按切分角度，维度）1）可按1w人一张表，1w人一张表；2）可按医院切分，属于这个医院的就在一张表； 3）按天，如果是今天的又一张表，昨天的一张表

104.四种会话跟踪：
cookie，session，url重写，隐藏表单域Hidden

105.防止表单提交的4种方法：
1.给数据库增加唯一键约束

2.利用session防止表单重复提交：服务器返回表单时，会先生成一个subToken保存于session并把该subToken传给表单页面，当表单提交时会带上subToken服务器拦截器Interceptor会拦截该请求，拦截器判断session保存的subToken和表单提交SubToken是否一致，若不一致或session的subToken为空或表单未携带subToken则不通过3.使用AOP自定义切入实现：原理：1）自定义防止重复提交标记  2）对需要防止重复提交的congtroller里的mapping方法加上该注解3）新增加Aspect

Volatitle关键字：1.线程不安全  2.用在多线程同步，可保证读取的可见性3.能禁止进行指令重排序  4.JVM保证从主内存加载到线程工作内存的值是最新的

109.Maven是项目管理和项目构建工具，仓库分为：本地仓库和远程仓库

111.Token（令牌）
（存放在redis中，超时需要新生成并通知前端）
Token是令牌，是服务器生成的一串字符串，作为客户端进行请求的一个标识
当用户第一次登录后客户端将账号密码传到服务器，服务器生成一个token并将此token返回给客户端保存着，以后客户端只需要带上这个token前来请求即可，无需再次带上用户名和密码
作用：防止表单重复提交-----后端生成一个token给客户端，客户端存储token----表单中使用隐藏域来存，也可以用cookie来存，然后再将request请求中的token和session中的token

基于Tolen登录：token令牌相当于用户的一个身份，里面有userid+时间戳，每个请求都带着token访问
1.用户输入密码账号，后台服务器通过加密或生成一个token
2.前端获取token，存到cookie或，在接下来请求中，将token通过url参数或httpHead传入服务器
3.服务器获取token值，通过查找数据库判断当前token是否有效
【浏览器】 【服务器】
| ---------------------登录：username和pid-------> |
| <-------------token:xxxxy-1------------------ |
（拿到token后将token保存在本地） | |
| |
|—后续请求：将之前保存的token放到httpheader或者url参数后面-------> |
| |
| <--------------------------------------------------------- |
(登录验证成功后，将登录凭证做数字签名，加密后得到串作为token返回给客户端) ，若希望token有时效则写在redis里面

112.异或的运算符： ^ 其主要是对两个操作数进行位的异或运算，相同取0，相反取1。即两操作数相同时，互相抵消。
int a=15;
int b=2;
a^b=13
a=15的二进制是1111，b=2的二进制是0010，经过异或运算后，得到的二进制数为1101，转换为十进制就是13。

114.final 关键字 和finally 关键字
final：
使用final声明的类不能继承，
使用final声明的方法不能被重写
使用final声明的变量变为常量 即是开始就要被赋值
使用final修饰的属性变成大写 如：final int INS= 10;
final不能用于修饰构造方法
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型

finally：在try catch后，且只能放一个1.finally不一直执行，表示在trycatch中不管有无异常都会执行，但是当程序再try块之前就发生异常，则会直接结束，不会执行finally  例如 int i= 1/10 ;try{....}catch{....}finally{....};      或者碰到exit方法时不会执行finally2.try catch 中有return时，finally仍会执行3.finally 中最好不要包含return，否则程序会提前退出，返回值不是try catch中的：因为finally和try catch中都有return，那么finally中return会覆盖别处的return语句，最终返回的是finally中的return值，因为别处在等待区情况分为finally中有无return： 1.如果finally中有return得话且try cathch中也有return，那么程序运行trycatch 然后运行finally然后return finally中的值；2.如果finally中无return但try catch中有return，那么程序运行 try catch  然后将值放在等待区，等待运行完finally，然后再return  return的值是try catch中改变后的值，即使再finally中修改了也不会影响，最终返回的还是try catch中的值4. 若别的语句有return，则程序会先执行finally中的syso的值，再进行其他的输出，原理是：程序在执行到return时会先将返回值存储在一个指定位置，再执行finally块，最后再返回刚刚存储的值，有异常情况下若finally后又return则不会运行这个return

例如：int a = 0 ; int b = 0 try{ return a+b; }catch{ } finally{ a += 100; } 无return，则输出值依旧为0，finally中的不会改变try catch中return的值
且顺序为 先执行try catch中的return，将return中的值先保存，等finally执行完成后再输出return中的值，所以finally中的值不会改变上面try中return的值

try中有return则finally在return前执行

final类是最终类，是不能有子类的类。Abstract和final不能同时修饰一个类，因为抽象类本身没有具体对象，需要派生出子类后在创建子类的对象，而最终类不可能有子类

145.try{}里面有一个return语句，那么紧跟在这个try后的finally{}里的code会不会被执行，什么时候被执行，在return前还是后？
答案：会执行，在return前执行

数组只有length属性，string才有length（）方法

string是final类故不可继承

167.是否可以继承String类?
String类是final类故不可以继承。

117.子类其实可以继承父类所有东西，只是有些不可调用（例如：private，代码块）

switch中只允许：byte，short，int ，char （因为都可以转为int）

描述JVM加载class文件的原理机制:JVM中类的装载是由classLoader和他的子类来实现，Java classLoader是一java运行时系统组件，它负责在运行时查找和装入类文件的类

121.如何实现单线程：<% @page isThreadSafe = “false”%>

finally不属于object类中方法，object中有equals，getClass，hashCode，toString，notify

构造函数的作用是对象初始化（属性初始化）

一个完整的url地址由： 协议，主机名，端口，文件 四部分组成

默认的浮点类型是double 如果要指明是float需在后面加f

java.exe是java虚拟机 javadoc.exe用来制作java文档 jdb.exe是java的调试器 javaprof.exe是剖析器

Char型变量中能不能存储一个中文汉字？ ：java采用unicode编码，2个字节代表一个字符，char中是2个字节，所以可以存储中文

数组若为int 则默认值为0，若为string则默认值为null

1.                     char(2)|V
   

   byte -----> short ------>int ------>long boolean(1)
   字节 （1） （2） （4）\ （8）
   | \ |
   | \ |
   | \ |
   V \ V
   float ----> double
   （4） （8）

   （byte，short，int，long）属于整数型， （float，double）属于浮点型， （char）属于字符型

134.this和super得区别
this指的是本身，再构造函数调用之间可使用this
super指的是父类，一般用于继承时，可调用父类得构造函数，属性方法

135.逻辑运算符：
长路与& （只要有一个false，结果都为false）：他会把（两边得关系运算结果）都计算出来（不管true和false两边都算）
短路与&&（有可能只运算一边）：当运算左边得关系运算结果是false时，不再对右边得关系运算进行计算
长路或| （只要有一个为true，结果都为true）：会将两边的关系运算结果算出来
短路||：当左边结果为true时不再进行右边运算，当左边结果为false，则继续进行右边运算
非运算符 ！
三种逻辑运算符的优先级：
非运算符（！）>与运算符（&）>或运算符（|）
例如： 5>=7 || 4<5 && !false
步骤一：计算5>=7 结果为false
步骤二：计算4<5 结果为true
步骤三：计算非运算 ！false 结果为true
得false || true && true
步骤四：计算true && true = true
步骤五：计算false || true = true

1. a++ 和 ++a
   a++先运算再加1，++a先加1再运算

137.如果方法结束后不返回任何值，则需写void

141.方法递归：无限调用自己

139.封装得目的
方便使用，保护某些属性和方法不被外部所看见

140.四种修饰方法的访问控制符

                         piblic    protected   default（friendly/无修饰符）   private

本类（同个类里方法和属性）： √ √ √ √
同包（同一个包名下面）： √ √ √
子类： √ √
其他： √

149.在什么情况下调用doGet（） 和doPost（）
jsp页面中的form标签的method属性为get时调用doGet（），为post时调用doPost（）

164.Math.round(11.5)等於多少? Math.round(-11.5)等於多少?
Math.round(11.5)12
Math.round(-11.5)-11
round方法返回与参数最接近的长整数，参数加1/2后求其floor

99乘法:
for（int x=0; x<=9; x++）{
for(int y=1; y<=x; y++ ){
sys(y+""+x+"="+xy+"\t")
}
sys();
}

选择排序：（假设第一个是最小值，然后跟组中数据比较，把最小值放前面）
for（int i = 0； i<arr.length-1; i++）{
//假设当前值是最小的
int minIndex= i;
for(int j = i+1; j<arr.length; j++){
if(arr[j]< arr[minIndex]){
//修改最小值下标
minIndex = j
}
}
int tem = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = tem;
sys(Arrays.toString(arr))
}
}

冒泡排序：（每次都将当前循环中最大放在后面，然后就不用比较最后的那个就可以减少次数）
public static void main(string [] args){
int [] arr = {1,5,8,2,6,9,6}
for(int i = 0; i<arr.length-1; i ++){
for(int j = 0; j<arr.length - 1 - i; j++){
if( arr[i] > arr[i+1] ){
int tmp = arr[i];
arr[i] = arr[i+1]
arr[i+1] = tmp;
sys(Arrays.toString(arr));
}
}
}
}
解析：
第一趟比较完后最后一个数是最大的，所以第二趟比较时最后一个数不参与
例：int [] arr = {1,5,8,2,6,9,6}
第一趟：
第一次:6和3比,6 > 3,交换：3,6,8,2,9,1
第二次:6和8比,6 < 8,不交换：3,6,8,2,9,1
第三次:8和2比,8 > 2,交换：3,6,2,8,9,1
第四次:8和9比,8 < 9,不交换：3,6,2,8,9,1
第五次:9和1比,9 > 1,交换：3,6,2,8,1,9
第一趟共进行了5次，结果为3，6，2，8，1，9

 第二趟：第一次:3和6比,3 < 6,不交换：3,6,2,8,1,9第二次:6和2比,6 > 2,交换：3,2,6,8,1,9第三次:6和8比,6 < 8,不交换：3,2,6,8,1,9第四次:8和1比,8 > 1,交换：3,2,6,1,8,9第二趟共进行了4次，结果为3,2,6,1,8,9

随机排序：
数组：1,2,3,4,5,6,7,8
String[] a = {“1”,“2”,“3”,“4”,“5”,“6”,“7”,“8”};
String[] b = new String[8]; //a.length
int m = a.length //
for(int i =0; i< b.length; i++){
int r = (int)(Math.random()*n);
b[i] = a[r]; a[r] = a[n-1];
n–;
sys(b[i]++"");
}

113.接口与抽象类 （在接口中编写的都是抽象方法）
抽象类：
1.类定义用（public ，protected修饰） + abstract修饰
2.不能直接实例化，需要通过子类继承进行实例化
3.含一个抽象方法的类就是抽象类，如果类已是抽象类，则可无抽象方法 （所以也就是：抽象类可以含有抽象方法，也可以不包含抽象方法，抽象类中可以有具体的方法；）
4.可有构造函数，可有普通成员
5.可以有普通方法和抽象方法，所以其中的方法可被static修饰
6.如果一个子类实现了父类（抽象类）的所有抽象方法，那么该子类可以不必是抽象类，否则就是抽象类；
7.抽象类可实现接口
子类继承后需要重写抽象类中所有的抽象方法。

编写抽象类：
1.写父类
public abstract class Animal{
public abstract void eat{
sys（）
}
}
2.定义一个肉食类继承
public class Rushi extends Animal{
public void eat{
sys（“吃肉”）
}
}
3.定义一个素食类
public class Sushi extends Animal{
public void eat{
sys（“吃素”）
}
}

抽象方法：
1.声明而未被实现的方法
2.必须使用abstract关键声明
3.方法中只有声明没有实现（没有方法体）
4.抽象类中可有其他方法和变量和代码块
5.通过不同子类继承重写
6.抽象方法不可用static，因为他是要被子类重写的，静态方法无法重写

接口：
1.使用interface修饰，public，abstract以及 default 默认 （pad三种修饰）
2.只有全局静态常量（static final 可不写 默认添加）和公共的抽象方法，不可有构造函数
3.不能直接实例化，需要通过子类 implement实现进行实例化
4.接口中所有的方法都是public/final修饰（默认）只有public 也对，而且都是抽象方法，修饰接口中的方法有public abstract static（一起可有可无，不能直接用static修饰）连起来
5.接口中方法全是抽象方法，所以其中的方法不可被static修饰
5.接口可以多实现，一个接口不可继承抽象类只可继承接口且可多继承接口
子类可以实现多接口，子类可同时继承（只能继承一个）抽象类和实现接口，子类实现接口后需要重写接口的所有抽象方法，实现类实现的方法（也就是子类中重写的方法）必须要用public修饰，否则编译不出来
//编写接口 interface声明
public interface UsbInterface{
void service();
}
//实现接口 implements 实现
public class UD implements UsbInterface{ /// 多个接口用“，（逗号）分割”
public void service(){
sys()
}
}
//使用接口,用接口实现多态
UsbInterface uf = new UsbInterface();
uf.service

多态的三个前提条件： 1.继承的存在 2.子类（重写）父类的方法 3.父类（引用变量）指向（子类对象）
实现多态的机制是什么？ 方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。

1. 方法重写（override）和 方法重载（overload） 区别
   重写：（2同2小1大）方法名，形参列表相同；（返回值类型）和（异常类型） 子类小于等于父类；(访问权限子类大于等于父类)(切记 父类私有方法，final修饰方法，代码块不能重写)，
   是父类与子类之间多态性 例如：实现接口写的方法
   重载：方法名相同，返回值类型相同,参数列表不同
   是一个类中多态性 例如：构造函数

重载方法的参数必须不同或是参数个数不同，或者是参数类型不同，重载的多个方法必须返回相同的数据类型

142.继承 extends
1）（父类构函），（私有）private得成员，代码块 不可以被继承，但父类构函可被调用用super（）
2）如果（子类）成员与（父类）相同，子类会（覆盖）父类
6）this与super不可同时再一个方法中

130.链表具有的特点：
1.采用动态分配存储
2.插入删除时只要找到对应前驱结点修改指针即可无需移动
3.所需空间与线性表达长度成正比

修饰方法的非访问控制符可以是：static，final，abstract，native（本地方法），synchronized，volatile（易失域）

146.3种引用数据类型：类，接口，数组

147.说明内存泄漏和内存溢出的区别和联系，结合项目经验描述Java程序中如何检测？如何解决？
答：
内存溢出 out of memory，是指程序在(申请内存时)，没有足够的内存空间供其使用，出现out of memory； 比如申请了一个integer,但给它存了long才能存下的数，那就是内存溢出。
内存泄露 memory leak，是指程序在(申请内存后)，无法释放已申请的内存空间，一次内存泄露危害可以忽略，但内存泄露堆积后果很严重,最终会导致内存溢出，无论多少内存,迟早会被占光。memory leak会最终会导致out of memory！

163.GC是什么? 为什么要有GC?
GC是垃圾收集的意思（Gabage Collection）,内存处理，忘记或者错误的内存回收会导致程序或系统的不稳定，
Java提供的GC功能可以 (自动监测对象是否超过作用域从而达到自动回收内存的目的)， Java语言没有提供释放已分配内存的显示操作方法。程序员可以手动执行System.gc()垃圾回收

JVM中垃圾回收分为Scanvenge gc和full gc，其中full gc 触发条件有：
老年代满，持久代满，system.gc()

107.同步和异步的区别：
如果数据将在线程间共享也就是共享数据，那么必须使用同步，当应用程序在对象上调用了一个需要花费很长时间执行的方法，并且不希望等待方法的返回时，用异步

162.何为序列化
序列化是将对象转换为容易传输的格式的过程。是为了解决对象流读写操作时可能引发的数据乱序等问题（如果不进行序列化可能会存在数据乱序的问题）
实现Serializable（xi rui lai shi er bo）接口

165.说出数据连接池的工作机制是什么?
J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，
池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，
新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。

148.GET和POST的区别
get post
不会重复提交 重复提交
2048个字符 无限制
ASCLL字符 无限制
URL中可见 URL中不可见
安全性差 高

166.abstract的method是否可同时是static,是否可同时是native，是否可同时是synchronized?
都不能

151.页面间对象传递的方法：
request，session，application，cookie

150.servlet生命周期
1.实例化----servlet容器创建servlet的实例
2.初始化----调用init（）方法，在生命周期只执行一次
3.服务------如果请求servlet，则容器调用service（）方法
4.销毁------销毁实例之前调用destroy方法（销毁之前自动调用，但手动调用这个方法就不一定会销毁，在remove时候或者关闭执行）
5.不可用----销毁实例并标记为垃圾收集

153.JSP九大隐式对象（页面可以直接调用）
request（封装用户请求）
response（向用户做出响应）
page （jsp页面本身）
session（客户和服务器间的会话）
config（包含servlet初始化要用的参数）
application（服务器启动时运行，用来存放全局变量，再用户间共享）
out（输出–system.out.println）
pageContext（用于访问page的各种对象）
exception（异常）

155.jsp的常用指令
isErrorPage（是否能使用Exception对象），isELignored（是否忽略表达式）

160.JavaScript 中 null和 undefined 是否有区别？有哪些区别？
赋值角度说明：
null 表示此处没有值，undefined表示此处定义了但是没有赋值

从数据转换角度：
Null在做数值转换时会被转换为0，undefined会被转换为NaN

159.WEB应用中如果有.class和.jar类型的文件一般分别应该放在什么位置？
class文件放在WEB-INF/classes文件下，.jar文件放在WEB-INF/lib文件夹下

168.J2EE是技术还是平台还是框架？
J2EE本身是一个标准，一个为企业分布式应用的开发提供的标准平台。
J2EE也是一个框架，包括JDBC、JNDI、RMI、JMS、EJB、JTA等技术。

1. 转发 和 重定向：
   1)转发/forward：request.getRequestDispatcher("/second").forward(request,response)
   过程：
   客户端发送http请求
   web服务器接收请求
   调用内部的一个方法在容器内部完成请求处理和转发动作
   将目标资源发送给客户
   2)重定向/redirect（ri?d??rekt ）：response.sendRedirect("/second")
   过程：
   客户端发送http请求
   web服务器接收后发送302状态码响应以及对应新的location给客户端浏览器
   客户浏览器发现是302响应，则自动再发送一个新的http请求，请求url是新的

不同点：1.转发是服务器行为，                                 重定向是服务端引导的客户端行为2.转发浏览器(只做一次访问请求)，传递的信息不会丢失;  重定向是浏览器做了（至少两次的请求），数据会丢失4.转发浏览器地址不变，                                重定向浏览器地址改变（为第二个）
注意：                                                   重定向可以重定向到servlet也可以重定向到jsp页面
如何选择使用：有中间数据需要处理时最好使用转发想隐藏真实请求的url的使用转发（异常跳转）阻止重新加载（刷新）时被重复调用，使用重定向（超时登录）一般增删改都使用重定向，查询使用转发      （因为如果增删改的话用转发，不断的刷新，那么会带着参数不断的请求，也就是不断的增加这个数据，然后数据库炸了）如果目标响应页面不需要从request中读取任何值，则使用重定向（还可以防止表单重复提交）

154.request.getAttribute() 和 request.getParameter()的区别：
getAttribute返回request范围内存在的对象，getParameter获取http提交的数据,返回字符串

156.jsp动态Include与静态Include的区别：
动态：用jsp：include实现
<jsp:include page=included.jsp flush=true />它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数
静态：
用include伪码实现,定不会检查所含文件的变化，适用于包含静态页面
<%@ include file=included.html %>

157.JSP和Servlet有哪些相同点和不同点
本质上，jsp就是servlet，因为jsp编译后就是servlet
Jsp在客户端，servlet在服务器上
jsp侧重于页面表现，servlet侧重于逻辑编译
在mvc设计模式中，jsp位于视图层v，servlet位于控制层c

158.session和cookie的区别
session将信息保存再服务器上，cookies保存在客户端上
session比cookie安全，session使用了cookie的机制
session时在服务器端，通过sessionId把数据保存在（客户端)
session可存（object类型）和（简单数据类型），cookie只能存（string类型）

170.Mybatis的缓存：
Mybatis缓存分为二级和一级缓存
一级缓存存放 （session中）：在会话过程时，查询获取的数据会放在一级
二级缓存存放在（它的命名空间中），默认是打开的，使用二级缓存属性类需要实现serializable序列号接口，可在他的映射文件中配置：当会话关闭时，一级缓存的数据会保存在二级缓存中----以查询为主少增删改
三级缓存：实现跨jvm，远程调用实现同步

172.B2B2C,B2B,B2C,C2C,
B2B2C:是一种电子商务类型的网络购物商业模式
B2B:是指商家与商家建立的商业关系. 例如我们在麦当劳中只能够买到可口可乐是因为麦当劳与可口可乐中的商业伙伴的关系. 商家们建立商业伙伴的关系是希望通过大家所提供的东西来形成一个互补的发展机会,大家的生意都可以有利润. 例子：阿里巴巴、慧聪。
B2C:就是我们很经常看到的供应商直接把商品卖给用户. 例如你去麦当劳吃东西就是B2C, 因为你只是一个客户. 例子：当当、卓越、优凯特。
C2C (Consumer to Consumer), 客户之间自己把东西放上网去卖. 例子：淘宝、拍拍、易趣

新总结----java面试题相关推荐

1. 比较新的java面试题——持续更新

   https://blog.csdn.net/u010697681/article/details/79414112

2. 用友公司Java面试题（含答案）

   为什么80%的码农都做不了架构师?>>>    用友公司Java面试题(含答案) 1.Hashtable和HashMap有什么区别?   a.Hashtable是继承自陈旧的Dict ...

3. java面试题2019 答案

   Java 面试随着时间的改变而改变.在过去的日子里,当你知道 String 和 StringBuilder 的区别(String 类型和 StringBuffer 类型的主要性能区别其实在于 Stri ...

4. Java面试题及答案整理（2022年140道）持续更新

   发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~博主已将这些面试题整理到一个网站上,每天更新 Java 面试题,目前有 1万多道 Jav ...

5. Java面试题及答案整理(2022最新版) 持续更新

   发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~博主已将这些面试题整理到一个网站上,每天更新 Java 面试题,目前有 1万多道 Jav ...

6. Java面试题及答案整理（ 2022年最新版，持续更新）

   发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全~ 这套互联网 Java 工程师面试题包括了:MyBatis.ZK.Dubbo.EL.Redis.MySQL. ...

7. Java面试题大全带答案 110道（持续更新）

   本人发现网上虽然有不少Java面试题大全带答案,但第一未必全,第二未必有答案,第三虽然有答案,但未必能在面试中说,所以在本文里,会不断收集各种面试题,并站在面试官的立场上,给出我自己的答案 如果不背 ...

8. Java面试题及答案整理（ 2022最新版，持续更新）

   发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ Java面试永远是程序员迈向成功的第一个门槛,想要面试成功,各种面试题的洗礼是必不可少 ...

9. Java面试题及答案整理 140道（ 2021年持续更新）

   发现网上很多Java面试题都没有答案,所以花了很长时间搜集整理出来了这套Java面试题大全,希望对大家有帮助哈~ 本人发现网上虽然有不少Java相关的面试题,但第一未必全,第二未必有答案,第三虽然有答 ...

最新文章

1. 【图解】2020年(下)软考准考证打印入口及注意事项
2. 服务器控件 原生html,应用样式到HTML服务器控件
3. MySQL高级 - 案例 - AOP记录日志
4. 【2020牛客NOIP赛前集训营-提高组（第二场）】题解（GCD，包含，前缀，移动）
5. Nginx的配置实例（反向代理实例 ）
6. linux切换到字符界面stemctl,CentOS7两种模式
7. linux root密码激活,Linux - root初始密码设置
8. java语法优化小结
9. Django 的第三方包
10. JAVA在PDF指定位置赋值
11. [PyTorch] 保存模型和恢复模型
12. 力扣-148 排序链表
13. linux下常用压缩（compress ，gz ,bzip2,xf）命令和打包命令（tar,zip）详解
14. IPv4正则表达式匹配
15. SAS下载高频数据脚本
16. 数据AES加密安全传输之后台JAVA加密解密
17. 【机器人算法】机器人动力学参数辨识
18. UOJ#449. 【集训队作业2018】喂鸽子（期望dp）
19. 苹果x电池多少毫安_苹果x掉电快，苹果x换电池多少钱
20. async-supported的作用

热门文章

1. 短视频剪辑小技巧，少用平剪很重要，教你剪出受人欢迎的短视频
2. 为什么政府网站要用SSL证书来保障信息安全？
3. 零基础学Python--------第8章 模块
4. 小程序错误--Super expression must either be null or a function at _inherits
5. 【转】分享上大学后养成的好习惯
6. RHCE（firewalld——查看及使用）
7. 风场可视化：随机重置
8. 厦门三日游—悠闲、惬意的停靠点
9. 化学实验中分离与提纯方式汇总
10. 将接收的二进制流转换成图片保存