Java名词总结
Java基本数据类型
(1) 整型（byte，short，int，long）
(2) 浮点型（float，double）
(3) 字符型（char）
(4) 布尔型（boolean）
一定要按照次顺序 byte，short，int，long，float，double，char，boolean
基本数据类型表
数组的特点
1）数组是同一个数据类型（一个数组中只能保存一种类型的数据，可以保存基本类型，也可以保存Object。一个int,一个String是不能同时保存在一个数组内的(如果是对象型数组，注意存放的每一个对象都必须被实例化)
2）数组的长度是固定的。
3）数组是可以保存一组数据的一种数据结构，它本身也会占用一个内存地址，因此数组是引用类型。
4）数组一旦定义好就不可以修改长度，如果要修改就必须重新定义一个新数组或者引用其他的数组，因此数组的灵活性较差。
5）数组拥有边界检查，尝试获取不在数组范围内的值时，会抛出ArrayIndexOutOfBoundsException异常
抽象类是什么：
抽象类不能创建实例，它只能作为父类被继承。抽象类是从多个具体类中抽象出来的父类，它具有更高层次的抽象。从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为其子类的模板，从而避免了子类的随意性。
(1) 抽象方法只作声明，而不包含实现，可以看成是没有实现体的虚方法
(2) 抽象类不能被实例化
(3) 抽象类可以但不是必须有抽象属性和抽象方法，但是一旦有了抽象方法，就一定要把这个类声明为抽象类
(4) 具体派生类必须覆盖基类的抽象方法
(5) 抽象派生类可以覆盖基类的抽象方法，也可以不覆盖。如果不覆盖，则其具体派生类必须覆盖它们
接口是什么：
(1) 接口不能被实例化
(2) 接口只能包含方法声明
(3) 接口的成员包括方法、属性、索引器、事件
(4) 接口中不能包含常量、字段(域)、构造函数、析构函数、静态成员
抽象类与接口的区别
（1）抽象类可以有构造方法，接口中不能有构造方法。
（2）抽象类中可以有普通成员变量，接口中没有普通成员变量
（3）抽象类中可以包含静态方法，接口中不能包含静态方法
（4） 一个类可以实现多个接口，但只能继承一个抽象类。
（5）接口可以被多重实现，抽象类只能被单一继承
（6）如果抽象类实现接口，则可以把接口中方法映射到抽象类中作为抽象方法而不必实现，而在抽象类的子类中实现接口中方法。
接口和抽象类的相同点：
(1) 都可以被继承
(2) 都不能被实例化
(3) 都可以包含方法声明
(4) 派生类必须实现未实现的方法
接口代表一个功能，代表一种本领，抽象类定义你是谁，接口定义你做什么（抽象类定义隶属关系，接口定义行为，单继承，多实现）
实例变量与类变量的区别
类变量也叫静态变量，也就是在变量前加了static 的变量； 实例变量也叫对象变量，即没加static 的变量； 区别在于： 类变量和实例变量的区别在于：类变量是所有对象共有，其中一个对象将它值改变，其他对象得到的就是改变后的结果；而实例变量则属对象私有，某一个对象将其值改变，不影响其他对象；
实例变量：
1）实例变量声明在一个类中，但在方法、构造方法和语句块之外；
2）当一个对象被实例化之后，每个实例变量的值就跟着确定；
3）实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
4）实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
5）实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
6）实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
7）实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
类变量：
1）类变量也称为静态变量，在类中以static关键字声明，但必须在方法构造方法和语句块之外。
2）无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
3）静态变量除了被声明为常量外很少使用。常量是指声明为public/private，final和static类型的变量。常量初始化后不可改变。
4）静态变量储存在静态存储区。经常被声明为常量，很少单独使用static声明变量。
5）静态变量在程序开始时创建，在程序结束时销毁。
6）与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为public类型。
7）默认值和实例变量相似。数值型变量默认值是0，布尔型默认值是false，引用类型默认值是null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
8）静态变量可以通过：ClassName.VariableName的方式访问。
9）类变量被声明为public static final类型时，类变量名称必须使用大写字母。如果静态变量不是public和final类型，其命名方式与实例变量以及局部变量的命名方式一致。
<u>https://www.cnblogs.com/scf141592/p/5726347.html</u>
实例方法和类方法对实例变量和类变量的访问
实例方法可以对当前对象的实例变量进行操作，也可以对类变量进行操作。实例方法由实例对象调用。
类方法不能访问实例变量，只能访问类变量。类方法由类名或者实例对象调用。类方法中不能出现this或者super关键字
class TiXing{
private float up,height;
private static float down;
TiXing(float x,float y,float z){
up=x;
height=y;
down=z;
}
public void display(){
System.out.println("up is:"+up+"height is:"+height+"down is:"+down);
}
public static void change(float number){
down=number;
//System.out.println("height:"+height);//出错 }
}
public class ep3_9{
public static void main(String args[]){
TiXing one=new TiXing(1,2,3);
one.display();
TiXing two=new TiXing(4,5,6);
one.display();
two.display();
//TiXing.display();//出错
one.change(101);
one.display();
two.change(102);
two.display();
}
}
final的功能：
1）类不能被继承。
2）成员变量加final就是一个常量，而且必须赋初值。
3）局部变量加final，变量的值在方法体中不能被修改
4）final修饰方法体，方法体不能被重写
finally 的功能：
1）finally存在于异常里：不管是否发生异常，finally里面内容都要执行
this表示本类的一个对象
作用如下：
1）this调用本类中的属性，也就是类中的成员变量；
2）this调用本类中的其他方法；
3）this调用本类中的其他构造方法，调用时要放在构造方法的首行。
限定修饰符的的作用和作用范围
作用：四种级别不同的访问权限，可以用来修饰类，方法和字段。
作用范围：
************************************************************************************************
一个类中 \一个包不同类或者子类中\ 不同包的子类中\ 不同包的非子类中
private 是
默认 是 是
protected 是 是 是（super）
public 是 是 是 是
*************************************************************************************************
异常的处理方式
1）try......catch
2）try......catch......finally
3）嵌套的try......catch语句，如果异常平级，catch后面不分顺序随意写，否则先写小的异常再写大的异常
throws与throw的区别
当然，你需要明白异常在Java中式以一个对象来看待。 并且所有系统定义的编译和运行异常都可以由系统自动抛出，称为标准异常，但是一般情况下Java 强烈地要求应用程序进行完整的异常处理，给用户友好的提示，或者修正后使程序继续执行。 直接进入正题哈： 1.用户程序自定义的异常和应用程序特定的异常,必须借助于 throws 和 throw 语句来定义抛出异常。 1.1 throw是语句抛出一个异常。 语法：throw (异常对象); throw e; 1.2 throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常) 语法：(修饰符)(方法名)([参数列表])[throws(异常类)]{......} public void doA(int a) throws Exception1,Exception3{......}
1.3 throws E1,E2,E3只是告诉程序这个方法可能会抛出这些异常，方法的调用者可能要处理这些异常，而这些异常E1，E2，E3可能是该函数体产生的。 throw则是明确了这个地方要抛出这个异常。 如： void doA(int a) throws IOException,{ try{ ...... }catch(Exception1 e){ throw e; }catch(Exception2 e){ System.out.println("出错了！"); } if(a!=b) throw new Exception3("自定义异常"); }
重载与重写的区别
重载：
1.方法名必须相同
2.参数列表必须不同（参数个数，参数类型，参数顺序）
3.其他修饰符可以相同，也可以不同
4.可以抛出不同异常
重写：
1.方法名、参数列表、返回值类型都必须相同
2.访问修饰符必须大于等于被重写的方法
3.重写的方法中，不能抛出新的异常
4.重写方法只会存在于具有继承关系的子类中，而当父类中的方法用private修饰时即使子类中有重名方法，也不叫方法的重写
5.非静态方法不能被重写成静态方法
扩展：方法重载是指同一个类中的多个方法具有相同的名字,但这些方法具有不同的参数列表,即参数的数量或参数类型不能完全相同
方法重写是存在子父类之间的,子类定义的方法与父类中的方法具有相同的方法名字,相同的参数表和相同的返回类型 注: (1)子类中不能重写父类中的final方法 (2)子类中必须重写父类中的abstract方法
首先我们来讲讲：
重载(Overloading)
（1) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。
（2）[Java](http://java.chinaitlab.com/)的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。
（3）重载的时候，方法名要一样，但是参数类型和个数不一样，返回值类型可以相同也可以不相同。无法以返回型别作为重载函数的区分标准。
重写（Overriding）
（1） 父类与子类之间的多态性，对父类的函数进行重新定义。
如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。
在[Java](http://java.chinaitlab.com/)中，
子类可继承父类中的方法，而不需要重新编写相同的方法。
但有时子类并不想原封不动地继承父类的方法，而是想作一定的修改，这就需要采用方法的重写。
方法重写又称方法覆盖。
（2）若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表，则新方法将覆盖原有的方法。
如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
（3）子类函数的访问修饰权限不能少于父类的；
下面是重写的例子：
概念：即调用对象方法的机制。
重写与重载的区别在于：
重写多态性起作用，对调用被重载过的方法可以大大减少代码的输入量，同一个方法名只要往里面传递不同的参数就可以拥有不同的功能或返回值。
用好重写和重载可以设计一个结构清晰而简洁的类，可以说重写和重载在编写代码过程中的作用非同一般.
面试题：重载（Overload）和重写（Override）的区别。重载的方法能否根据返回类型进行区分？ 答：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。
数组和链表的区别？
链表通过指针来连接元素与元素，数组则是把所有元素按次序依次存储。
链表的插入删除元素相对数组较为简单，不需要移动元素，且较为容易实现长度扩充，但是寻找某个元素较为困难；
数组寻找某个元素较为简单，数组查找就像翻书一样（有页码），但插入与删除比较复杂，由于最大长度需要再编程一开始时指定，故当达到最大长度时，扩充长度不如链表方便。 相同：两种结构均可实现数据的顺序存储，构造出来的模型呈线性结构。
集合
1）集合类存放于java.util包中。
2）集合类存放的都是对象的引用，而非对象本身，出于表达上的便利，我们称集合中的对象就是指集合中对象的引用（reference)。
3）集合类型主要有3种：set(集）、list(列表）和map(映射)
集合分支
Collection接口 ：Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。 所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。 如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
Iterator it = collection.iterator(); // 获得一个迭代子while(it.hasNext()) {
Object obj = it.next(); // 得到下一个元素
}
iterator接口:
iterator接口
由Collection接口派生的两个接口是List和Set。
Set
1）Set接口同样是Collection接口的一个子接口，它表示数学意义上的集合概念。Set中不包含重复的元素，即Set中不存两个这样的元素e1和e2，使得e1.equals(e2)为true。由于Set接口提供的数据结构是数学意义上集合概念的抽象，因此它需要支持对象的添加、删除，而不需提供随机访问。故Set接口与Collection的接口相同。
2）Set接口继承Collection接口，而且它不允许集合中存在重复项。所有原始方法都是现成的，没有引入新方法。具体的Set实现类依赖添加的对象的equals()方法来检查等同性。
3）HashSet： 使用HashMap的一个集的实现。虽然集定义成无序，但必须存在某种方法能相当高效地找到一个对象。使用一个HashMap对象实现集的存储和检索操作是在固定时间内实现的.
List
List接口继承了Collection 接口以定义一个允许重复项的有序集合。该接口不但能够对列表的一部分进行处理，还添加了面向位置的操作。
实际上有两种List: 一种是基本的ArrayList,其优点在于随机访问元素，另一种是更强大的LinkedList,它并不是为快速随机访问设计的，而是具有一套更通用的方法。
List : 次序是List最重要的特点：它保证维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(这只推荐LinkedList使用。)一个List可以生成ListIterator,使用它可以从两个方向遍历List,也可以从List中间插入和移除元素。 ArrayList : 由数组实现的List。允许对元素进行快速随机访问，但是向List中间插入与移除元素的速度很慢。ListIterator只应该用来由后向前遍历ArrayList,而不是用来插入和移除元素。因为那比LinkedList开销要大很多。
LinkedList : 对顺序访问进行了优化，向List中间插入与删除的开销并不大，随机访问则相对较慢。(使用ArrayList代替。)还具有下列方法：addFirst(), addLast(), getFirst(), getLast(), removeFirst() 和 removeLast(), 这些方法 (没有在任何接口或基类中定义过)使得LinkedList可以当作堆栈、队列和双向队列使用。
List和Set对比
Linked 改快读慢
Array 读快改慢（类似于翻书有页码）
Hash 两之间
Collection是集合接口 |————Set子接口:无序，不允许重复。 |————List子接口:有序，可以有重复元素。
区别：Collections是集合类
Set和List对比： Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变。
Set和List具体子类： Set |————HashSet：以哈希表的形式存放元素，插入删除速度很快。
List |————ArrayList：动态数组 |————LinkedList：链表、队列、堆栈。
Map
Map接口不是Collection接口的继承。而是从自己的用于维护键-值关联的接口层次结构入手。按定义，该接口描述了从不重复的键到值的映射。
解疑：
1、什么是Iterator
一些集合类提供了内容遍历的功能，通过java.util.Iterator接口。这些接口允许遍历对象的集合。依次操作每个元素对象。当使用 Iterators时，在获得Iterator的时候包含一个集合快照。通常在遍历一个Iterator的时候不建议修改集合本省。
2、Iterator与ListIterator有什么区别？
Iterator：只能正向遍历集合，适用于获取移除元素。ListIerator：继承Iterator，可以双向列表的遍历，同样支持元素的修改。
3、什么是HaspMap和Map？
Map是接口，Java 集合框架中一部分，用于存储键值对，HashMap是用哈希算法实现Map的类。
<u>https://www.cnblogs.com/jing99/p/6947549.html</u>
Map和list接口的异同点
1）List 用于遍历一个数组时效率最高；比如在循环显示所有信息时经常用到； 2）Set中的元素是不能重复的，如果使用add(Object obj)方法添加已经存在的对象，则会覆盖前面的对象；虽然Set同List都实现了Collection接口，但是他们的实现方式却大不一样。List基本上都是以Array为基础。但是Set则是在HashMap的基础上来实现的，这个就是Set和List的根本区别。 Map 就是键值对map（键，值），键是Sting 类型 值是Object （对象类型），所以在知道某条信息的一项时查询其他项就用该方法，效率最高
3）list和map是两种不同的数据结构，list是列表，map是键值对。
[图片上传失败...(image-afa6ee-1569372379289)]
list,map,set的区别
list,map,set的区别 (首先假定小猪都是同一个细胞克隆出来的) List = 排成一长队的小猪 Map = 放在一个个，有房间号的屋子里面的一群小猪 Set = 一群小猪贴上号，然后赶到一个猪圈里
Hashset 它不保证集合的迭代顺序；特别是它不保证该顺序恒久不变。 LinkedHashSet定义了迭代顺序，即按照将元素插入到集合中的顺序（插入顺序）进行迭代。
TIMESTAMP和DATETIME的区别
- 存储空间不同
a) TIMESTAMP占用4个字节
b) DATETIME占用8个字节 - 受时区影响
c) TIMESTAMP实际记录的是1970-01-01 00:00:01到现在的数数，受时区影响
d) DATETIME不受时区影响 - 时间范围不同
e) TIMESTAMP的时间范围是：‘1970-01-01 00:00:01’ UTC ~ ‘2038-01-19 03:14:07’ UTC
f) DATETIME的时间范围是：‘1000-01-01 00:00:00’ ~ ‘9999-12-31 23:59:59’
datetime ：'1000-01-01 00:00:00.000000' to '9999-12-31 23:59:59.999999'
timestamp：'1970-01-01 00:00:01.000000' to '2038-01-19 03:14:07.999999'
timestamp翻译为汉语即"时间戳"，它是当前时间到 Unix元年(1970年1月1日0时0分0秒)的秒数。
对于某些时间的计算，如果是以datetime的形式会比较困难，假如我是 1994-1-20 06:06:06 出生，现在的时间是 2016-10-1 20:04:50 ，那么要计算我活了多少秒钟用 datetime 还需要函数进行转换，但是 timestamp 直接相减就行。
- 自动更新
g) TIMESTAMP类型在默认情况下，insert、update 数据时，TIMESTAMP列会自动以当前时间（CURRENT_TIMESTAMP）填充/更新。
5、选择
如果在时间上要超过Linux时间的，或者服务器时区不一样的就建议选择 datetime。
如果是想要使用自动插入时间或者自动更新时间功能的，可以使用timestamp。
为什么要用Nginx反向代理
反向代理是指以代理服务器来接受internet上的连接请求，然后将请求转发给内部网络上的服务器，并将从服务器上得到的结果返回给internet上请求连接的客户端，此时代理服务器对外就表现为一个服务器。
在计算机网络中，反向代理是代理服务器的一种。服务器根据客户端的请求，从其关联的一组或多组后端服务器（如Web服务器）上获取资源，然后再将这些资源返回给客户端，客户端只会得知反向代理的IP地址，而不知道在代理服务器后面的服务器簇的存在[1]。
与前向代理不同，前向代理作为客户端的代理，将从互联网上获取的资源返回给一个或多个的客户端，服务端（如Web服务器）只知道代理的IP地址而不知道客户端的IP地址；而反向代理是作为服务器端（如Web服务器）的代理使用，而不是客户端。客户端借由前向代理可以间接访问很多不同互联网服务器（簇）的资源，而反向代理是供很多客户端都通过它间接访问不同后端服务器上的资源，而不需要知道这些后端服务器的存在，而以为所有资源都来自于这个反向代理服务器。
一般来说公网延迟高，客户端与nginx之间的请求连接走公网，nginx先把这些请求缓存住，等这些请求数据全部完成之后nginx再向内网服务器请求，降低公网网络延迟成本，同时也降低一个连接占用服务端程序的时间。
原因：因为tcp不一定一次就能把全部数据传输完毕，所以一个连接可能需要等待很久才能把所有需要的数据都传输完毕，而这样的空闲连接如果都直接连
接到服务器上的话，会加重服务器负担，而nginx在这方面做了很大的优化，可以承载更多的连接，空闲连接也不会占据太多内存，所以nginx作为反向代理能降低上游服务器的负载。
反向代理是指的，服务器代理网络上的客户机请求，将请求转达给内部真实服务器，然后在返回给Internet客户端，代理服务器上面没有任何网页资料。
反向代理和正向代理没有冲突，可以在防火墙设备中同时使用这两种结合，正向代理可以进行过滤，保护内部网络安全。
什么是Nginx？
根据前面的对比，我们可以了解到Nginx是一个[http服务器]是一个使用c语言开发的高性能的http服务器及反向代理服务器。Nginx是一款高性能的http 服务器/反向代理服务器及电子邮件（IMAP/POP3）代理服务器。由俄罗斯的程序设计师Igor Sysoev所开发，官方测试nginx能够支支撑5万并发链接，并且cpu、内存等资源消耗却非常低，运行非常稳定。
3.1 Nginx的应用场景
1、 http服务器。Nginx是一个http服务可以独立提供http服务。可以做网页静态服务器。
2、** 虚拟主机。可以实现在一台服务器虚拟出多个网站。例如个人网站使用的虚拟主机。**
- 基于端口的，不同的端口
- 基于域名的，不同域名
3、 反向代理，负载均衡。当网站的访问量达到一定程度后，单台服务器不能满足用户的请求时，需要用多台服务器集群可以使用nginx做反向代理。并且多台服务器可以平均分担负载，不会因为某台服务器负载高宕机而某台服务器闲置的情况。
