牛客练习题 - 技术栈

建立Statement对象的作用是执行SQL语句
正则表达式：
JAVA8的switch支持10种类型。byte char short int Byte,Short,Character,Integer String enum
实际只支持int类型 Java实际只能支持int类型的switch语句，那其他的类型时如何支持的 a、基本类型byte char short 原因：这些基本数字类型可自动向上转为int, 实际还是用的int。 b、基本类型包装类Byte,Short,Character,Integer 原因：java的自动拆箱机制可看这些对象自动转为基本类型 c、String 类型原因：实际switch比较的string.hashCode值，它是一个int类型如何实现的，网上例子很多。此处不表。 d、enum类型原因：实际比较的是enum的ordinal值（表示枚举值的顺序），它也是一个int类型所以也可以说 switch语句只支持int类型
局部内部类、成员内部类、匿名内部类、final。
Dbuble是基本类的封装类，不可直接赋值
run()方法是线程的具体逻辑方法，执行完，线程就结束。
int [] Int = new int[2];//默认0 String[] strings = new String[2];//默认null
类的加载包括：加载，验证，准备，解析，初始化。
抽象类可以包含普通方法
抽象类到底能不能被实例化是初学者很容易犯的错误，抽象类确实有构造方法，但这个构造方法是用来被子类调用的，因为任何子类都必须调用从Object开始的所有父亲的构造方法，才算完成初始化工作。如果抽象类被实例化，就会报错，编译无法通过。而接口里不包含构造器，自然无法被实例化。
类中声明的变量有默认初始值；方法中声明的变量没有默认初始值，必须在定义时初始化，否则在访问该变量时会出错。
接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的。
在abstract class 中可以有自己的数据成员，也可以有非abstarct的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（也就是必须是 static final的，不过在 interface中一般不定义数据成员），所有的成员方法默认都是 public abstract 类型的。
abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。
is-a，理解为是一个，代表继承关系。如果A is-a B，那么B就是A的父类。 like-a，理解为像一个，代表组合关系。如果A like a B，那么B就是A的接口。 has-a，理解为有一个，代表从属关系。如果A has a B，那么B就是A的组成部分。
java的String底层是char数组，它的length()返回数组大小，而unicode中一个汉字是可以用一个char表示的
方法重载的返回值的类型可以不同，因为判断方法重载的方法主要是根据方法的参数不同来判定；方法重写的返回值类型需要相同，重写就是子类继承了父类的方法，并在此方法上重写属于自己的特征，既然是继承过来的，那么它的返回值类型就必须要相同
json对象要求属性必须加双引号。
json对象必须由一组有序的键值对组成。
JSON语法可以表示以下三种类型的值: 1.简单值：使用与JavaScript 相同的语法，可以在JSON中表示字符串，数值，布尔值和null。 2.对象：对象作为一种复杂数据类型，表示的是一组有序的键值对。而每组键值对中的值可以是简单值，也可以是复杂数据类型的值。 3.数组：数组也是一种复杂数据类型，表示一组有序的值的列表，可以通过数值索引来访问其中的值。数组的值也可以是任意类型--简单值，对象或数组。
一旦在finally块中使用了return或throw语句，将会导致try块，catch块中的return，throw语句失效
Iterator 支持从源集合中安全地删除对象，只需在 Iterator 上调用 remove() 即可。这样做的好处是可以避免 ConcurrentModifiedException ，当打开 Iterator 迭代集合时，同时又在对集合进行修改。有些集合不允许在迭代时删除或添加元素，但是调用 Iterator 的remove() 方法是个安全的做法。
执行forward时，浏览器不知道服务器发送的内容是从何处来，浏览器地址栏中还是原来的地址
执行redirect时，服务器端告诉浏览器重新去请求地址
forward是内部重定向，redirect是外部重定向
两个数值进行二元操作时，会有如下的转换操作：如果两个操作数其中有一个是double类型，另一个操作就会转换为double类型。否则，如果其中一个操作数是float类型，另一个将会转换为float类型。否则，如果其中一个操作数是long类型，另一个会转换为long类型。否则，两个操作数都转换为int类型。
虚拟机是运行在操作系统之上的，不与硬件交互
多个else if块之间的顺序可以改变，改变之后可能对程序的执行结果有影响
System是java.lang中的一个类，out是System内的一个成员变量，这个变量是一个java.io.PrintStream类的对象，println呢就是一个方法了。
基本型和基本型封装型进行"=="运算符的比较，基本型封装型将会自动拆箱变为基本型后再进行比较
两个基本封装型进行equals()比较，首先equals()会比较类型，如果类型相同，则继续比较值，如果值也相同，返回true
基本型封装类型调用equals (), 但是参数是基本类型，这时候，先会进行自动装箱，基本型转换为其封装类型，再进行比较
System.out.println(a==b);//true int a=257; Integer b=257;
where 条件查询
（3）数据控制（DCL）包括对基本表和视图的授权，完整性规则的描述，事务控制等内容。
（4）嵌入式SQL的使用规定（TCL）涉及到SQL语句嵌入在宿主语言程序中使用的规则。
alter table 表名 add constraint FK_ID foreign key(你的外键字段名) REFERENCES 外表表名(对应的表的主键字段名);
局部内部类是放在代码块或方法中的，不能有访问控制修饰符，且不能用static修饰
final修饰的方法只是不能重写，static修饰的方法只能访问类的成员变量
通过super可以调用父类构造函数
protected成员在子类可见性可以修改
父类一般具有通用性，子类更具体

子类能够集成父类中的方法。

继承具有传递性
局部变量的作用范围仅仅在定义它的方法内，或者是在定义它的控制流块中
首写字母可以为下划线
Servlet过滤器的配置包括两部分：第一部分是过滤器在Web应用中的定义，由<filter>元素表示，包括<filter-name>和<filter-class>两个必需的子元素第二部分是过滤器映射的定义，由<filter-mapping>元素表示,可以将一个过滤器映射到一个或者多个Servlet或JSP文件，也可以采用url-pattern将过滤器映射到任意特征的URL。
同步是害怕在操作过程的时候被其他线程也进行读取操作，一旦是原子性的操作就不会发生这种情况。
因为一步到位的操作，其他线程不可能在中间干涉。另外三项都有读取、操作两个步骤，而X=1则是原子性操作。
抽象类是可以实现接口的，而且抽象类也可以继承自抽象类
抽象类必须有"abstract class"修饰
String s = new String("xyz");创建了几个StringObject？两个或一个都有可能
参数传递分为两种 a.基本类型 b.引用类型
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
String 作为参数传递，效果和基本类型作为参数传递一样的
基本类型是值传递，引用类型是引用传递
值传递不改变原来的值，引用传递会改变原来的值。
x.append(y)是对x所指向的堆进行操作，修改后x与a依然指向这个堆，所以可以修改成功
y=x，等于修改了y的指向，b的指向还是以前的地方
jar 将许多文件组合成一个jar文件
javadoc 它从程序源代码中抽取类、方法、成员等注释形成一个和源代码配套的API帮助文档。
javah 把java代码声明的JNI方法转化成C\C++头文件
CyclicBarrier和CountDownLatch都可以让一组线程等待其他线程
Callable类的call()方法可以返回值和抛出异常
局部变量在使用前必须被初始化，成员变量会默认赋初始值。
实例变量是类的成员变量
隐藏细节应该是封装干的事情
原子（atom）本意是"不能被进一步分割的最小粒子"，而原子操作（atomic operation）意为"不可被中断的一个或一系列操作" 。原子操作就是不可再分的操作。在多线程程序中原子操作是一个非常重要的概念，它常常用来实现一些同步机制。由不可分性可知，原子性是拒绝多线程操作的（只有分解为多步操作，多个线程才能对其操作：就像一个盒子里有多个兵乓球，多个人能够从盒子里拿乒乓球；如果盒子只有一个兵乓球，一个人拿的话，其他人就拿不到了；这就是原子性，乒乓球就具有原子性，人就相当于原子）
构造方法不能被重写。
子类构造函数调用父类构造函数用super
子类重写父类方法后，若想调用父类中被重写的方法，用super
未被重写的方法可以直接调用。

复制代码

只有向上转型之后，才能向下转型

客户端通过new Socket()方法创建通信的Socket对象服务器端通过new ServerSocket()创建TCP连接对象 accept接纳客户端请求
Object 是引用数据类型，只申明而不创建实例，只会在栈内存中开辟空间，默认为空，空占1 bit.
volatile能保证数据的可见性，但不能完全保证数据的原子性，synchronized即保证了数据的可见性也保证了原子性。
按照流是否直接与特定的地方（如磁盘、内存、设备等）相连，分为节点流和处理流两类。
节点流：可以从或向一个特定的地方（节点）读写数据。如FileReader.
处理流：是对一个已存在的流的连接和封装，通过所封装的流的功能调用实现数据读写。如BufferedReader.处理流的构造方法总是要带一个其他的流对象做参数。一个流对象经过其他流的多次包装，称为流的链接。
JAVA常用的节点流：
文件 FileInputStream FileOutputStrean FileReader FileWriter 文件进行处理的节点流。字符串 StringReader StringWriter 对字符串进行处理的节点流。数组 ByteArrayInputStream ByteArrayOutputStreamCharArrayReader CharArrayWriter 对数组进行处理的节点流（对应的不再是文件，而是内存中的一个数组）。管道 PipedInputStream PipedOutputStream PipedReaderPipedWriter对管道进行处理的节点流。
常用处理流（关闭处理流使用关闭里面的节点流）
缓冲流：BufferedInputStrean BufferedOutputStream BufferedReader BufferedWriter 增加缓冲功能，避免频繁读写硬盘。
转换流：InputStreamReader OutputStreamReader 实现字节流和字符流之间的转换。
数据流 DataInputStream DataOutputStream 等-提供将基础数据类型写入到文件中，或者读取出来.
流的关闭顺序
一般情况下是：先打开的后关闭，后打开的先关闭
另一种情况：看依赖关系，如果流a依赖流b，应该先关闭流a，再关闭流b。例如，处理流a依赖节点流b，应该先关闭处理流a，再关闭节点流b 可以只关闭处理流，不用关闭节点流。处理流关闭的时候，会调用其处理的节点流的关闭方法
在C++中，char是基础数据类型，8位，1个字节。byte不是基础数据类型，一般是typedef unsigned char byte;这样子的，也就是说，byte其实是unsigned char类型，那么也是8位，1个字节。不同的是，char可以表示的范围是-128-127，而byte可以表示的范围是0-255。

在java中，char和byte都是基础数据类型，其中的byte和C++中的char类型是一样的，8位，1个字节，-128-127。但是，char类型，是16位，2个字节， '\u0000'-'\uFFFF'。

因为java内部都是用unicode的，所以java其实是支持中文变量名的

Java默认使用Unicode字符集来表示字符

Java语言中,中文字符所占的字节数取决于字符的编码方式,采用ISO8859-1编码方式时,一个中文字符与一个英文字符一样只占1个字节

采用GB2312或GBK或Unicode编码方式时,一个中文字符占2个字节

而采用UTF-8编码方式时,一个中文字符会占3个字节。

short → float 无须强制转换。
long → float 无须强制转换。
float占4个字节为什么比long占8个字节大呢，因为底层的实现方式不同。
double → float 没有强制转换，错误。
抽象类可以包含抽象方法，也可以不包含。
类中定义成员和方法，不能直接进行运算，可以写在代码块{}或者静态代码块中static{}中。
i++也是一个表达式，是有返回值的，返回值就是i自增前的值
抽象类和接口中的方法都没有方法体。
添加进TreeSet中的元素都指定了排序规则，有两种指定方式，要么元素实现java.lang.Comparable接口，要么创建TreeSet的时候传入一个java.util.Comparator类型的比较器。一般我们往TreeSet中添加的数字、字符串等类型的元素，都是用的第一种方式，sun公司在定义的这些类都实现了java.lang.Comparable，这就是所谓的自然规则。而如果需要向TreeSet中添加自定义类型的元素，也必须指定排序规则(两种方式都可以)，否则在进行添加的时候会报错(一个非受检异常java.lang.ClassCastException)
LinkedHashSet按添加顺序排序。
&运算符：两个数都转为二进制，然后从两个数的最高位进行与运算，两个都为真（1），结果才为真（1），否则为假（0）
Vector实现了List接口，List是一个接口。
抽象类中的方法是可以有方法体的。JDK1.8之后，接口中的方法也可以有方法体，用default关键字修饰方法。

当x和y的正负相同时，取余和取模结果相同；

当x和y的正负不同时，取余结果的符号和x相同，取模结果的符号和y相同。（口诀：取余取头，取模取尾）

while循环能够实现的操作，for循环也能实现
for(;;) 就是while(true) 死循环
我们使用while 就是为了他的循环次数的不一定的而for循环一般限定了循环次数
while(条件) {
//执行语句
}
都可以替换成
for(;条件;) {
//执行语句
}
hashMap可以以null为key HashTable不能
输入输出流编程中，读和写时都要抛出IOException
选项AbstractSet类实现Set接口
选项HashSet继承 AbstractSet类，同时也实现set
ClassLoader就是用来动态加载class文件到内存当中用的
ClassLoader使用的是双亲委托模型来搜索类的
Java默认提供的三个ClassLoader是Boostrap ClassLoader，Extension ClassLoader，App ClassLoader
boolean 1个字节或4个字节，在java规范2中，如果boolean用于声明一个基本类型变量时占4个字节，如果声明一个数组类型的时候，那么数组中的每个元素占1个字节
synchronized保证三大性，原子性，有序性，可见性，volatile保证有序性，可见性，不能保证原子性。
ResultSet中记录行的第一列索引为1。

通过阅读源码可以知道，string与stringbuffer都是通过字符数组实现的。

其中string的字符数组是final修饰的，所以字符数组不可以修改。

stringbuffer的字符数组没有final修饰，所以字符数组可以修改。

string与stringbuffer都是final修饰，只是限制他们所存储的引用地址不可修改。

至于地址所指内容能不能修改，则需要看字符数组可不可以修改。
HashMap实际上是一个"链表散列"的数据结构，即数组和链表的结合体。HashMap的底层结构是一个数组，数组中的每一项是一条链表。
解决冲突主要有三种方法：定址法，拉链法，再散列法
HashMap中的key-value都是存储在Entry数组中的。
Java中静态变量只能在类主体中定义，不能在方法中定义。静态变量属于类所有而不属于方法。
静态成员属于类成员，在方法区分配内存，而不是堆。静态变量属于类本身，成员变量属于类的某个实例。
同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。
String str="123456a";
int e=Integer.parseInt(str);//java.lang.NumberFormatException 非纯数字的字符串转化为Integer对象会报数字格式异常。
java.lang.NullPoninterException：变量未被初始化、对象未赋值、对象为空（俗称的空指针异常）
java.lang.RuntimeException：运行时异常
java.lang.ArrayindexOutOfBoundsException：数组下标越界
抽象方法只能定义在抽象类中，抽象方法和抽象类必须由abstract修饰，abstract关键字只能描述类和方法，不能描述变量。
abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。
静态方法中不能使用this和super关键字，因为this代表本类对象，super代表父类对象，而静态时，有可能没有对象存在，所以this和super无法使用。
被final修饰的变量只能是一个常量，只能赋值一次。内部类被定义在类中的局部位置上时，只能访问局部被final修饰的局部变量。
同样是新增5000个对象，LinkedLIst比ArrayList更快
在java中，我们可以用违例（Exception）来抛出一些并非错误的消息，但这样比直接从函数返回一个结果要更大的系统开销。
我们自定义异常的情况 ，请仔细读：我们可以用违例（Exception）来抛出一些并非错误的消息 ，可以，并非错误的消息。比如我自定义一个异常，若一个变量大于10就抛出一个异常，这样就对应了B选项说的情况，我用抛出异常说明这个变量大于10，而不是用一个函数体（函数体内判断是否大于10，然后返回true或false）判断，因为函数调用是入栈出栈，栈是在寄存器之下的速度最快，且占的空间少，而自定义异常是存在堆中，肯定异常的内存开销大！
Vector是Collection集合下的实现类，实现至List接口，是线程安全的，其底层和ArrayList同为数组，可实现自动扩容，但是ArrayList是非线程安全的。
接口继承的时候只能继承接口不能继承类，因为如果类可以存在非抽象的成员，如果接口继承了该类，那么接口必定从类中也继承了这些非抽象成员，这就和接口的定义相互矛盾，所以接口继承时只能继承接口。
线程安全概念：
如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。
线程安全问题都是由全局变量及静态变量引起的。
若每个线程中对全局变量、静态变量只有读操作，而无写操作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写操作，一般都需要考虑线程同步，否则的话就可能影响线程安全。
LinkedList 和 ArrayList 都是不同步的，线程不安全；
Vector 和 Stack 都是同步的，线程安全；
Set是线程不安全的；
Hashtable的方法是同步的，线程安全；
HashMap的方法不是同步的，线程不安全；
jre 判断程序是否执行结束的标准是所有的前台线程执行完毕。
后台线程：指为其他线程提供服务的线程，也称为守护线程。JVM的垃圾回收线程就是一个后台线程。前台线程：是指接受后台线程服务的线程，其实前台后台线程是联系在一起，就像傀儡和幕后操纵者一样的关系。傀儡是前台线程、幕后操纵者是后台线程。由前台线程创建的线程默认也是前台线程。可以通过isDaemon()和setDaemon()方法来判断和设置一个线程是否为后台线程。
托管线程池中的线程都是后台线程，使用new Thread方式创建的线程默认都是前台线程。
不管是前台线程还是后台线程，如果线程内出现了异常，都会导致进程的终止。
应用程序的主线程以及使用Thread构造的线程都默认为前台线程
使用Thread建立的线程默认情况下是前台线程，在进程中，只要有一个前台线程未退出，进程就不会终止。主线程就是一个前台线程。而后台线程不管线程是否结束，只要所有的前台线程都退出（包括正常退出和异常退出）后，进程就会自动终止。一般后台线程用于处理时间较短的任务，如在一个Web服务器中可以利用后台线程来处理客户端发过来的请求信息。而前台线程一般用于处理需要长时间等待的任务，如在Web服务器中的监听客户端请求的程序，或是定时对某些系统资源进行扫描的程序

finally是在return后面的表达式运算后执行的（此时并没有返回运算后的值，而是先把要返回的值保存起来，管finally中的代码怎么样，返回的值都不会改变，任然是之前保存的值），所以函数返回值是在finally执行前确定的；

finally中最好不要包含return，否则程序会提前退出，返回值不是try或catch中保存的返回值。

在try语句块或catch语句块中执行到System.exit(0)直接退出程序。

由于replaceAll方法的第一个参数是一个正则表达式，而"."在正则表达式中表示任何字符，所以会把前面字符串的所有字符都替换成"/"。如果想替换的只是"."，那么久要写成"\\.".
加载驱动方法
1.Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
1. DriverManager.registerDriver(new com.mysql.jdbc.Driver());
3.System.setProperty("jdbc.drivers", "com.mysql.jdbc.Driver")
Maven 拥有约定，因为你遵循了约定，它已经知道你的源代码在哪里

>>是算术右移操作符

运算符">>"执行算术右移，它使用最高位填充移位后左侧的空位。

右移的结果为：每移一位，第一个操作数被2除一次，移动的次数由第二个操作数确定。

逻辑右移或叫无符号右移运算符">>>"只对位进行操作，没有算术含义，它用0填充左侧的空位。

HashMap可以用null值和空字符串作为K,不过只能有一个
HashMap实现Map接口，它允许任何类型的键和值对象，并允许将null用作键或值

finally代码块在return中间执行。return的值会被放入临时空间，然后执行finally代码块，如果finally中有return，会刷新临时空间的值，方法结束返回临时空间值。

在调用子类构造器之前，会先调用父类构造器，当子类构造器中没有使用"super(参数或无参数)"指定调用父类构造器时，是默认调用父类的无参构造器，如果父类中包含有参构造器，却没有无参构造器，则在子类构造器中一定要使用"super(参数)"指定调用父类的有参构造器，不然就会报错。
equals和==的区别 ==操作比较的是两个变量的值是否相等，对于引用型变量表示的是两个变量在堆中存储的地址是否相同，即栈中的内容是否相同.
Java堆中存储的是对象，而不是引用。
在Java中，对象引用存储在堆中，而对象本身的数据结构存储在堆中。对象引用是存储在栈中的指针，它指向内存中对象的具体位置。这意味着，当我们通过引用访问一个对象时，实际上是通过栈中的引用找到堆中对象的位置来进行访问和操作的。堆内存用于动态存储对象和数组等数据，其存储空间较大，且数据的生命周期可以通过垃圾回收器来管理。相对地，栈内存用于存储局部变量、方法参数和返回地址等数据，是一种线性结构，其存储空间有限，且数据的生命周期与方法的执行周期相同
在源码中 toLowerCase 是重新 new String()。
在java 中，声明一个数组时，不能直接限定数组长度，只有在创建实例化对象时，才能对给定数组长度.。
包装类就是引用类型，基本数据类型就是值类型
锁只能使方法在一次调用的时候具备原子性，不能使多次调用的整体操作具备原子性。

^表示异或就是相同是0 不同是1 。14是1110，3是0011。所以14^3=1101，即13

三种定义方法： 1.String [] arr = new String[4]; 2.String [] arr = new String[]{"a","b","c","d"};3.String [] arr = {"a","b","c","d"};注意这种写法->String [] arr = new String[4]{"a","b","c","d"}; 编译会不通过

finalize是方法名，在垃圾收入集器将对象从内存中清除出去之前做必要的清理工作。
Java网络编程API建立在Socket基础之上
Java网络接口支持IP以上的所有高层协议
java虚拟机栈：线程私有 ，生命周期和线程一致。描述的是 Java 方法执行的内存模型：每个方法在执行时都会床创建一个栈帧(Stack Frame)用于存储局部变量表、操作数栈、动态链接、方法出口等信息。每一个方法从调用直至执行结束，就对应着一个栈帧从虚拟机栈中入栈到出栈的过程。没有类信息，类信息是在方法区中
java堆：对于绝大多数应用来说，这块区域是 JVM 所管理的内存中最大的一块。线程共享，主要是存放对象实例和数组
方法区：属于共享内存区域，存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。
高精度类型得到低精度结果需要进行强转
subset(form，true，to，true)是Treeset的非静态方法，该方法返回从form元素到to元素的一个set集合，两个boolean类型是确认是否包含边境值用的。
subSet是指向原数据的，原数据修改，subSet也跟着修改.
&在逻辑运算中是非短路逻辑与，在位运算中是按位与
导出类调用基类的构造器必须用到的关键字super 基类就是父类，也叫超类。导出类就是子类，也叫派生类。
子类调用父类的构造器使用super(),放在子类构造函数的首行。
request.getAttribute()方法返回request范围内存在的对象，而request.getParameter()方法是获取http提交过来的数据。getAttribute是返回对象,getParameter返回字符串。
java中静态属性和静态方法可以被继承。
静态方法，不存在重写，重写只对可见的实例方法有效。静态方法只有隐藏。
重载是根据形参的静态类型确定调用的方法版本，重写是根据调用者在运行期的实际类型来确定调用的方法版本。
Java中while()循环语句中，括号内必须为布尔值
abstract关键字不可以与final，private,static关键字共存，因为被final修饰的方法不可以被重写，意味着子类不可以重写该方法，如果abstract和final共同修饰父类中的方法，子类要实现抽象方法（abstract的作用），而final又不让该方法重写，这相互矛盾。如果private和abstract共同修饰父类中的方法，private修饰则该方法不可以被子类访问，但是abstract修饰需要子类去实现，两者产生矛盾。如果static和abstract共同修饰父类中的方法，static表示是静态的方法，随着类的加载而加载，则该方法不需要在子类中去实现，这与abstract关键字矛盾。
off-heap叫做堆外内存，将你的对象从堆中脱离出来序列化，然后存储在一大块内存中，这就像它存储到磁盘上一样，但它仍然在RAM中。对象在这种状态下不能直接使用，它们必须首先反序列化，也不受垃圾收集。序列化和反序列化将会影响部分性能（所以可以考虑使用FST-serialization）使用堆外内存能够降低GC导致的暂停。堆外内存不受垃圾收集器管理，也不属于老年代，新生代。
off-heap是指JVM进程管理的内存
抛InterruptedException的代表方法有：
java.lang.Object 类的 wait 方法
java.lang.Thread 类的 sleep 方法
java.lang.Thread 类的 join 方法
CyclicBarrier是一个屏障类，它的await方法可以简单的理解为：等待多个线程同时到达之后才能继续进行，在此之前它就是这些线程的屏障，线程不能继续进行，而对于失败的同步尝试，CyclicBarrier 使用了一种要么全部要么全不 (all-or-none) 的破坏模式：如果因为中断、失败或者超时等原因，导致线程过早地离开了屏障点，那么在该屏障点等待的其他所有线程也将通过 BrokenBarrierException（如果它们几乎同时被中断，则用 interruptedException）以反常的方式离开。因此它被中断也是可以抛出interruptedException的，如果还是不清楚，查看一下JavaAPI，对于这个类介绍的清清楚楚。
API里面写的：当线程在活动之前或活动期间处于正在等待、休眠或占用状态且该线程被中断时，抛出该异常。
suspend()这个方法容易造成死锁，已被标记过时！！
可以把局部内部类当做一个局部变量，所以它是不需要加任何修饰符的
局部内部类前不能用修饰符public和private,protected
内部类就随意了。
A选项：isIDCard=/^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3} $/C选项：isIDCard=/\^\[1-9\]\\d{5}\[1-9\]\\d{3}((0\\d)\|(1\[0-2\]))((\[0\|1\|2\]\\d)\|3\[0-1\])\\d{4}$ /
^：起始符号，^x表示以x开头
$：结束符号，x$ 表示以x结尾
[n-m]：表示从n到m的数字
\d：表示数字，等同于[0-9]
X{m}：表示由m个X字符构成，\d{4}表示4位数字
15位身份证的构成：六位出生地区码+六位出身日期码+三位顺序码
18位身份证的构成：六位出生地区码+八位出生日期码+三位顺序码+一位校验码
[1-9]\d{5}：六位出生地区码，出生地区码没有以0开头，因此第一位为[1-9]。
[1-9]\d{3}：八位出生日期码的四位年份，同样年份没有以0开头。
((0\d)|(1[0-2]))：八位出生日期码的两位月份，| 表示或者，月份的形式为0\d或者是10、11、12。
(([0|1|2]\d)|3[0-1])：八位出生日期码的两位日期，日期由01至31。
\d{4}：三位顺序码+一位校验码，共四位。
A选项的构成：
[1-9]\d{7}：六位出生地区码+两位出生日期码的年份，这里的年份指后两位，因此没有第一位不能为0的限制，所以合并了。
java.awt：包含构成抽象窗口工具集的多个类，用来构建和管理应用程序的图形用户界面
java.lang：提供java编成语言的程序设计的基础类java.io：　包含提供多种输出输入功能的类，
java.net：　包含执行与网络有关的类，如URL，SCOKET，SEVERSOCKET，
java.applet：包含java小应用程序的类
java.util：　包含一些实用性的类
**. java.util：**包含集合框架、遗留的 collection 类、事件模型、日期和时间设施、国际化和各种实用工具类（字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等）。集合类、时间处理模式、日期时间工具等各类常用工具包。
一个类一旦没有显式的定义任何构造，那么JVM会默认给你一个无参构造。无参构造的第一行依然默认是super()。
接口只能继承接口，但是可以多继承。类都是单继承，但是继承有传递性。
子类的构造器第一行默认都是super()，默认调用直接父类的无参构造，一旦直接父类没有无参构造，那么子类必须显式的声明要调用父类或者自己的哪一个构造器。
flush（）函数强制将缓冲区中的字符流、字节流等输出，目的是如果输出流输出到缓冲区完成后，缓冲区并没有填满，那么缓冲区将会一直等待被填满。所以在关闭输出流之前要调用flush（）。
OutputStream类包含方法flush()。
abstract类中不可以有private的成员。
java没有指针，只有引用。
包装类时针对基本数据类型的。String不是包装类。
子类的构造方法总是先调用父类的构造方法，如果子类的构造方法没有明显地指明使用父类的哪个构造方法，子类就调用父类不带参数的构造方法。而父类没有无参的构造函数，所以子类需要在自己的构造函数中显示的调用父类的构造函数。
不可变类，说的是一个类一旦被实例化，就不可改变自身的状态。常见的比如String和基本数据类型的包装类，对于这种不可变类，一旦在进行引用传递的时候，形参一开始就和实际参数指向的不是一个地址，所以在方法中对形参的改变，并不会影响实际参数。
对于线程而言，start是让线程从new变成runnable。run方法才是执行体的入口。
但是在Thread中，run方法是个空方法，没有具体实现。
Bground继承了Thread，但是没有重写run方法，那么调用run方法肯定是无输出。
真数组： 数组元素在内存中是一个接着一个线性存放的，通过第一个元素就能访问随后的元素，避免了数据覆盖的可能性，和数据类型覆盖并没有关系。

String str1 = ``"hello"``;

这里的str1指的是方法区中的字符串常量池中的"hello"，编译时期就知道的；

String str2 = ``"he"``+ ``new``String(``"llo"``);

这里的str2必须在运行时才知道str2是什么，所以它是指向的是堆里定义的字符串"hello"，所以这两个引用是不一样的。

如果用str1.equal(str2)，那么返回的是``true``；

标识符就是变量的意思。

Java反射机制（Java Reflection）是 Java 的特征之一，是Java语言中一种动态（运行时）访问、检测和修改它本身的能力，主要作用是动态（运行时）获取类的完整结构信息、调用对象的方法。简单点的说就是Java程序在运行时（动态）通过创建一个类的反射对象，再对类进行相关操作，比如：

在运行时判断任意一个对象所属的类；
在运行时构造任意一个类的对象；
在运行时判断任意一个类所具有的成员变量和方法（通过反射甚至可以调用private方法）；
在运行时调用任意一个对象的方法

重点： 是运行时而不是编译时

多数情况下，我们使用某个类，都会知道这个类，以及要用它来做什么，可以直接通过 new 实例化创建对象，然后使用这个对象对类进行操作，这个就属于正射。反射则是一开始并不知道要初始化的是什么类，无法使用new来实例化创建对象，主要是通过JDK提供的反射API来实现，在运行时才知道要操作的是什么类，并且可以获取到类的完整构造以及调用对应的方法，这就是反射。