0.bootstrap常用英语：
typography 排版
Glyphicon 字形图标
breadcrumb 面包碎屑（这里是用来在导航中显示当前页面的位置）
Pagination 分页
badges 徽章（举例显示4条未读消息的提示，带圆形背景）
jumbotron 超大屏幕
tooltip 提示工具插件
popover 弹出框插件
affix 附加导航插件
text-muted muted柔和的，意思是文字颜色淡灰色
scheme 策划计划
schema 概要，计划，图表;
tab 选项卡
1. Java中的一个byte，其范围是-128~127的.
byte是一个字节保存的，有8个位，即8个0、1。
8位的第一个位是符号位，
也就是说0000 0001代表的是数字1
1000 0000代表的就是-1
所以正数最大位0111 1111，也就是数字127, 负数最大为1111 1111，也就是数字-128
2.
byte b;//指定变量b为byte型 (最小值-128 最大值127)
一个常量，保存 byte 类型可取的最大值，即 27-1。(127)
一个常量，保存 byte 类型可取的最小值，即 -27。(-128)
---------------------------------------------------
short s;//指定变量s为short型
保存 short 可取的最大值的常量，最大值为 215-1。（32 767）
保存 short 可取的最小值的常量，最小值为 -215。（-32 768）
---------------------------------------------------
int i;//指定变量i为int型
值为 231－1 ( 2147483647 二十一亿）的常量，它表示 int 类型能够表示的最大值。
值为 －231 的常量，它表示 int 类型能够表示的最小值。
---------------------------------------------------
long l;//指定变量l为long型
3.
String是不可变的。也就是说只要用String定义了一个对象，当对他进行修改的时候，都是新建一个String，而不是在原有的基础上修改而成的。
StringBuffer可变。线程安全~所以效率比StringBuilder低一点。
StringBuilder可变字符串，可通过aappend等方法对字符串进行修改。线程不安全，是sun为了追求极致写的。效率比StringBuffer高。
3.1.int和Integer的区别
int 是基本数据类型，而Integer是一个对象，也是引用类型。 int定义的不易扩展，而Integer定义的，可以借助里面的方法来进行扩展。
Integer i = null;说白了，Integer就是一个引用，可以指向null。而int必须赋数字。
Java是一个近乎纯洁的面向对象编程语言，但是为了编程的方便还是引入了基本数据类型，但是为了能够将这些基本数据类型当成对象操作，Java为每 一个基本数据类型都引入了对应的包装类型（wrapper class），int的包装类就是Integer，从Java 5开始引入了自动装箱/拆箱机制，使得二者可以相互转换。
Java 为每个原始类型提供了包装类型：
- 原始类型: boolean，char，byte，short，int，long，float，double
- 包装类型：Boolean，Character，Byte，Short，Integer，Long，Float，Double
int基本数据运算速度快，而在map、list等只能装Object的容器中，就只能使用Integer等外覆类。
4.****************************
Set、List和Map可以看做集合的三大类。
Set存储的零散的元素且不允许有重复元素（数学中的集合也是如此），List是线性结构的容器，适用于按数值索引访问元素的情形。
List集合是有序集合，集合中的元素可以重复，访问集合中的元素可以根据元素的索引来访问。
Set集合是无序集合，集合中的元素不可以重复，访问集合中的元素只能根据元素本身来访问（也是不能集合里元素不允许重复的原因）。
Map集合中保存Key-value对形式的元素，访问时只能根据每项元素的key来访问其value。
ArrayList和Vector都是使用数组方式存储数据,Vector中的方法由于添加了synchronized修饰，因此Vector是线程安全的容器，但性能上较ArrayList差，因此已经是Java中的遗留容器。（Java早期的版本中提供的容器，除此之外，Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器）
对于Set、List和Map三种集合，最常用的实现类分别是HashSet、ArrayList和HashMap三个实现类。
1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。
2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。
3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。
LinkedList 采用的将对象存放在独立的空间中，而且在每个空间中还保存下一个链接的索引 但是缺点就是查找非常麻烦 要丛第一个索引开始.
是批量随机的插入删除数据，LinkedList的速度大大优于ArrayList.因为ArrayList每插入一条数据，要移动插入点及之后的所有数据。 这一点我做了实验。在分别有200000条“记录”的ArrayList和LinkedList的首位插入20000条数据，LinkedList耗时约是ArrayList的20分之1。
Vector:线程同步
HashSet：（无序）哈希表是通过使用称为散列法的机制来存储信息的，元素并没有以某种特定顺序来存放；
LinkedHashSet：（插入顺序）以元素插入的顺序来维护集合的链接表，允许以插入的顺序在集合中迭代；
TreeSet：（升序）提供一个使用树结构存储Set接口的实现，对象以升序顺序存储，访问和遍历的时间很快。
HashSet<String> hs = new HashSet<String>();
hs.add("B");
hs.add("A");
hs.add("D");
hs.add("E");
hs.add("C");
hs.add("F");
System.out.println("HashSet 顺序:\n"+hs);
LinkedHashSet<String> lhs = new LinkedHashSet<String>();
lhs.add("B");
lhs.add("A");
lhs.add("D");
lhs.add("E");
lhs.add("C");
lhs.add("F");
System.out.println("LinkedHashSet 顺序:\n"+lhs);
TreeSet<String> ts = new TreeSet<String>();
ts.add("B");
ts.add("A");
ts.add("D");
ts.add("E");
ts.add("C");
ts.add("F");
System.out.println("TreeSet 顺序:\n"+ts);
//输出结果
HashSet 顺序:
[D, E, F, A, B, C]
LinkedHashSet 顺序:
[B, A, D, E, C, F]
TreeSet 顺序:
[A, B, C, D, E, F]
********set和map区别***********
set里元素都是散养的且不重复，map键值对，允许多键对一值，但不能一键对多值，因为你根本知道选哪个才对。
set里放对象，map里放键值对。
首先加入元素的形式，set：
List<Employee> list = new ArrayList<Employee>(); // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)
list.add(new Employee(Bob YANG, 22, Shanghai, 10086, waiter));
map:
Map<String, String> map = new HashMap<String, String>();
map.put("obama", "present");
set中的元素可以是{[name=Bob YANG, age=22, address=Shanghai, phone=10086, job=waiter],[...],[...],[...]}
map中的元素则是这个样子的{obama=present, justin=singer, mao=chairman}
hashmap,linkdedhashmap,treemap区别
HashMap 随机排列，允许一个键为null,允许多条值为null，不支持线程的同步，最常用的Map,它根据键的HashCode值存储数据,根据键可以直接获取它的值
TreeMap 升序排列
LinkedHashMap 插入顺序排列，是HashMap的一个子类，
Hashtable 与HashMap类似,它继承自Dictionary类，不同的是:它不允许记录的键或者值为空;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了 Hashtable在写入时会比较慢。
**********HashTable与HashMap的区别************
第一：我们从他们的定义就可以看出他们的不同，HashTable基于Dictionary类，而HashMap是基于AbstractMap。Dictionary是什么？它是任何可将键映射到相应值的类的抽象父类，而AbstractMap是基于Map接口的骨干实现，它以最大限度地减少实现此接口所需的工作。
第二：HashMap可以允许存在一个为null的key和任意个为null的value，但是HashTable中的key和value都不允许为null。
5.*********栈，堆，方法区*********
================
方法区（非堆）：是各个线程共享的内存区域，它用于存储已被虚拟机加载的类信息、静态变量、即时编译器编译后的代码等数据。
java堆：是虚拟机中所管理的内存中区域最大的一块，是被所有线程共享的一块内存区域，在虚拟机启动时创建。此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。java堆是垃圾收集器管理的主要区域。
java虚拟机栈：线程私有的，它的生命周期与线程相同。每个方法被执行的时候都会同时创建一个栈帧，用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每个方法被调用直至执行完成的过程，就对应着一个栈帧在虚拟机中从入栈到出栈的过程。
====================
堆区:
1.存储的全部是对象，每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享，堆中不存放基本类型和对象引用，只存放对象本身
栈区:
1.每个线程包含一个栈区，栈中只保存基础数据类型的对象和自定义对象的引用(不是对象)，对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的，其他栈不能访问。
3.栈分为3个部分：基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
方法区:
1.又叫静态区，跟堆一样，被所有的线程共享。方法区包含所有的class和static变量。
2.方法区中包含的都是在整个程序中永远唯一的元素，如class，static变量。
======================
栈里存放的是值类型（int、float等）的值和引用类型（String、你自己创建的类对象等）在堆中的地址；堆中存放引用类u型的值，如果堆中某个值的地址在栈中没有被指向，他就会被GC回收。
方法区存储所有的类和静态变量。
小总结：方法区放类信息、静态变量；堆放对象；栈线程私有，放基本类型变量(如int)和对象地址(在堆里的地址)。
6.***************
inputstream的.read(byte[] b)
这个方法是先规定一个数组长度，将这个流中的字节缓冲到数组b中，返回的这个数组中的字节个数，这个缓冲区没有满的话，则返回真实的字节个数，到未尾时都返回-1
byte[] buffer = new byte[512];
int bytesReaded;
while((bytesReaded = in.read(buffer)) != -1) {
out.write(buffer, 0, bytesReaded);
}
总结，每次in.read(buffer)返回的都是512，唯独最后一次返回的是该多少是多少，比如37。
7.**********
简单工厂模式，又叫做静态工厂方法（Static Factory Method）模式。
就是专门写一个类，他有一个方法根据传入的参数不同，返回不同的对象。
所谓简单工厂模式, 就是将容易变化的地方, 考虑用一个独立Class来进行创造实体(Object)的过程.
目的: 合并创造实体的动作, 统一以变量处理之. 使得新增实体种类时, 可以不修改到已有程序.
public class Animal{}
public class Cat extends Animal{}
public class Dog extends Animal{}
public class Fish extends Animal{}
/** 工厂类 */
public class AnimalFactory {
public static getAnimal(String name){
Animal animal = null;
if("Cat".equals(name)){
animal = new Cat();
}else if("Dog".equals(name)){
animal = new Dog();
}else if("Fish".equals(name)){
animal = new Fish();
}
return animal;
}
}
public class Test{
public static void main(String[] args){
Animal a1 = AnimalFactory.getAnimal("Cat");
}
}
8.*******
Object serialization 允许你将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。
举个例子：
网络传输的时候，可以传字符串，亦可以传对象object，例如socket，传字符串的时候接收方很容易解析出来，但是，传一个对象的时候，对方读完字节流后，不知道你传的什么对象，所以没办法给转成原来的对象并解析对象的属性，这时候就要用到序列化和反序列化。
类实现序列化接口，socket发送这个对象的字节流，接收方到流后就可以将流反序列化成对象，然后使用对象的方法和属性。
9.********
java单例模式确保一个类只有一个实例，自行提供这个实例并向整个系统提供这个实例。
特点：
1，一个类只能有一个实例；
2，自己创建这个实例；
3，整个系统都要使用这个实例。
单例模式，能避免实例重复创建；
单例模式，应用于避免存在多个实例引起程序逻辑错误的场合；
单例模式，较节约内存。
饿汉式
class Singleton {
private static Singleton instance=new Singleton();
private Singleton(){}
static Singleton getInstance() {
return instance;
}
}
懒汉式
class Singleton {
private static Singleton instance=null;
private Singleton(){}
static Singleton getInstance() {
if(instance==null)
instance=new Singleton();
return instance;
}
}
10.*******
Mysql的left join技术
表book
+---------+-----------+-------+--------+
| book_id | book_name | price | author |
+---------+-----------+-------+--------+
| 1 | javaSE | 20 | ligang |
| 2 | javaEE | 30 | lihua |
+---------+-----------+-------+--------+
表employee
+----+---------+--------+--------+-------+---------------------+
| id | name | dept | salary | level | date |
+----+---------+--------+--------+-------+---------------------+
| 1 | tom | 开发部 | 2300 | 2 | 2016-01-01 00:02:39 |
| 2 | jack | 开发部 | 2500 | 2 | 2014-01-01 00:03:16 |
| 3 | dana | 董事会 | 15000 | 1 | 2000-02-01 00:04:06 |
| 4 | lorenzo | 董事会 | 30000 | 1 | 2000-01-01 00:05:19 |
| 5 | sonen | 销售部 | 3000 | 3 | 2015-01-04 00:06:02 |
| 6 | conor | 销售部 | 1800 | 3 | 2014-04-12 00:06:52 |
| 7 | bisping | 销售部 | 2600 | 3 | 2014-01-18 00:17:50 |
+----+---------+--------+--------+-------+---------------------+
select * from book left join employee on book.book_id=employee.id;
+---------+-----------+-------+--------+----+------+--------+--------+-------+---------------------+
| book_id | book_name | price | author | id | name | dept | salary | level | date |
+---------+-----------+-------+--------+----+------+--------+--------+-------+---------------------+
| 1 | javaSE | 20 | ligang | 1 | tom | 开发部 | 2300 | 2 | 2016-01-01 00:02:39 |
| 2 | javaEE | 30 | lihua | 2 | jack | 开发部 | 2500 | 2 | 2014-01-01 00:03:16 |
+---------+-----------+-------+--------+----+------+--------+--------+-------+---------------------+
select * from employee left join book on employee.id = book.book_id;
+----+---------+--------+--------+-------+---------------------+---------+-----------+-------+--------+
| id | name | dept | salary | level | date | book_id | book_name | price | author |
+----+---------+--------+--------+-------+---------------------+---------+-----------+-------+--------+
| 1 | tom | 开发部 | 2300 | 2 | 2016-01-01 00:02:39 | 1 | javaSE | 20 | ligang |
| 2 | jack | 开发部 | 2500 | 2 | 2014-01-01 00:03:16 | 2 | javaEE | 30 | lihua |
| 3 | dana | 董事会 | 15000 | 1 | 2000-02-01 00:04:06 | NULL | NULL | NULL | NULL |
| 4 | lorenzo | 董事会 | 30000 | 1 | 2000-01-01 00:05:19 | NULL | NULL | NULL | NULL |
| 5 | sonen | 销售部 | 3000 | 3 | 2015-01-04 00:06:02 | NULL | NULL | NULL | NULL |
| 6 | conor | 销售部 | 1800 | 3 | 2014-04-12 00:06:52 | NULL | NULL | NULL | NULL |
| 7 | bisping | 销售部 | 2600 | 3 | 2014-01-18 00:17:50 | NULL | NULL | NULL | NULL |
+----+---------+--------+--------+-------+---------------------+---------+-----------+-------+--------+
也就是说，left join就是两个表按某种条件焊接在一起，比如id相同，既然前头left join后头，那么前头自然在左边，后头在右边。
左边的没有内容了，右边的即使有内容也不显示；左边有多余，右边没有也得按null显示。
以左表为中心，返回左表中符合条件的所有记录以及右表中联结字段相等的记录——当右表中无相应联接记录时，返回空值
select * from book right join employee on book.book_id=employee.id;
+---------+-----------+-------+--------+----+---------+--------+--------+-------+---------------------+
| book_id | book_name | price | author | id | name | dept | salary | level | date |
+---------+-----------+-------+--------+----+---------+--------+--------+-------+---------------------+
| 1 | javaSE | 20 | ligang | 1 | tom | 开发部 | 2300 | 2 | 2016-01-01 00:02:39 |
| 2 | javaEE | 30 | lihua | 2 | jack | 开发部 | 2500 | 2 | 2014-01-01 00:03:16 |
| NULL | NULL | NULL | NULL | 3 | dana | 董事会 | 15000 | 1 | 2000-02-01 00:04:06 |
| NULL | NULL | NULL | NULL | 4 | lorenzo | 董事会 | 30000 | 1 | 2000-01-01 00:05:19 |
| NULL | NULL | NULL | NULL | 5 | sonen | 销售部 | 3000 | 3 | 2015-01-04 00:06:02 |
| NULL | NULL | NULL | NULL | 6 | conor | 销售部 | 1800 | 3 | 2014-04-12 00:06:52 |
| NULL | NULL | NULL | NULL | 7 | bisping | 销售部 | 2600 | 3 | 2014-01-18 00:17:50 |
+---------+-----------+-------+--------+----+---------+--------+--------+-------+---------------------+
select * from employee right join book on book.book_id=employee.id;
+----+------+--------+--------+-------+---------------------+---------+-----------+-------+--------+
| id | name | dept | salary | level | date | book_id | book_name | price | author |
+----+------+--------+--------+-------+---------------------+---------+-----------+-------+--------+
| 1 | tom | 开发部 | 2300 | 2 | 2016-01-01 00:02:39 | 1 | javaSE | 20 | ligang |
| 2 | jack | 开发部 | 2500 | 2 | 2014-01-01 00:03:16 | 2 | javaEE | 30 | lihua |
+----+------+--------+--------+-------+---------------------+---------+-----------+-------+--------+
左连接与右连接前头后头的位置很容易混淆，这里的左右不是绝对对称的，
这里我得出一个结论：A left join B, B left join A, A right join B, B right join A,到底A、B谁在前头谁在后头，不要试图用单词的意思来理解，那样一定会犯错，就按最最简单的方式，A与B写出时谁在前谁在后，无论中间是left join还是right join，先写的永远都在前头，后写的永远在后头。
下面来点提升练习题：
现在修改一下book表：
select * from book;
+----+------------------+-------+--------+
| id | name | price | author |
+----+------------------+-------+--------+
| 1 | javaSE | 20 | ligang |
| 2 | javaEE | 30 | lihua |
| 3 | thinking in java | 80 | bruce |
| 4 | effective java | 60 | frank |
| 5 | american history | 25 | kerry |
| 6 | house design | 30 | lee |
+----+------------------+-------+--------+
=======================================================================================================
select e.id, e.name, b.id, b.name from employee e left join book b on e.id = b.id where e.id<7;
+----+---------+----+------------------+
| id | name | id | name |
+----+---------+----+------------------+
| 1 | tom | 1 | javaSE |
| 2 | jack | 2 | javaEE |
| 3 | dana | 3 | thinking in java |
| 4 | lorenzo | 4 | effective java |
| 5 | sonen | 5 | american history |
| 6 | conor | 6 | house design |
+----+---------+----+------------------+
select e.id, e.name, b.id, b.name from employee e left join book b on e.id = b.id and b.price > 30 where e.id<7;
+----+---------+------+------------------+
| id | name | id | name |
+----+---------+------+------------------+
| 1 | tom | NULL | NULL |
| 2 | jack | NULL | NULL |
| 3 | dana | 3 | thinking in java |
| 4 | lorenzo | 4 | effective java |
| 5 | sonen | NULL | NULL |
| 6 | conor | NULL | NULL |
+----+---------+------+------------------+
select e.id, e.name, b.id, b.name from employee e left join book b on e.id = b.id and b.price > 30 where b.id<7;
+----+---------+----+------------------+
| id | name | id | name |
+----+---------+----+------------------+
| 3 | dana | 3 | thinking in java |
| 4 | lorenzo | 4 | effective java |
+----+---------+----+------------------+
=======================================================================================================
where采用的book的id，左边又是book，所以book执行到底，列出6个。
select b.id, b.name, e.id, e.name from book b left join employee e on e.id = b.id and b.price > 30 where b.id < 7;
+----+------------------+------+---------+
| id | name | id | name |
+----+------------------+------+---------+
| 1 | javaSE | NULL | NULL |
| 2 | javaEE | NULL | NULL |
| 3 | thinking in java | 3 | dana |
| 4 | effective java | 4 | lorenzo |
| 5 | american history | NULL | NULL |
| 6 | house design | NULL | NULL |
+----+------------------+------+---------+
where采用e.id，book在左边，此时只出现book.price大于30的项。为什么此时只有两项？因为employee的1、2、5、6行都是null。
select b.id, b.name, e.id, e.name from book b left join employee e on e.id = b.id and b.price > 30 where e
.id < 7;
+----+------------------+----+---------+
| id | name | id | name |
+----+------------------+----+---------+
| 3 | thinking in java | 3 | dana |
| 4 | effective java | 4 | lorenzo |
+----+------------------+----+---------+
一个小小的左连接，却妙趣无穷，用的时候再做测验吧。
11.int(1)与int(11)有什么区别？
int(M),这里的M代表的并不是存储在数据库中的具体的长度，以前总是会误以为int(3)只能存储3个长度的数字，int(11)就会存储11个长度的数字，这是大错特错的。
其实当我们在选择使用int的类型的时候，不论是int(3)还是int(11)，它在数据库里面存储的都是4个字节的长度，在使用int(3)的时候如果你输入的是10，会默认给你存储位010,也就是说这个3代表的是默认的一个长度，当你不足3位时，会帮你不全，当你超过3位时，就没有任何的影响。
要查看出不同效果记得在创建类型的时候加 zerofill这个值，表示用0填充，否则看不出效果的。
create table t (t int(3) zerofill);
insert into t set t = 10;
select * from t;
+——+
| t |
+——+
| 010 |
+——+
12.varchar(20) 与 varchar（256）的区别？
最大允许长度不一样。
存入的最大长度限制为20， 那就没有必要弄成varchar(256)。varchar(256)意为最大允许你存储256个字符。
如果你能确保最大长度为不超过20， 则varchar(20)为合重的设计。
你存储一个长度为20的字符串，varchar(20)和varchar(256)所占用的物理空间大小是一样的。
存入“helloword” 时,varchar255比varchar(20) 占用相同字节数。
13.JDK1.5版本到JDK1.7版本的特性
JDK1.5新特性:
1.自动装箱与拆箱
2.枚举
3.泛型(Generic)
4.For-Each循环
JDK 1.6新特性:
1.支持win7+ 的aero特效，即半透明
2. common annotation，插入式注解处理，在编译期间而不是运行期间处理注解
JDK 1.7新特性：
1.switch中可以使用字串了
2.<>钻石运算符，泛型自动推断
3.安全的加减乘除，Math.safe....
4..数字字面量下划线支持，age_of_jack=8;....
5.支持二进制文字。例如：int binary = 0b1001_1001;
6、在try catch异常扑捉中，一个catch可以写多个异常类型，用"|"隔开
7、jdk7之前，你必须用try{}finally{}在try内使用资源，在finally中关闭资源，不管try中的代码是否正常退出或者异常退出。jdk7之后，你可以不必要写finally语句来关闭资源，只要你在try()的括号内部定义要使用的资源。
jAVA8 十大新特性
1、接口的默认方法实现。方法实现，只需要使用 default关键字即可
2、Lambda 表达式。1、简化匿名类的编写。2、支持函数式编程。
3、Stream 接口，可以将多个操作依次串起来。
4.localtime,localzone,localdate,localdatetime 定义了一个没有时区信息的时间
14.枚举是一种类型，用于定义变量，以限制变量的赋值 赋值时通过"枚举名.值"来取得相关枚举中的值
public enum Season {
winter, spring, summer, fall;
}
表示Season（季节）的值只能是枚举里面定义的 winter, spring, summer, fall（春夏秋冬）;
看起来很象是特殊的class, 它也可以有自己的变量，可以定义自己的方法，可以实现一个或者多个接口。
所有枚举值都是public , static , final的。
15.取整 Math. floor round ceil
floor 向下取整。返回不大于的最大整数
round。加0.5再向下取整。算法为Math.floor(x+0.5)，即将原来的数字加上0.5后再向下取整，所以，Math.round(11.5)的结果为12，Math.round(-11.5)的结果为-11。
ceil 向上取整。则是不小于他的最小整数
看例子
Math.floor
Math.round
Math.ceil
1.4
1
1
2
1.5
1
2
2
1.6
1
2
2
-1.4
-2
-1
-1
-1.5
-2
-1
-1
-1.6
-2
-2
-1
16.封装，继承，多态
Person => Teacher，Student，一句话，三大特性都有了。
封装：
属于同一类事物的共性（包括属性与方法）归到一个类中
继承：
个性对共性的属性与方法的接受，并加入个性特有的属性与方法
多态：
多态的概念发展出来，是以封装和继承为基础的。
多态就是在抽象的层面上实施一个统一的行为，到个体（具体）的层面上时，这个统一的行为会因为个体（具体）的形态特征而实施自己的特征行为。
17.char能不能存储汉字？
java中的一个char的确是2个字节。java采用unicode，2个字节来表示一个字符。
一个数字或英文或汉字都是一个字符，只不过数字和英文时，存储的2个字节的第一个字节都为0，就是浪费了点空间。存汉字就占满了2个字节。
18. final finalize finally区别？
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。
finally 是异常处理语句结构的一部分，表示总是执行。
finalize 是Object类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源回收，例如关闭文件等
19.Collection 和Collections的区别？
1、java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│ └Stack
└Set
2、java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。
Collections.sort(list);
reverse(List list)：反转指定List集合中元素的顺序
shuffle(List list)：对List中的元素进行随机排序（洗牌）
sort(List list)：对List里的元素根据自然升序排序
sort(List list, Comparator c)：自定义比较器进行排序
swap(List list, int i, int j)：将指定List集合中i处元素和j出元素进行交换
rotate(List list, int distance)：将所有元素向右移位指定长度，如果distance等于size那么结果不变
binarySearch(List list, Object key)：使用二分搜索法，以获得指定对象在List中的索引，前提是集合已经排序
max(Collection coll)：返回最大元素
max(Collection coll, Comparator comp)：根据自定义比较器，返回最大元素
min(Collection coll)：返回最小元素
min(Collection coll, Comparator comp)：根据自定义比较器，返回最小元素
fill(List list, Object obj)：使用指定对象填充
frequency(Collection Object o)：返回指定集合中指定对象出现的次数
replaceAll(List list, Object old, Object new)：替换
20.冒泡排序
int[] arr={6,3,8,2,9,1};
第一趟排序：
第一次排序：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比较，2大于1，交换位置： 1 2 3 6 8 9
第二趟总共进行了1次比较， 排序结果： 1 2 3 6 8 9
---------------------------------------------------------------------
第一趟比较5次，过来一遍，一定能找到最大的那个，下一趟比较就不需要再比谁最大了，因为最大的已经有了。
第二趟比较4次一定可以找到二大的，下一趟就不用管最大、二大了。
第三趟比较3次一定找到三大
最后一个不用比较了，它一定是最小的，所以只需要arr.length-1趟。
每一趟的比较次数也不同，越来越少，因为最大、二大已经知道，无须再比。
可以这么想：第n趟比较总共会比较多少次呢？首先后头是n-1个不管（比如说第3趟开始时，最大、二大已经有了，后头3-1=2个不管）；前头第一个不管，因为比较最少需要2个，第一个是基础；然后拿第一个和剩余的一一映射，看看有多少根映射，就有多少次。那么也就是：
a[0]-->a[1]; a[0]-->a[2]; a[0]-->a[3]，共比较三次。a[4]a[5]分别是二大、最大。
for(int i=1;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
//交换位置
}
代码实现：
arr.lenth=6,我们这里就写6。
for(int i=0;i<6-1;i++){//外层循环控制排序趟数
for(int j=0;j<6-1-i;j++){//内层循环控制每一趟排序多少次
if(arr[j]>arr[j+1]){
//第一次比较，a[0]和a[1],大于就替换位置，小于就不变。
int temp=arr[j];
//第二次比较，a[1]和a[2],....
arr[j]=arr[j+1];
//一直比到a[5]
arr[j+1]=temp;
}
}
}
21.向上转型和向下转型
向上转型：将子类对象转为父类对象。父类指向子类引用对象会遗失除与父类对象共有的其他方法，也就是在转型过程中，子类的新有的方法都会遗失掉，在编译时，系统会提供找不到方法的错误。
Animal a 引用指向 new Bird();子类对象当成父类对象，只能调用父类的成员，如果子类重写了父类的方法就根据这个引用指向调用子类重写的这个方法（这个方法就是覆盖override）。这个调用过程就称为“动态绑定”。
向下转型：父类转子类。 情况一：如果父类引用的对象如果引用的是指向的子类对象，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。
情况二：如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误。
class Animal {
public void eat() {
System.out.println("animal eatting...");
}
}
class Bird extends Animal {
public void eat()
System.out.println("bird eatting...");
}
public void fly() {
System.out.println("bird flying...");
}
}
向下转型：
main(String[] args) {
Animal ab = new Bird(); // 向上转型，这种情况太常见了，List<T> list=new ArrayList<T>;
// 原来这种写法只能用ArrayList重写List的方法，不能用ArrayList特有的方法
ab.eat();
ab.fly();//这句报错！此处提示在Animal中没有定义fly方法。
}
向下转型：2种情况
main(String[] args) {
Animal ab = new Bird(); // 向下，指向子类对象，不报错
Bird b = (Bird) ab;
b.eat();
b.fly();
}
main(String[] args) {
Animal ab = new Animal(); // 向下，指向父类对象，报错
Bird b = (Bird) ab;
b.eat();
b.fly();
}
22. Servlet简介
> Server + let
> 意为：运行在服务器端的小程序。
> Servlet实际上就是一个接口。
- 狭义上的Servlet，指的就是Servlet接口
- 广义上的我们认为凡是实现Servlet接口的类，我们都称他是一个Servlet *****
> Servlet的作用：
1.接收用户发送的请求
2.调用其他的java程序来处理请求
3.根据处理结果，返回给用户一个页面
23.缓存是什么？
作用就像仓库中临时堆放货物的地方一样，货物从运输车辆上放下时临时堆放在缓存区中，然后再搬到内部存储区中长时间存放。货物在这段区域中存放的时间很短，就是一个临时货场。 最初缓存只有一级，后来处理器速率又提升了，一级缓存不够用了，于是就添加了二级缓存。二级缓存是比一级缓存速率更慢，容量更大的内存，主要就是做一级缓存和内存之间数据临时交换的地方用。
为了适应速率更快的处理器，已经出现了三级缓存了，它的容量更大，速率相对二级缓存也要慢一些，但是比内存可快多了。
24.什么是Web缓存？
Web缓存是指一个Web资源（如html页面，图片，js，数据等）存在于Web服务器和客户端（浏览器）之间的副本。
缓存会根据进来的请求保存输出内容的副本；当下一个请求来到的时候，如果是相同的URL，缓存会根据缓存机制决定是直接使用副本响应访问请求，还是向源服务器再次发送请求。
Web缓存的作用
1.减少网络带宽消耗:无论对于网站运营者或者用户，带宽都代表着金钱，过多的带宽消耗，只会便宜了网络运营商。当Web缓存副本被使用时，只会产生极小的网络流量，可以有效的降低运营成本。
2.降低服务器压力:给网络资源设定有效期之后，用户可以重复使用本地的缓存，减少对源服务器的请求，间接降低服务器的压力。同时，搜索引擎的爬虫机器人也能根据过期机制降低爬取的频率，也能有效降低服务器的压力。
3.减少网络延迟，加快页面打开速度:带宽对于个人网站运营者来说是十分重要，而对于大型的互联网公司来说，可能有时因为钱多而真的不在乎。那Web缓存还有作用吗？答案是肯定的，对于最终用户，缓存的使用能够明显加快页面打开速度，达到更好的体验。
25.Java中用最有效率的方法算出2 乘以8 等於几?
2 << 3，
因为将一个数左移n 位，就相当于乘以了2 的n 次方，即：2X2n次方那么，一个数乘以8 只要将其左移3 位
即可，而位运算cpu 直接支持的，效率最高，所以，2 乘以8 等於几的最效率的方法是2 << 3。
//计算2*8=2*23
System.out.println(2<<3);//8=2的3次方为8
//计算2*16=2*24
System.out.println(2<<4);//16=2的4次方为16