[置顶] JAVA知识点
1 执行下列语句将清除1.txt的内容
FileOutputStream objectOutputStream = new FileOutputStream(
"1.txt", false);
FileOutputStream立马创建，而不需要判断是否CLOSE或者写入。
File file=new File("t.txt");不创建新文件
2 BUILD不了
（1）尝试手动build
（2）查看是否有LIB加载错误或丢失
（3）若一些JRE的JAR老提示找不到，可以重新加JRE到BUILD PATH里面
3 修改JAR里面的CLASS后，不需要重新添加至BUILD PATH
4. 在创建需要清理对象之后立马进入try finally语句块！
5.抽象类可以实现接口，接口可以继承接口，且两者都可以选择实现父接口方法，而不是必须！
interface demo {
Number go();
}
abstract class GenericDemo implements demo {
}
interface GenericDemo extends demo {
}
6. 枚举类型既然是类，那么也就可以有构造函数。只不过不得有公开(Public)的构造函数，这是为了避免直接对枚举类型实例化。如下代码：
Java代码
enum DetailActioin2
{
TURN_LEFT("向左转"),TURN_RIGHT("向右转"),SHOOT("射击");
private String description;
//不公开的构造函数
private DetailActioin2(String description)
{
this.description = description;
}
public String getDescription()
{
return description;
}
}
7 matcher.appendReplacement(sb, "$0"+"$1"+"_recycle/");
8 没有这样的语法： T super Integer
9
///U/U3FR3FFG6FRVVMFCWGUHJE66K4-UZH/U3FR3FFG6FRVVMFCWGUHJE66K4-UZH_recycleBin/fujian1
"/[^/]*?" + recycleBin;
/U/U3FR3FFG6FRVVMFCWGUHJE66K4-UZH/fujian1
10 抽象工厂通过不同的构建过程生成不同的对象表示，而Builder模式通过相同的构建过程生成不同的表示。
11 new FILE中FILE需要的是绝对路径，
12
在实际编程实践中，你不一定总能清楚地知道每层的流对象是否占据了系统资源，所以，最安全（也是最常规）的做法就是关闭最外层的那个对象。这种逐层包装的对象在实现上都会有一个特点，像“关闭”这种操作都会逐层向内调用。
13 格式化文档
//print
System.out.printf(format, args)
System.out.format(format, args)
new Formatter(System.out).format(format, args);
//return string
String.format(format, args)
错误：
System.out.println(String.format("\t[%d]\t[%d]\t[%d]",
arrayData[0], arrayData[1], arrayData[2]));
正确
System.out.format("\t[%d]\t[%d]\t[%d]",
arrayData[0], arrayData[1], arrayData[2]);
14 多参列表：
//right
Object[] arrayData = new Object[3];
Arrays.fill(arrayData, 1);
System.out.format("\t[%d]\t[%d]\t[%d]",
arrayData);
//error
int[] arrayData2 = new int[3];
Arrays.fill(arrayData, 1);
System.out.format("\t[%d]\t[%d]\t[%d]",
arrayData2);
15 先后往前
| 1 |
[]数组运算 .点运算符 （）调用方法 |
从左到右 |
| 2 |
! ~ ++ -- +(一元加) -(一元减) （）强制类型转换 new |
从右到左 |
16 打印异常的时候，先是最后调用的方法，然后依次推后。
int abs = Math.abs(Integer.MIN_VALUE);
int i = Integer.MAX_VALUE + 1;
// -2147483648
System.out.print(abs);
System.out.print(abs == i);
17
instanceof
System.out.println((String)null); //返回null
System.out.println(null instanceof Object); //遇到左边null,直接返回null
System.out.println(0 instanceof Integer); //无法编译, 一个基本类型，一个对象
System.out.println(new Date() instanceof Integer); //无法编译，没有任何继承关系
20
类的时候分为主动使用和被动使用
类加载分为 ： 加载。连接（验证，准备，解析），初始化； 操作的都是静态成员或者静态块； 在准备阶段分配它们的内存并设置默认值， 在初始化阶段设置成真实的值；
而实例化的时候，才有构造器的调用， 同样先为非静态成员分配空间和默认值，然后初始化（初始化域和块，然后到构造器。）
所以调用子类，在类加载的时候即完成了静态部分，然后实例化的时候才先父类后子类。
区别类实例化和类初始化。
21
int planet = 7; String event = "a disturbance in the Force"; String result = MessageFormat.format( "At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.", planet, new Date(), event);
22
long x=100*100*10000000;
System.out.println(x);
不是这个数值，
long y=100000000000;
编译错误
因此正确应该是long x=100L*100*10000000;
23
不用声明异常，可见给最后的return屏蔽了，不要用这个方式。
public static Person newInstance(){
Person person=new Person("1");
try {
return person;
} catch (Exception e) {
throw new Exception();
}finally{
person.setName("2");
return person;
}
}
反回NAME为2
24： ArrayList >size即1.5倍+1
HashMap>threshold(capacity * load factor) *2倍
vector也是2倍或者步长capacityIncrement
错误的写法:
- Map map = new HashMap(collection.size());
- for (Object o : collection) {
- map.put(o.key, o.value);
- }
Map map = new HashMap(collection.size());
for (Object o : collection) {
map.put(o.key, o.value);
}
这里可以参考guava的Maps.newHashMapWithExpectedSize的实现. 用户的本意是希望给HashMap设置初始值, 避免扩容(resize)的开销. 但是没有考虑当添加的元素数量达到HashMap容量的75%时将出现resize.
正确的写法:
- Map map = new HashMap(1 + (int) (collection.size() / 0.75));
Map map = new HashMap(1 + (int) (collection.size() / 0.75));
25
（不符合LSP： Liskov Substitution Principle）
覆写必须满足4个条件： 可见性放大，异常减少，返回值类型变大，参数不变。；都是发扬光大的事情
不符合LSP： （无关覆写），Liskov Substitution Principle， 前置条件（参数）类型缩小，构造器抛出异常放大（）
违反LSP，即父类出现的地方都可以换成子类： 构造器抛出异常，子类必须抛出的更多或一样，更多时就违反了。 重载时，子类的参数类型较小。替换掉的话，有可能导致行为变成子类的重载行为。所以子类的重载参数类型都大的时候，可以保证行为一致。
26 用IDE生成的HASHCODE和EQUALS方法之后，如果把EQUALS中一些不需要的字段比较去掉，一定不要忘记把HASH CODE的也改掉。否则对象相同, HASHCODE不同。
___________________________________________
27 volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java内存模型保证声明为volatile的long和double变量的get和set操作是原子的。在32位机器上，对LONG/DOUBLE型的读写被切成2个32位。所以不是原子操作。如果是以后的64位，这个问题应该可以解决。
28
原子操作：
读写变量是原子操作，除了LONG/DOUBLE,但是加上VOLATILE就可变成原子操作
- Reads and writes are atomic for reference variables and for most primitive variables (all types except
longanddouble). - Reads and writes are atomic for all variables declared
volatile(includinglonganddoublevariables).
29
System.out.println(System.getProperty("java.ext.dirs")); 扩展
System.out.println(System.getProperty("java.class.path")); 系统或者应用
System.out.println(System.getProperty("sun.boot.library.path")); 根
30
在java的线程Thread类中有三个方法，比较容易混淆，在这里解释一下
（1）interrupt：置线程的中断状态
（2）isInterrupt：线程是否中断
（3）interrupted：返回线程的上次的中断状态，并清除中断状态