一直依赖都比较模糊，今天早上看了几个帖子总结一下，供自己和大家参考，如果有不对的地方还请大家指点。
先说一下static
static 可以是变量、方法、内部类（类不能为static型）
1、static变量
类装载时只分配一块存储空间，所有此类的对象都可以操控此类的存储空间。
static 变量优于任何非static变量初始化，而且只初始化一次， static代码块也只会初始化一次。
静态变量可以直接访问
2、static方法
无需实例化类即可使用(类名、方法名)，方法内部不能用this,super关键字， 不能访问所属类的实例变量和实例方法，只能访问所属类的静态变量和静态方法。static方法独立于任何实例， 并且不能为 abstract抽象方法。
举例：
public class TestStatic {
private static String staticValue = "";
@SuppressWarnings("unused")
private String value;
public TestStatic() {
super();
}
@SuppressWarnings("static-access")
public static void main(String []args) {
//直接使用 类名.静态方法名()
System.out.println("TestStatic.staticValue");
TestStatic.setStaticValue("static value");
TestStatic t1 = new TestStatic();
TestStatic t2 = new TestStatic();
//t1, t2存取到的值应该是一样的
System.out.println("from t1:staticValue=" + t1.getStaticValue()
System.out.println("from t2:staticValue=" + t2.getStaticValue());
//通过对象t1改变static变量
System.out.println("t1.staticValue");
t1.setStaticValue("t1");
//t1, t2存取到的值应该是一样的
System.out.println("from t1:staticValue=" + t1.getStaticValue());
System.out.println("from t2:staticValue=" + t2.getStaticValue());
//通过对象t2改变static变量
System.out.println("t2.staticValue");
t2.setStaticValue("t2");
//t1 受到影响
System.out.println("from t1:staticValue=" + t1.getStaticValue());
}
public static String getStaticValue() {
return staticValue;
}
public static void setStaticValue(String staticValue) {
//直接通过 类名.静态变量 存取
TestStatic.staticValue = staticValue;
}
public String accessStaticValue () {
value = staticValue; //普通的方法可以存取static 方法或 static变量
return staticValue;
}
}
final 可以变量、方法、类
根据程序上下文环境，
Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。
final方法不能被子类的方法覆盖，但可以被继承。
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。
final不能用于修饰构造方法。
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
1、final变量
一旦初始化就不能改变，基本类型的值不可改变，对象变量的引用不可以改变。final变量初始化的位置 一般位于定义处或者构造函数中。final方法中的final参数，值也不会改变。
2、final方法
不能被覆盖，主要作用就是把方法锁定，防止任何可继承该类的子类改变它的实现。
3final 类
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; 出错,已经给赋过值了.
}
}
this和super
this只当前对象， 尤其是区分 形参和类的属性时
super只的是父类
举例：
class Person{
public static void prt(String s){
System.out.println(s);
}
Person(){
prt("A Person.");
}
Person(String name){
prt("A person name is:"+name);
}
}
public class Chinese extends Person{
Chinese(){
super(); //调用父类构造函数（1）
prt("A chinese.");//(4)
}
Chinese(String name){
super(name);//调用父类具有相同形参的构造函数（2）
prt("his name is:"+name);
}
Chinese(String name,int age){
this(name);//调用当前具有相同形参的构造函数（3）
prt("his age is:"+age);
}
public static void main(String[] args){
Chinese cn=new Chinese();
cn=new Chinese("kevin");
cn=new Chinese("kevin",22);
}
}
final static 变量、成员方法
变量一旦给复制就不能修改并且可以通过类名直接访问
方法不能覆盖，可以通过类名直接访问