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变量永远指向某个对象，是一个常量指针，而不是指向常量的指针。

一、final
        根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。

        final类不能被继承，没有子类，final类中的方法默认是final的。
        final方法不能被子类的方法覆盖，但可以被继承。
        final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
        final不能用于修饰构造方法。
        注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

1、final类
        final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。

2、final方法
        如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
        使用final方法的原因有二：
        第一、把方法锁定，防止任何继承类修改它的意义和实现。
        第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
        例如：

publicclass Test1 {
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(); //调用失败，无法从父类继承获得
}
}

3、final变量（常量）
        用final修饰的成员变量表示常量，值一旦给定就无法改变！
        final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。
        从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。

另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

package org.leizhimin;
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; 出错,已经给赋过值了.
        }
}

4、final参数
        当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

publicclass Test4 {
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变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

        static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：
类名.静态方法名(参数列表...)
类名.静态变量名

        用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。

1、static变量
        按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是：
        对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。
        对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。

2、静态方法

静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！
        因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

3、static代码块

static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

publicclass Test5 {
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变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。

4、static和final一块用表示什么
        static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！
        对于变量，表示一旦给值就不可修改，并且通过类名可以访问。
        对于方法，表示不可覆盖，并且可以通过类名直接访问。

        特别要注意一个问题：

        对于被static和final修饰过的实例常量，实例本身不能再改变了，但对于一些容器类型（比如，ArrayList、HashMap）的实例变量，不可以改变容器变量本身，但可以修改容器中存放的对象，这一点在编程中用到很多。

        也许说了这么多，反倒把你搞晕了，还是看个例子吧：

publicclass TestStaticFinal {
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();
        }
}

运行结果如下：

-------------值处理前----------

strStaticFinalVar=aaa

strStaticVar=null

strFinalVar=null

intStaticFinalVar=0

integerStaticFinalVar=8

alStaticFinalVar=[]

-------------值处理后----------

strStaticFinalVar=aaa

strStaticVar=哈哈哈哈

strFinalVar=null

intStaticFinalVar=0

integerStaticFinalVar=8

alStaticFinalVar=[aaa, bbb]

Process finished with exit code 0

        看了上面这个例子，就清楚很多了，但必须明白：通过static final修饰的容器类型变量中所“装”的对象是可改变的。这是和一般基本类型和类类型变量差别很大的地方。

成员内部类：
相当于类的非静态成员，可以用权限修饰符来修饰，包括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方法，因此我们不能运行它。
多继承	抽象方法可以继承一个类和实现多个接口	接口只可以继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。
添加新方法	如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。	如果你往接口中添加方法，那么你必须改变实现该接口的类。