三个修饰符的作用：提高程序运行性能，优化程序结构

static

static表示"静态" ,“共享”, “全局”, “属于类的” 只能修饰方法和变量和内部类（相当于外部类）

1.修饰成员变量

1.1 引用成员变量的方式建议使用className.var。

1.2 表示类的所有实例共享此变量且可以修改，并且继承A的子类的实例也可以修改变量

用法：

class A{ //非静态成员变量每new出一个实例就在实例的堆区域拷贝一份，互不影响 String name; //静态成员变量属于类，在编译时就将此变量 static int age; //类的方法存在静态存储区（包含类的定义等信息），每个实例在堆里有一个方法的指向，当age使用static修饰时，jvm会将静态变量存放至静态存储区 void M1(){}; void M2(){}; static void main(args){ A a= new A(); }

例子：

public class staticA { static int a=0; int b=1; void M1(){ System.out.println("a:"+a); } public static void main(String args[]){ staticA a= new staticA(); a.M1(); a.a=2; a.M1(); } } 测试：

public class teststaticA extends staticA{ public static void main(String args[]){ teststaticA a=new teststaticA(); a.M1(); a.a=10; a.M1(); teststaticA.a=11; a.M1(); } } 结果：

a:0 a:10 a:11

从内存优化角度看，上面的方法虽然优化了内存，但有个问题，就是每个对象对静态成员变量修改会影响其他对象，可以将成员变量设置成private，在类的构造函数对变量操作，例如

class A{ //类外部无法访问此变量 private static int i; A(){ //每实例化一个对象值自增，A所有实例对象共享此变量 i++; } }

2.修饰成员方法

类的方法本来即是存放在类定义中的（内存静态存储区域），static修饰成员方法可以使用classname.method(),避免了new对象的资源消耗。

2.1 static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。

2.2 静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字

2.3 静态的方法可以被继承，但是不能重写。如果父类中有一个静态的方法，子类也有一个与其方法名，参数类型，参数个数都一样的方法，并且也有static关键字修饰，那么该子类的方法会把原来继承过来的父类的方法隐藏，而不是重写。

父类

public class father { int i; public static void m2() { System.out.println("m2"); } } 子类

public class child extends father { public static void main(String args[]) { child child = new child(); child.m1(); } public static void m2(){ System.out.println("子类的静态同名方法隐藏了父类m1"); } }

3.修饰代码块

静态代码块是独立于类成员的语句块，不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次，初始化时首先初始化静态块然后普通类成员初始化然后是静态方法（classname.mthod方式调用静态方法则会在实例初始化完成之前执行），最后是实例

例子：

class Book { public Book(String msg) { System.out.println(msg); } } public class staticblock { Book book1 = new Book("book1成员变量初始化"); // static {或者这样写 // book2 = new Book("static成员book2成员变量初始化"); // book4 = new Book("static成员book4成员变量初始化"); // } // 静态代码块 static Book book2 = new Book("static成员book2成员变量初始化"); public staticblock(String msg) { System.out.println(msg); } Book book3 = new Book("book3成员变量初始化"); // 静态代码块 static Book book4 = new Book("static成员book4成员变量初始化"); public static void funStatic() { System.out.println("static修饰的funStatic方法"); } public static void main(String[] args) { staticblock.funStatic(); System.out.println("****************"); staticblock p1 = new staticblock("p1初始化"); } }

4.静态导包

package com.a.b; public class c{ public static void m(Object o){ System.out.println(o); } } 采用static导入包后，在不与当前类的方法名冲突的情况下，无需使用“ 类名.方法名”的方法去调用类方法 //import all method import static com.a.b.c.*; public class t { public static void main( String[] args ) { m("Hello World!"); } /**Output * Hello World! }

final

final修饰符表示“终态”“不可修改”的含义，可以修饰类，成员变量，方法（锁定方法）。

1.修饰类

final修饰的类不可以被继承，finalclass表示这个类不会再被改变，也不允许其他类进行操作，不希望有子类，final类没有可扩展性。

final类成员方法都会被默认指定final关键字，成员变量可以自己定义。

2.修饰方法

final把方法锁定，防任何继承类修改它的含义，final方法可以被继承不可被重写/覆盖。

类的private方法会隐式地被指定为final方法。

例子

public class father { int i; public void m1() { System.out.println("m1"); } public final void m3() { System.out.println("m3"); } }

子类

public class child extends father { public static void main(String args[]) { child child = new child(); child.m3(); } public void m1(){ System.out.println("子类覆盖了了父类的普通m1方法"); } public void m3(){ System.out.println("程序报错，无法覆盖父类final方法"); } }

3.修饰变量。（常量的含义）

3.1 对于一个final变量，如果是基本数据类型（int char String等）的变量，则其数值一旦在初始化之后便不能更改（每个实例的变量而言）； final作用于类的成员变量时，类成员变量（局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，旦被初始化赋值之后，就不能再被赋值。

例子

class test{ final int i=0; final String="aaa"; void test(){ i=2;//error final Object obj=new Object(); obj=new Object();//error } void m1(){ final int a;//可以在使用的时候赋值 } }

如果没有在初始化时赋值则可以在构造函数赋值

public class father { final int i; public father(int b){ i=b; } public void m1(int a) { System.out.println("m1:"+i); final int aa = a; System.out.println("m1:"+aa); } public static void m2() { System.out.println("m2"); } public static void main(String args[]){ father father=new father(77); father.m1(88); father father1=new father(66); father1.m1(99); } }

3.2 final变量是个常量，编译器会把它当做编译期常量使用使用到变量的地方会直接替换，非final变量则是在运行时通过链接访问。

例子

public class testvar { public static void main(String[] args) { String a = "hello2"; //对象引用变量a放在栈中，字符串放在字符串池，a指向它 String f="hello2";//f和a指向一个地址所以相等 System.out.println(a==f);//true String aa=new String("hello2"); String ff=new String("hello2"); System.out.println(aa==ff);//flase final String b = "hello";//常量 String c = b + 2; //常量，c指向字符串池的hello2 System.out.println((a == c));//true String d = "hello";//d指向hello String e = d + 2;//字符串对象相加会生成新的字符串对象，而不是查找字符串池，所以对象的引用不同 //==对基本类型的变量比较的是值，引用类型的变量存储的并不是 “值”本身，而是于其关联的对象在内存中的地址 System.out.println((a == e));//false } }

3.3 如果是引用类型的变量（maplist），则在对其初始化之后便不能再让其指向另一个对象，但对象内容可变。

public class testvar { final List<String> list=new LinkedList<String>(); public static void main(String[] args) { testvar r=new testvar(); r.list=new LinkedList();//error r.list.add("a"); r.list.add("b"); Iterator<?> i=r.list.iterator(); while(i.hasNext()){ System.out.println(""+i.next()); } }

static-final

static作用于成员变量用来表示只保存一份副本（内存栈中）每个对象共享这个变量，而final的作用是用来保证变量不可变（每个对象的变量值可以在实例化的时候赋值，每个对象的变量值可以不同）

例子

public class testfinal { public static void main(String[] args) { MyClass myClass1 = new MyClass(); System.out.println(myClass1.i); System.out.println(myClass1.j); System.out.println(myClass1.k); myClass1.i++;//error.每个实例可以保存有不同的final变量值，但一旦赋值无法修改 myClass1.j++;//每个对象都可对static的变量修改 myClass1.k++;//error 实例化赋值之后，实例无法对final修饰的成员变量修改 MyClass myClass2 = new MyClass();//成员变量j的值是myclass1实例化后赋的的值 System.out.println(myClass2.i); System.out.println(myClass2.j); System.out.println(myClass2.k); } } class MyClass { public final double i = Math.random(); public static double j = Math.random();//MyClass实例化后得到的j值保存在栈中，被所有实例共享 public static final double k = Math.random(); //public static double j ; public MyClass(){ //j = Math.random();//每个实例化都会改变j值，并且这个j值会被Myclass的所有实例共享 } }

static final static-final变量初始化机制

static变量在类加载的时候就会赋值，如果是static int a;则会在静态区给一个初始值0，之后可以修改,不能通过构造方法或非静态块来进行初始化,从设计角度来考虑,如果可以通过构造方法或非静态块来进行初始化,那每new一个对象都会对静态的常量进行再一次的赋值操作,也就是说修改它的值,

final变量在实例化的时候赋值即可，类加载的时候不会赋初始值，final int a;是个空final必须要实例化的时候赋值才能使用

例子

public class testmemberinnerclass { private final int a;//空final private static int b; private static final int c;//final修饰的不会初始赋值 static { c=0; } public testmemberinnerclass(int j,int l){ a=j; System.out.println("构造a:"+a); b=l; System.out.println("构造b:"+b); } public class innerclass { void m2_inner(int i, int k) { b = k; System.out.println("inner class a:" + a); System.out.println("inner class b:" + b); } } public static void main(String args[]) { System.out.println(""+b); System.out.println("对象outer1"); testmemberinnerclass outer = new testmemberinnerclass(10,11); innerclass inner = outer.new innerclass();// 必须通过包含内部类的外部类去访问内部类 inner.m2_inner(4, 5); System.out.println("对象outer2"); testmemberinnerclass outer1 = new testmemberinnerclass(20,21); innerclass inner1 = outer1.new innerclass();// 必须通过包含内部类的外部类去访问内部类 inner1.m2_inner(4, 5); } }

结果：

0 对象outer1 构造a:10 构造b:11 inner class a:10 inner class b:5 对象outer2 构造a:20 构造b:21 inner class a:20 inner class b:5