类

抽象类：（通用性，将相同的部分抽象起来）

1. 包含一个及以上抽象方法的类必须为抽象类
2. 抽象类可以包含具体数据和具体方法；
3. 抽象类可以不含抽象方法；
4. 抽象类不能被实例化；

接口：（描述类具体什么功能）

1. 接口没有实例；
2. 实现接口的类必须定义接口中的所有方法；

抽象类接口区别：

1. 每个类只能继承一个类，却可以实现多个接口

lamada:(可传递的代码块)

1. 将lambda表达式传递到需要一个函数式接口的方法时，要用函数式接口来接受lambda表达式，再实现接口中的抽象方法——（P241）

内部类：（在类中定义的类）

1. 内部类可以访问外围类的私有数据；
2. 内部类可以对同一个包中的其他类隐藏；
3. 内部类不能有static方法；
4. 只有内部类可以声明为static；
5. 在内部类不需要访问外围类对象时，应该使用静态内部类；
6. 内部类为static时，不能引用外围类对象

局部内部类：（在方法中定义的类）

1. 不能用public或private访问说明符进行声明，它的作用域被限定在声明局部类的块中；
2. 局部内部类对外界可以完全地隐藏，只有包含定义类的块的方法知道；
3. 不仅可以访问包含它们的外部类，还可以访问final类型的局部变量；

static 关键字：

用于修饰成员（成员变量和成员函数），被修饰的成员具备以下特点：

1. 随着类的加载而加载；
2. 优先于对象而存在；
3. 被所有对象所共享；
4. 可以直接被类名调用。

使用注意：

1. 静态方法只能访问静态成员；
2. 静态方法中不可以写this、super关键字；
3. 主函数是静态的。

Static方法：

1. 无法在静态方法中引用非静态成员，非静态的变量是依赖对象存在的，对象必须实例化后，它的变量才会在内存中存在

2. 内部类也是如此，在外围类static main方法中不能直接构造内部类对象，必须先new一个外围类对象，使其在内存中存在，通过外围类引用构造内部类对象或将内部类定义为static(这样内部类将不能访问外围类的对象)

在类中，用static声明的成员变量为静态成员变量，它为该类的公用变量，在第一次使用时被初始化，对于该类的所有对象来说，static成员变量只有一份；
用static声明的方法为静态方法，在调用该方法时，不会将对象的引用传递给它，所以在static方法中不可访问非static的成员；
静态方法不再是针对于某个对象调用，所以不能访问非静态成员
可以通过对象引用或类名（不需要实例化）访问静态成员
关于Static类：
深夜，临睡前写了个小程序，除了点小问题

public class Test_drive {
	public static void main(String[] args){
		A a = new A();　　　　　　　　　　　　　　//报错
		B b = new B();　　　　　　　　　　　　　　//报错
		System.out.println(b instanceof A);
	}
	class A{
		int a;
	}
	class B extends A{
	}
}

上面两个语句报错信息如下：

No enclosing instance of type Test_drive is accessible. Must qualify
the allocation with an enclosing instance of type Test_drive (e.g.
x.new A() where x is an instance of Test_drive). 在overflow上面查找到了类似的问题：
http://stackoverflow.com/questions/9560600/java-no-enclosing-instance-of-type-foo-is-accessible/9560633#9560633

下面简单说一下我的理解：

在这里，A和B都是Test_drive的内部类，类似于普通的实例变量，如果类的静态方法不可以直接调用类的实例变量。在这里，内部类不是静态的内部类，所以，直接赋值（即实例化内部类），所以程序报错。

解决的方法可以有以下两种：
（1）将内部类定义为static，即为静态类
（2）将A a = new A();B b = new B(); 改为：

    Test_drive td = new Test_drive();
    A a = td.new A();
    B b = td.new B();  

This关键字：

在类的方法定义中使用的this代表使用该方法的对象的引用，
当必须指出当前使用方法的对象是谁时要使用this，
有时使用this可以处理方法中成员变量个参数重名的情况，
this可以看作是一个变量，它的值是 流当前对象的引用

public class Leaf {
	int i = 0;
	Leaf(int I) {
		this.i = i;
	}
	Leaf increament() {
		i++;
		return this;
	}
	void print() {
		System.out.println(“i = ”+i);
	}
	Public static void main(String[] args){
		Leaf leaf = new Leaf(100);
		Leaf.increament().increament().print();
	}
}

CoreJavaChapter6：

在实现Comparator接口时的Comparator.LengthComparator类中的Arrays.sort(friends, new LengthComparator())方法有何用？
//因为sort方法，只要元素顺序不对就会一直通过LengthComparator对象调用compare方法
（P237）构造器引用：Person::new在卷II第一章讨论stream,map,collect方法详解

final关键字的用法

在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。下面就从这三个方面来了解一下final关键字的基本用法。

1. 修饰类
   当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。
   final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。

2. 修饰方法
   在使用final时，注意，只有在想明确禁止该方法在子类中被覆盖的情况下才将方法设置为final。
   final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。
   此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。
   （注：类的private方法会隐式地被指定为final方法。）

3. 修饰变量
   final修饰变量只能被赋值一次，赋值后不再改变。

类初始化顺序

Java代码中一个类初始化顺序：

static变量 －> 其他成员变量 －> 构造函数

三者的调用先后顺序：

初始化父类Static －> 子类的Static （如果是类实例化，接下来还会： 初始化父类的其他成员变量－> 父类构造方法－> 子类其他成员变量－> 子类的构造方法）。

系统默认值的给予比通过等号的赋予先执行。
一个类中的static变量或成员变量的初始化顺序，是按照声明的顺序初始化的。