final 内部类 static
【Java中为什么会有final变量】：
final这个关键字的含义是“这是无法改变的”或者“终态的”；
那么为什么要阻止改变呢？
java语言的发明者可能由于两个目的而阻止改变:
1).效率问题：
jdk中的某些类的某些方法，是不允许被用户覆盖的，设计者可能认为，所用方法已经是最好的方法，
用户私自覆盖，或是由于疏忽而覆盖，就会影响JVM或是系统的系能；
2). 设计所需：
众所周知，有些情况必须使用final关键字，比如方法中的匿名内部类的参数传递；
【final关键字的使用方法】：
【修饰变量】：
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
【修饰方法】：
final方法不能被子类方法覆盖，但可以被继承。
【修饰类】：
final类不能被继承，没有子类，final类中所有方法都是final的。
【final的内存分配方式】：
【修饰变量】：
通常情况下，final变量有3个地方可以赋值：直接赋值，构造函数中，或是初始化块中。
【初始化】：
由于在java的语法中，声明和初始化是联系在一起的，
也就是说：如果你不显示的初始化一个变量，系统会自动用一个默认值来对其进行初始化。(如int就是0)
对于final变量，在声明时，如果你没有赋值，系统默认这是一个空白域，在构造函数进行初始化，
如果是静态的，则可以在初始化块。
【内存】：
常量(final变量)和非final变量的处理方式是不一样的。
每一个类型在用到一个常量时，都会复制一份到自己的常量池中。
常量也像类变量(static)一样保存在方法区，只不过他保存在常量池。
(可能是，类变量被所有实例共享，而常量池是每个实例独有的。)
【修饰方法】：
保存在方法区，并且可以被函数代码直接替换，而不用等到执行时再决定具体是那个函数。
【修饰类】：
保存在方法区。
【java中变量的初始化顺序】：
变量的初始化次序优于任何方法，甚至在构造方法的前面。对于static变量也是一样，
如果变量是原始类型，那么它得到一个标准的原始类型的初始值，
如果是一个对象的引用，除非你创建了一个新的对象给这个引用，否则就是null。
static变量在需要的时候才会初始化，并且在这个类的构造函数和所有其他普通变量之前调用，static之后就不再进行初始化了，
static变量在类初始化时(注意不是实例)，就必须分配内存空间，
static变量单独划分一块存储空间。
java类首次装入时，会对静态成员变量或方法进行一次初始化，
先初始化父类的静态代码-->初始化子类的静态代码-->
(创建使历史，如果不创建实例，则后面的不执行)初始化父类的非静态代码-->初始化父类的构造
-->初始化子类的非静态代码-->初始化子类的构造
类只有在使用new调用创建的时候才会被java类装载器装入。
【final方法为何会高效】：
final方法会在编译的过程中利用内嵌机制进行inline优化。
inline优化是指：在编译的时候直接调用函数代码替换，而不是在运行时调用函数。
inline需要在编译的时候就知道最后要用哪个函数，
显然，非final是不行的。
非final方法可能在子类中被重写，由于可能出现多态的情况，编译器在编译阶段
并不能确定将来调用方法的对象的真正类型，也就无法确定到底调用哪个方法。
【什么是多态】：
按字面的意思是“多种状态”。在面向对象语言中，接口的多种不同的实现方式即为多态。
简单的说，就是一句话：允许将子类类型的指针赋值给父类类型的指针。
【非final方法为什么会出现多态】：
显然，如果派生出一个子类，覆盖非final方法，就会出现2个这样的方法可供调用，这就是多态。
【final变量的变与不变】：
有人说final变量在赋值后就不可变，
那么这个不变到底指的是什么呢？
这个不变指的是引用，是地址，而所引用的对象的内容仍然是可变的。
就是说，这个final变量永远指向某个对象，是一个常量指针，而不是指向常量的指针。
根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二：
第一、把方法锁定，防止任何继承类修改它的意义和实现。
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
例如：
publicstaticvoid main(String[] args) {
// TODO 自动生成方法存根
}
publicvoid f1() {
System.out.println("f1");
}
//无法被子类覆盖的方法
publicfinalvoid f2() {
System.out.println("f2");
}
publicvoid f3() {
System.out.println("f3");
}
privatevoid f4() {
System.out.println("f4");
}
}
publicclass Test2 extends Test1 {
publicvoid f1(){
System.out.println("Test1父类方法f1被覆盖!");
}
publicstaticvoid main(String[] args) {
Test2 t=new Test2();
t.f1();
t.f2(); //调用从父类继承过来的final方法
t.f3(); //调用从父类继承过来的方法
//t.f4(); //调用失败，无法从父类继承获得
}
}
用final修饰的成员变量表示常量，值一旦给定就无法改变！
final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。
另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
publicclass Test3 {
privatefinal String S = "final实例变量S";
privatefinalint A = 100;
publicfinalint B = 90;
publicstaticfinalint C = 80;
privatestaticfinalint D = 70;
publicfinalint E; //final空白,必须在初始化对象的时候赋初值
public Test3(int x) {
E = x;
}
/**
* @param args
*/
publicstaticvoid main(String[] args) {
Test3 t = new Test3(2);
//t.A=101; //出错,final变量的值一旦给定就无法改变
//t.B=91; //出错,final变量的值一旦给定就无法改变
//t.C=81; //出错,final变量的值一旦给定就无法改变
//t.D=71; //出错,final变量的值一旦给定就无法改变
System.out.println(t.A);
System.out.println(t.B);
System.out.println(t.C); //不推荐用对象方式访问静态字段
System.out.println(t.D); //不推荐用对象方式访问静态字段
System.out.println(Test3.C);
System.out.println(Test3.D);
//System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同.
System.out.println(t.E);
Test3 t1 = new Test3(3);
System.out.println(t1.E); //final空白变量E依据对象的不同而不同
}
privatevoid test() {
System.out.println(new Test3(1).A);
System.out.println(Test3.C);
System.out.println(Test3.D);
}
publicvoid test2() {
finalint a; //final空白,在需要的时候才赋值
finalint b = 4; //局部常量--final用于局部变量的情形
finalint c; //final空白,一直没有给赋值.
a = 3;
//a=4; 出错,已经给赋过值了.
//b=2; 出错,已经给赋过值了.
}
}
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。
publicstaticvoid main(String[] args) {
new Test4().f1(2);
}
publicvoid f1(finalint i) {
//i++; //i是final类型的,值不允许改变的.
System.out.print(i);
}
}
二、static
static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。
被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。
用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。
类名.静态方法名(参数列表...)
类名.静态变量名
按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。
静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：
privatestaticint a;
privateint b;
static {
Test5.a = 3;
System.out.println(a);
Test5 t = new Test5();
t.f();
t.b = 1000;
System.out.println(t.b);
}
static {
Test5.a = 4;
System.out.println(a);
}
publicstaticvoid main(String[] args) {
// TODO 自动生成方法存根
}
static {
Test5.a = 5;
System.out.println(a);
}
publicvoid f() {
System.out.println("hhahhahah");
}
}
3
hhahhahah
1000
4
5
static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
对于方法，表示不可覆盖，并且可以通过类名直接访问。
privatestaticfinal String strStaticFinalVar = "aaa";
privatestatic String strStaticVar = null;
privatefinal String strFinalVar = null;
privatestaticfinalint intStaticFinalVar = 0;
privatestaticfinal Integer integerStaticFinalVar = new Integer(8);
privatestaticfinal ArrayList<String> alStaticFinalVar = new ArrayList<String>();
privatevoid test() {
System.out.println("-------------值处理前----------\r\n");
System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
System.out.println("strStaticVar=" + strStaticVar + "\r\n");
System.out.println("strFinalVar=" + strFinalVar + "\r\n");
System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n");
System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");
//strStaticFinalVar="哈哈哈哈"; //错误，final表示终态,不可以改变变量本身.
strStaticVar = "哈哈哈哈"; //正确，static表示类变量,值可以改变.
//strFinalVar="呵呵呵呵"; //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//intStaticFinalVar=2; //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
//integerStaticFinalVar=new Integer(8); //错误, final表示终态，在定义的时候就要初值（哪怕给个null），一旦给定后就不可再更改。
alStaticFinalVar.add("aaa"); //正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
alStaticFinalVar.add("bbb"); //正确，容器变量本身没有变化，但存放内容发生了变化。这个规则是非常常用的，有很多用途。
System.out.println("-------------值处理后----------\r\n");
System.out.println("strStaticFinalVar=" + strStaticFinalVar + "\r\n");
System.out.println("strStaticVar=" + strStaticVar + "\r\n");
System.out.println("strFinalVar=" + strFinalVar + "\r\n");
System.out.println("intStaticFinalVar=" + intStaticFinalVar + "\r\n");
System.out.println("integerStaticFinalVar=" + integerStaticFinalVar + "\r\n");
System.out.println("alStaticFinalVar=" + alStaticFinalVar + "\r\n");
}
publicstaticvoid main(String args[]) {
new TestStaticFinal().test();
}
}
Process finished with exit code 0
成员内部类：
相当于类的非静态成员，可以用权限修饰符来修饰，包括private、protected、public.
1、定义成员内部类
class Outter {
//非静态内部类
class Inner {
//内部类成员
int i = 12;
}
//外部类的普通成员
int j = 0;
}
2、外部类之内创建成员内部类对象
语法和普通的创建对象相同，用new操作符调用相应的构造方法即可。注意的是，非静态内部类属于外部类的非静态成员，不能在静态上下文使用。
例子：
class Outter {
//非静态内部类
class Inner {
//内部类成员
int i = 12;
public void innerTest() {
System.out.println(“Inner Class Method”);
}
}
//外部类的普通成员
int j = 0;
public void test() {
Inner inner = new Inner();
inner.innerTest();
}
}
3、外部类之外创建成员内部类对象
既然是外部类的非静态成员，就必须在外部类对象存在的情况下使用。
基本语法是
<外部类类名>.<内部类类名> 引用变量名称 = <外部类对象的引用>.new <内部类构造器>;
<外部类类名>.<内部类类名> 引用变量名称 = new <外部类构造器>.new <内部类构造器>;
(1)、创建内部类对象时对象引用必须是<外部类类名>.<内部类类名>
(2)、调用内部类的构造方法不能直接用new 而是要用<外部类对象的引用>.new调用
例子：
class Outter {
//非静态内部类
class Inner {
//内部类成员
int i = 12;
public void innerTest() {
System.out.println(“Inner Class Method”);
}
}
//外部类的普通成员
int j = 0;
}
class MainTest {
public static void main(String[] args) {
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner();
inner.innerTest();
}
}
在外部类之外访问内部类时需要注意权限修饰符的限制，这点和类成员一样。
3、内部类编译后生成的.class文件名称格式是<外部类类名>$<内部类类名>。
4、内部类与外部类之间的成员互相访问
内部类可以访问外部类的任何成员，包括private成员。
外部类访问内部类的成员需要创建内部类的对象，之后可以访问内部类的任何成员，包括private成员，需要注意的是成员内部类不可以有静态成员。
当外部类的成员和内部类的成员重名时单单用this是区分不了的。在内部类中访问外部类的成员时可以用如下语法区分
<外部类类名>.this.<外部类中需要被访问的成员名>;
局部内部类
内部类定义在方法中成为局部内部类，只在局部有效。该类只为所在的方法块服务。
局部内部类和成员内部类一样可以访问外围类的所有成员，但是不可以访问同在一个局部块的普通局部变量。如果要访问，此局部变量要被声明称final的。
代码块结束后普通的局部变量会消亡，而创建的局部内部类对象并不会随着语句块的结束而消亡。final的局部变量的存储方式和普通的局部变量不同，其不会因为语句块的结束而消失，还会长期存在，因此可以被局部内部类访问。
例子：
public class InnerClassTest1 {
public static void main(String[] args) {
Outter outter = new Outter();
ForInner forInner = outter.getInner();
forInner.sayHello();
}
}
class Outter {
ForInner forInner;
public ForInner getInner() {
class Inner implements ForInner {
public void sayHello() {
System.out.println("你好，我是局部内部类对象，我还存在！");
}
}
forInner = new Inner();
return forInner;
}
}
interface ForInner {
void sayHello();
}
由于局部内部类只在局部有效，所以不能在外面用局部内部类的引用指向局部内部类的对象，只能用局部内部类实现接口并创建局部内部类对象，在外面用接口引用指向局部内部类对象。
静态方法中的局部内部类只能访问外围类的静态成员，访问不了非静态成员。
局部内部类生成的.class文件名称是<外部类类名>$<n><内部类类名>其中n是该局部的第几个内部类
静态内部类
静态内部类的定义
class Outter {
static class Inner {
/****/
}
}
由于静态内部类是外部类的静态成员，所以静态内部类只能访问外部类的静态成员。并且创建静态内部类的对象不依赖外部类的对象。在外部类之外创建静态内部类对象的语法如下
<外部类类名>.<内部类类名> 引用变量名 = new <外部类类名>.<内部类构造器>;
例子：
class Outter {
static class Inner {
public void sayHello() {
System.out.println(“成功创建静态内部类对象！”);
}
}
public void getInner() {
//在外部类中创建静态内部类的对象
Inner ii = new Inner();
ii.sayHello();
}
}
public class MainTest {
public static void main(String[] args) {
//在外部类外创建静态内部类的对象
Outter.Inner i = new Outter.Inner();
i.sayHello();
//在外部类中使用静态内部类的对象
new Outter().getInner();
}
}
静态内部类实际上已经脱离了外部类的控制，创建对象时也不再需要外部类对象的存在，实质上只是一个放置在别的类中的普通类而已。
匿名内部类
基于继承的匿名内部类，语法如下：
new <匿名内部类要继承父类的对应构造器> {
//匿名内部类类体
};
基于实现接口的匿名内部类，语法如下：
new <接口名> {
//匿名内部类类体，实现接口中的所有方法
}
匿名内部类中使用外面的变量要被声明成final的。
匿名内部类对象初始化的代码可以写在其非静态块中
匿名内部类生成的.class文件是<外部类类名>$<n>.class n是该类的第几个匿名内部类。
各种内部类可用的修饰符
成员内部类
final、abstract、public、private、protected、static
静态内部类
final、abstract、public、private、protected
局部内部类
final、abstract
匿名内部类
不能对匿名内部类使用修饰符
内部接口
定义在类中的内部接口无论是否被static修饰都是静态成员。
内部接口声明成private的意味着只能被外部类中的某个内部类来实现。
内部接口不能扮演局部的角色，否则编译报错。因为接口的设计初衷是对外公布，让很多类实现，而局部的角色违背了接口的设计初衷。
接口中的内部接口属于接口的成员，具有接口成员的所有属性，不能用private进行修饰。
外部接口外实现内部接口的语法如下：
class <类名> implements <外部接口名>.<内部接口名> {
//类体
}
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final (这里需要说一点,既然一个变量被final修饰了,那么这个变量就是一个常量!!!!!变量必须初始化成常量!!!!!)
下面比较一下两者的语法区别：
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量!!!!!!!(注意重点在 普通 即 非静态 和 变量!!!!)
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法(static)，接口中不能包含静态方法.
6. 抽象类和接口中都可以包含静态成员变量(static)，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。
7. 一个类可以实现多个接口，但只能继承一个抽象类。
参数
| 抽象类 | 接口 | |
| 默认的方法实现 | 它可以有默认的方法实现 | 接口完全是抽象的。它根本不存在方法的实现 |
| 实现 | 子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。 | 子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现 |
| 构造器 | 抽象类可以有构造器 | 接口不能有构造器 |
| 与正常Java类的区别 | 除了你不能实例化抽象类之外，它和普通Java类没有任何区别 | 接口是完全不同的类型 |
| 访问修饰符 | 抽象方法可以有public、protected和default这些修饰符 | 接口方法默认修饰符是public。你不可以使用其它修饰符。 |
| main方法 | 抽象方法可以有main方法并且我们可以运行它 | 接口没有main方法，因此我们不能运行它。 |
| 多继承 | 抽象方法可以继承一个类和实现多个接口 | 接口只可以继承一个或多个其它接口 |
| 速度 | 它比接口速度要快 | 接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。 |
| 添加新方法 | 如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。 | 如果你往接口中添加方法，那么你必须改变实现该接口的类。 |
