对象vs对象变量
“对象” 描述的是一个类的具体实例，他被java虚拟机分配在 "堆" （Heap）中。
“对象变量” 为一个对象的引用（对象变量的值=记载着具体对象的位置/地址），他被分配在 "栈" （Stack） 上。
Date birthday = new Date();
birthday - 即为对象变量，他被分配在 Stack 上，初始化的Date对象被分配在 Heap 中，如图：
方法的隐式参数
在Java中，通常将 this 关键字称为方法的隐式参数。例如
public class Employee{ private double salary; public void raiseSalary(double byPercent){ double raise = this.salary * byPercent /100; this.salary += raise; } }
final 实例域
表示该实例应在其所在类的构造函数中赋值且之后是不可变的。例如定义常量。
static 关键字的用法
1. static + variable ： 定义一个属于类的变量，无论有多少个该类的实例对象，这个static变量的值均一样（指向同一个实例域）。
public class Employee{ private static int uniqueCode = 12345; }
所有employee对象的 uniqueCode 都指向同一个实例域。所以他们的值都相等 =1；
2. static + final + variable: 通常用于定义常量：
public class Math { ... priave static final PI = 3,1415926; ... }
3. 静态方法 - 直接通过 class.function() 的方式调用
4. 工厂方法 - 通过getXXXInstance（）的方式返回对象
5. Main 方法
初始化块
可以分为：
1.静态初始化块
2.对象初始化块
他们的执行顺序是根据定义的先后顺序，依次执行。例如
public class Employee{ private static int nextId; private int id; // static init block static { Radom radom = new Radom(); nextId = radom.nextInt(10000); } // object init block { id = 1; } }
包 （package）
目的： 保证类的唯一性；存放相同功能的一群类。
Jar (java 归档文件包)
使用 zip 格式压缩来组织文件目录以及子目录
-----
派生类调用父类的方法 super.fuc();
注意： supper 是一个关键字而不是对象。
object:所有对象的超类
hashcode() - 该方法默认情况下返回内存地址；String类型是特例他的返回值是由String的字符串值生成的。因此，当s1="OK", s2="OK"时，s1.hashcode() 等于 s2.hashcode()
泛型数组列表 - ArrayList<T>
// 定义1 ArrayList<Employee> employeeList = new ArrayList<Employee>(); // 定义 2 ArrayList<Employee> employeeList = new ArrayList<>();
两种定义均可，第二种为简写形式。
在定义ArrayList是，可以传递“capacity”指定大小，这么做只是分配给数组列表，一次性存储这么多对象的“潜力”，实际上在定义的还没有没有分配空间。
ArrayList.Set(int index, T obj); //设置某位的值-覆盖原值
ArrayList.Add(int index, T obj); //添加值-原来的值后移
使用 @SuppressWarning(“Uncheck”) 来接受类型转换的警告。
pulic class Test{ private ArrayList findQueryResult(){ ... } @SupperssWaring("Uncheck") ArrayList<Employee> list = this.findQueryResult(); }
枚举类
枚举类型实际上是一个类、他的常用发放有
valueof - 设置枚举实例的值。 Size s = Emum.valueof(Size.Class, "SMALL");
toString - 返回实例的字符串值
values - 返回全部枚举值的数组
ordinal - 返回枚举常亮的位置
反射
获取Class对象的三种方式：例如：
1. Employee.Class
2. e.getClass()
3. Class.forClass("Employee")
常用方法：
class.getName() 返回类名（完全名称，包括包名）
class.newInstance() 构造对象 ： Employee e1 = Class.forClass("com.xxx.Employee").newInstance();
接口
接口定义了一系列的“行为准则”，类如果要实现（implements）接口，必须要实现接口中的所有方法。
接口中的方法默认为 “public”的，所以不必显示生命为public。
接口中的域（字段），默认为public static final
内部类
使用内部类的三种情况：
1. 访问类中的域以及数据，包括私有的域和数据。
2. 对所属包中的其他类隐藏。
3. 多用匿名方法，视线回调函数。
一、编译器在编译内部类中是，会为其添加一个对于她的外部类的引用引用，我们将它称之为“out”, 例如：
public class TalkingClock{ private bool beep; private int interval; public TalkingClock(int interval, bool beep){ this.interval=interval; this.beep=beep; } ... public class TimePrinter(){ public printTime(){ if (beep){ Date now = new Date(); System.out.println("current is : " + now); } } } }
注： 内部类会在编译的时候修改内部类默认的构造器，如下，并且在调用的时候将外部类传递进去
public class TimePrinter(){ public TimePrinter(TalkingClock tc){ outer = tc; } }
// pass outer object reference
TimePrinter tp = new TimePrinter(this)
二、当内部类定义为 Public 时，可以创建和引用内部类，语法如下：OuterClass.InnerClass
TalkingClock tc = new TalkingClock(10000, true); tc.TimePrinter tp= tc. new TimePrinter();
局部内部类
顾名思义，在方法的内部定义的类。注：不能用修饰符【public,private】修饰它。举例：
public class OutClass{ public void start(){ class innerClass{ ... } InnerClass ic = new InnerClass(); Timmer t = new Timer(10000, ic); t.start(); } }
匿名内部类
// 定义了一个匿名类，它继承 object 类; // 调用匿名类的 getClass() 方法 new Object{}.getClass();
静态内部类
当内部类不需要引用外部类的字段时，可将内部类定义成为 static 的
public class OutClass{ static InnerClass{ ... } }