思来想去 还是觉得有个编程语言傍身，会有备无患。
java数组
静态初始化
int [] array = new int[]{1,2,3};
int [] array1 = {1,2,3}动态初始化
int [] array2 = new int[3];
java 内存
栈内存
基本变量、 引用变量
速度快 用于执行程序
堆内存
new创建的对象和数组。
java gc自动回收
引用
引用变量是普通变量，定义时在栈中分配内存 引用变量指向堆空间地址
java foreach写法
for (int i : s){do same thing}
封装
import
Java的常用包
java.lang：这个包下包含Java语言的核心类，如String、Math、System、和Thread 等。
java.util：这个包下包含了Java的大量工具类/接口和集合框架类/接口。如Arrays和List等
java.net：这个包下包含了一些Java网络编程相关的类、接口。
java.io这个包下包含了一些Java输入/输出编程相关的类/接口。
java.text：这个包下包含了一些Java格式化相关的类。
java.sql：这个包下包含了Java进行JDBC数据库编程的相关类/接口。
继承
父类是对子类共性的抽象，父类和子类的关系，是由一般到特殊的关系。
父类包含的范围总比子类包含的范围要大，所以可以认为父类是大类，子类是小类
在设计类的继承关系时，应当把共性放在父类，特性放在子类。
每一个类只能有一个直接父类，即单继承。
3.5.2 带有继承又带有静态初始化块
静态初始化块：用static修饰的代码块，也称为类初始化块。
静态初始化块只在类首次初始化时执行。
静态初始化块要比普通初始化块先执行。
静态初始化块和静态方法都是在类初始化时执行，而不是创建对象时执行。
静态初始化块与静态方法的区别：
如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;
需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动执行的. 静态方法在类加载的时候就已经加载可以用类名直接调用。
1）在类初始化阶段，先执行最顶层父类的静态初始化块，然后依次向下，直到执行当前类的静态初始化块。
2）在对象初始化阶段，先执行最顶层父类的初始化块、最顶层父类的构造器，然后依次向下，直到执行当前类的初始化块、当前类的构造构造器。
继承
多态
接口
接口(interface)是抽象方法和常量值的定义的集合
一个类可以实现多个接口，接口也可以继承其它接口
5）如果实现接口的类中没有实现接口中的全部方法，必须将此类定义为抽象类
设计模式
单例模式
懒汉模式
// 单例模式
class Single{
private static Single single;
private Single(){}
public static Single getSingle(){
if (single == null)
single = new Single();
return single;
}
}
饿汉模式
// 单例模式 饿
class Single1{
private static Single1 single = new Single1();
private Single1(){}
public static Single1 getSingle(){
return single;
}
}
简单工厂
运算类：是一个抽象类，有两个属性值，和一个抽象运算方法。
下面四个类是继承抽象类，用多态实现运算结果。
简单工厂模式最大的优点在于工厂类中包含了必要的逻辑判断，根据客户端的条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。如果要在运算里加取余或平方运算，需要在工厂里增加case 分支语句，修改 了原来的类，有点违反开放封闭原则。为了可扩展，采用工厂方法改写。
开放封闭原则：软件实体应该可以扩展，但是不可以修改。它有两个特性：对扩展开放，对修改封闭。
工厂模式
package day3;
interface Shape{
void draw();
}
class Circle implements Shape{
@Override
public void draw(){
System.out.println("draw a circle");
}
}
class Rect implements Shape{
@Override
public void draw(){
System.out.println("draw a Rect");
}
}
class DrawFactory{
//简单工厂模式 一个工厂
//工厂模式 多个工厂
public static Shape getShape(String type){
switch(type.toLowerCase()){
case ("circle"):
return new Circle();
case ("rect"):
return new Rect();
default:
return new Rect();
}
}
}
public class Factory {
public static void main(String args[]){
String drawshape = "circle";
DrawFactory factory = new DrawFactory();
Shape ShapeA = factory.getShape(drawshape);
ShapeA.draw();
Shape ShapeB = factory.getShape("rect");
ShapeB.draw();
}
}
非静态内部类
非静态内部类：没有static修饰的成员内部类。
当在非静态内部类的方法内访问某个变量时
1）系统优先在该方法内查找是否存在该名字的局部变量，如果存在就使用该变量。
2）如果不存在，则 到该方法所在的内部类中查找是否存在该名字的成员变量，如果存在则使用该成员变量。
3）如果不存在，则到该内部类所在的外部类中查找是否存在该名字的成员变量，如果存在则使用该变量。
4）如果还不存在，则系统将出现编译错误，提示找不到该变量。
如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量。
内部类如果访问外部类成员变量、内部类成员变量与内部类方法的局部变量同名时，
访问内部类方法的局部变量：变量名
访问内部类成员变量：this.变量名
访问外部类成员变量：外部类名.this.变量名
为什么能用Outer.this找到外部类的成员变量
有static 修饰的成员内部类，就是静态内部类。
静态内部类属于外部类的本身，而不属于外部类的某个实例对象。
静态内部类不能访问外部类的实例成员，只能访问外部类的类成员。即使是内部类的实例方法也不能访问外部类的实例成员，只能访问外部类的静态成员。
枚举类型
1）可达状态
当一个对象被创建后，有一个以上的引用变量引用它。在有向图中可以从起始顶点导航到该对象，那么它就出于可达状态，程序可以通过引用变量来调用该对象的属性和方法。
2）可恢复状态
如果程序中某个对象不再有任何引用变量引用它，他将进入可恢复状态，此时从有向图的起始顶点不能导航到该对象。在这种状态下，系统的垃圾回收机制转变回收该对象所占用的内存。在回收该对象之前，系统会调用可恢复状态的对象的finalize方法进行资源清理，如果系统调用finalize方法重新让一个以上的引用变量引用该对象，则该对象会再次编程可达状态；否则，该对象将进入不可达状态。
3）不可达状态
当对象的所有关联都被切断，且系统调用所有对象的finalize方法依然没有使该对象变成可达状态后，这个对象将永久性地失去引用，最后变成不可达状态。只有当一个对象出于不可达状态，系统才会真正回收该对象所占用的资源。
强制垃圾回收
调用 System 类的 gc() 静态方法：System.gc()
调用 Runtime 对象的 gc() 实例方法：Runtime.getRuntime().gc()
这种强制只是建议系统立即进行垃圾回收，系统完全有可能建议完全置之不理，垃圾回收机制会在收到通知后，尽快进行垃圾回收。
4.3 finalize 方法
Object类的finalize()方法。
finalize 方法的特点
1）永远不要主动调用某个对象的finalize 方法，该方法应交给垃圾回收机制调用。finalize 方法何时被调用，是否被调用具有不确定性，不要把finalize 方法当成一定会被执行的方法。
2）在 JVM 的规范中，只规定了 JVM 必须要有垃圾回收机制，但是什么时候回收却没有明确说明。也就是说，对象成为了垃圾对象之后， 并不一定会马上就被垃圾回收。
3）Sun 公司采用的垃圾回收的方式，是“最少回收” 的方式：只有当内存不够的时候才会进行垃圾回收。
4）当JVM执行finalize 方法时出现异常时，垃圾回收机制不会报告异常，程序继续执行。
目前已有很多用户，建议抛弃Object 类的 finalize 方法。
- 任何java类都可以重写Object类的finalize方法。
- finalize 方法在对象被垃圾回收的时候调用。
- 但是，由于 Sun 公司的 JVM 采用的是“最少”回收的机制，因此不应当把释放资源的代码写在 finalize 方法中。
基本类型的包装类型
equal
对对象来说 equal和== 相识，需要自己实现object的equal比较
类装载
什么是类装载时：
1）生成该类对象的时候，会加载该类及该类的所有父类；
2）访问该类的静态成员的时候；
3）class.forName("类名")(反射)；
String StringBuffer StringBuilder
package day3;
public class StringIntern {
public static void main(String args[]){
String a = "aaa";
String b = "aaa";
System.out.println(a==b);
String c = a + "aaa";
System.out.println(c == (a + b));
//运行时确定
String d = new String("aaa");
System.out.println("aaa" == d);
//新创建实例
d = d.intern();
System.out.println("aaa" == d);
}
}
用来处理字符串常用的类有3种: String、StringBuilder、StringBuffer。
它们的异同点：
- 都是 final 类, 都不允许被继承;
- String 长度是不可变的, StringBuffer、StringBuilder 长度是可变的;
- StringBuffer 是线程安全的, StringBuilder 不是线程安全的。
String VS StringBuffer
String 类型和StringBuffer的主要性能区别：String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。
使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。
StringBuilder
StringBuilder是5.0新增的。此类提供一个与 StringBuffer 兼容的 API，但不保证同步。该类被设计用作 StringBuffer 的一个简易替换，用在字符串缓冲区被单个线程使用的时候（这种情况很普遍）。如果可能，建议优先采用该类，因为在大多数实现中，它比 StringBuffer 要快。两者的方法基本相同。
使用策略
- 基本原则：
如果要操作少量的数据，用String ；
单线程操作大量数据，用StringBuilder ；
多线程操作大量数据，用StringBuffer。 - 不要使用String类的”+”来进行频繁的拼接，因为那样的性能极差的，应该使用StringBuffer或StringBuilder类，这在Java的优化上是一条比较重要的原则。
- StringBuilder一般使用在方法内部来完成类似”+”功能，因为是线程不安全的，所以用完以后可以丢弃。StringBuffer主要用在全局变量中。
- 相同情况下使用 StirngBuilder 相比使用 StringBuffer 仅能获得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险。而在现实的模块化编程中，负责某一模块的程序员不一定能清晰地判断该模块是否会放入多线程的环境中运行，因此：除非确定系统的瓶颈是在 StringBuffer 上，并且确定你的模块不会运行在多线程模式下，才可以采用StringBuilder；否则还是用StringBuffer。
Hashset 存放对象
- 覆盖实现equals
-
覆盖实现hashCode
ii
Collections util中的包
范型
//java7
List list = new ArrayList<>();
范型类
返回值为Set
java IO
其中：红色斜体代表抽象基类，无法直接创建实例；蓝色粗体代表节点流，必须直接与指定的物理节点关联。
说明：
1）表中的4个访问管道流，它们都用于实现进程之间通信功能。
2）表中的4个缓冲流增加了缓冲功能，可以提高输入、输出的效率，增加缓冲功能后需要使用flush()才可以将缓冲区的内容写入实际的物理节点。
3）表中的2个对象流主要用于实现对象的序列化。
4）表中的2个转换流，用于实现将字节流转换成字符流。
缓冲流
为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。
根据数据操作单位可以把缓冲流分为
字节流：BufferedInputStream和BufferedOutputStream
字符流：BufferedReader 和 BufferedWriter
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法
对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出。