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

 

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

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

一、final类
        final类不能被继承，所以final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，若是这个类不须要有子类，类的实现细节不容许改变，而且确信这个类不会载被扩展，那么就设计为final类。

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

public class Test1 {
public static void main(String[] args) {
// TODO 自动生成方法存根
}
public void f1() {
    System.out.println( "f1");
}
//没法被子类覆盖的方法
public final void f2() {
    System.out.println( "f2");
}
public void f3() {
    System.out.println( "f3");
}
private void f4() {
    System.out.println( "f4");
}
}
public class Test2 extends Test1 {
public void f1(){    
    System.out.println( "Test1父类方法f1被覆盖!");
}
public static void 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的使用上提供了更大的灵活性，为此，一个类中的final数据成员就能够实现依对象而有所不一样，却有保持其恒定不变的特征。

package org.leizhimin;
public class Test3 {
private final String S = "final实例变量S";
private final int A = 100;
public final int B = 90;
public static final int C = 80;
private static final int D = 70;
public final int E; //final空白,必须在初始化对象的时候赋初值
public Test3( int x) {
                E = x;
        }
/**
         * @param args
         */
public static void 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依据对象的不一样而不一样
        }
private void test() {
                System.out.println( new Test3(1).A);
                System.out.println(Test3.C);
                System.out.println(Test3.D);
        }
public void test2() {
final int a;     //final空白,在须要的时候才赋值
final int b = 4;     //局部常量--final用于局部变量的情形
final int c;     //final空白,一直没有给赋值.    
                a = 3;
//a=4;    出错,已经给赋过值了.
//b=2; 出错,已经给赋过值了.
        }
}

四、final参数
        当函数参数为final类型时，你能够读取使用该参数，可是没法改变该参数的值。

public class Test4 {
public static void main(String[] args) {
new Test4().f1(2);
        }
public void f1( final int i) {
//i++;    //i是final类型的,值不容许改变的.
                System.out.print(i);
        }
}

2、static

        static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也能够造成静态static代码块，可是Java语言中没有全局变量的概念。

被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的全部实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。所以，static对象能够在它的任何对象建立以前访问，无需引用任何对象。

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的全部实例共享同一个static变量。

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

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

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

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

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

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

public class Test5 {
private static int a;
private int 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);
        }
public static void main(String[] args) {
// TODO 自动生成方法存根
        }
static {
                Test5.a = 5;
                System.out.println(a);
        }
public void f() {
                System.out.println( "hhahhahah");
        }
}

运行结果：
3
hhahhahah
1000
4
5

        利用静态代码块能够对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候能够直接调用而不用建立实例。

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

        特别要注意一个问题：

        对于被static和final修饰过的实例常量，实例自己不能再改变了，但对于一些容器类型（好比，ArrayList、HashMap）的实例变量，不能够改变容器变量自己，但能够修改容器中存放的对象，这一点在编程中用到不少。

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

public class TestStaticFinal {
private static final String strStaticFinalVar = "aaa";
private static String strStaticVar = null;
private final String strFinalVar = null;
private static final int intStaticFinalVar = 0;
private static final Integer integerStaticFinalVar = new Integer(8);
private static final ArrayList<String> alStaticFinalVar = new ArrayList<String>();
private void 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");
        }
public static void 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.
一、定义成员内部类
class Outter {
//非静态内部类
class Inner {
//内部类成员
int i = 12;
}
//外部类的普通成员
int j = 0;
}
二、外部类以内建立成员内部类对象
语法和普通的建立对象相同，用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();
}
}
三、外部类以外建立成员内部类对象
既然是外部类的非静态成员，就必须在外部类对象存在的状况下使用。
基本语法是
<外部类类名>.<内部类类名> 引用变量名称 = <外部类对象的引用>.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();
}
}
在外部类以外访问内部类时须要注意权限修饰符的限制，这点和类成员同样。
三、内部类编译后生成的.class文件名称格式是<外部类类名>$<内部类类名>。

四、内部类与外部类之间的成员互相访问
内部类能够访问外部类的任何成员，包括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方法，所以咱们不能运行它。
多继承	抽象方法能够继承一个类和实现多个接口	接口只能够继承一个或多个其它接口
速度	它比接口速度要快	接口是稍微有点慢的，由于它须要时间去寻找在类中实现的方法。
添加新方法	若是你往抽象类中添加新的方法，你能够给它提供默认的实现。所以你不须要改变你如今的代码。	若是你往接口中添加方法，那么你必须改变实现该接口的类。