疯狂java学习笔记之面向对象(八) - static和final

一、static：

　　1、static是一个标识符：

　　　　- 有static修饰的成员表明该成员是属于类的;

　　　　- 没有static修饰的成员表明该成员是属于实例/对象的。

　　2、static修饰的成员(Field、方法、初始化块),与类共存亡；static修饰的成员建议总是通过类名来访问,虽然它也可以通过实例来访问(实质也是通过类来访问的),所以平时若在其他程序中见到通过实例/对象来访问static成员时,可以直接将实例/对象 替换成类名；

　　3、程序都是先有类再有对象的,有可能出现有类但没有实例/对象的情况,反过来绝对不可能出现有实例/对象却没有类的现象。

　　4、类加载时会把属于类的Field存放到永生代堆内存中。

　　规则：

　　A、static修饰的成员不允许访问非static成员,非static成员可以访问static成员;

　　B、this引用、super都丕允许出现在static成员中;

　　C、若Field是实例/对象的,相当于前面省略了this.  , 若Field是类的则相当于前面省略了类名.

注意点:若自己写程序永远都不要使用对象/实例去调用static修饰的方法、Field，若看到其他程序出现实例/对象去调用static修饰的方法、Field，我们阅读时则先把对象换成类名.

 public class TestStatic{
     private int age;
     private String name;
     private static String gender;
     private double weight;

     public void test(String name){
         System.out.println("他/她叫: " + name);
     }

     public static void main(String[] args){
         TestStatic ts = new TestStatic();
         ts.test("小猴子");
         //通过对象ts来访问static成员,可以替换成类名.gender
         //因为gender是string引用变量且属于成员变量,若程序员没给它赋初始值,系统会默认给个null值它
         System.out.println(ts.gender);
         System.out.println(TestStatic.gender);
     }
 }

 public class TestStatic2{
     static int count = 99;
     int age;
     {
         age = 22;
         test();
     }

     static{
         test();
         //age = 13; //static成员不能访问非static成员
     }

     public void way(){
         System.out.println("age值为: " + age);
     }

     public static void test(){
         //static方法引用了非static修饰的age,报错
         //System.out.println("age的值为: " + age);
         System.out.println("~~这是一个test方法~~");
     }

     public static void main(String[] args){
         //定义了一个t2引用变量但t2并未指向任何对象
         TestStatic2 t2 = null;
         TestStatic2 t3 = new TestStatic2();
         //对于static修饰的Field、方法,直接打印时相当于前面省略了类名
         System.out.println(count);  //t2.count
         //成员变量前必须有主调对象且有static修饰的方法不能直接访问没有static修饰的变量
         System.out.println(t3.age);    //t3.age;
     }
 }

二、final：

　　final作为一个修饰符,只能修饰:变量、方法和类。

　　1、final修饰变量

　　　　--final修饰的变量只能被赋值一次且赋值后不可改变。

　　　A、final修饰成员变量：

　　　　Java成员变量默认可以由系统执行初始化,程序员可以不指定初始化,但final修饰的成员变量必须由程序员执行初始化

　　　　[原因]:如果final修饰的成员变量由系统执行初始化,那它的值只能是0、0.0、null、false、\u0000,且还不能改变,那么该变量则会变得毫无价值

　　　　若final修饰【实例变量】,可以在以下3个地方指定初始值：

　　　　　①、定义时指定初始值；

　　　　　②、初始化块中指定初始值；

　　　　　③、构造器中指定初始值。

　　　　注意：final修饰的变量只能指定一次初始值且普通方法是不允许为final实例变量赋值的。

 public class TestFinal{
     //final修饰实例变量必须指定初始值且只能在定义时、初始化块、构造器中指定。
     final int age = 20;
     final double weight;
     /*
     {final修饰的变量只能被赋值一次。
         weight = 150;
     }*/

     {
         System.out.println("~~实例初始化块~~");
     }

     public TestFinal(){
         weight = 140;
     }

     /* 普通方法不能为final修饰的变量赋值
     public void setWeight(){
         this.weight = weight;
     }*/

     public static void main(String[] args){
         TestFinal tf = new TestFinal();
         //实例变量必须拥有主调者
         System.out.println(tf.weight);
     }
 }

　　　　若final修饰【类变量】,只可以在以下两个地方指定初始值:

　　　　　①、定义时指定初始值;

　　　　　②、类初始化块中指定初始值。

　　　B、final修饰局部变量:

　　　　Java的局部变量默认就必须由程序员来指定初始值。

　　　　final修饰局部变量后,只有【一个变化】：一旦赋值后就不能再改变了。

 public class TestFinal3{
     public static void main(String[] args){
         final int age;
         age = 12;
         System.out.println(age);
         //final修饰age后,age只能赋值一次,否则报错"可能已分配变量age"
         //age = 22;
         //System.out.println(age);
     }
 }

　　　C、final修饰的变量，它会被执行“宏替换”。如果final修饰的变量，可以【在编译的时候就确定】它的值，那么这个【变量就不存在】“宏替换” -- 就是查找、替换

 public class  FinalConstant {
     public static void main(String[] args) {
         String s1  =  new String("疯狂java");
         String s2  =  new String("疯狂java");
         System.out.println(s1  ==  s2);  //false

         //JVM会把所有用过的String对象进行缓存
         String s3  =  "fkjava.org";
         String s4  =  "fkjava.org";//第二次用的是缓存中的fkjava.org对象
         System.out.println(s3  ==  s4);  //true

         //由于+前后的值都是"直接量"，可以直接计算
         String s5  =  "疯狂"  +  "软件";
         //在编译的时候,编译器已经把"+运算"计算出来,由于+前后的值都是"直接量",可直        //接计算
         String s6  =  "疯狂软件"    ;//JVM在编译时就自动去掉+号
         //s5、s6两个引用变量是否相等【必须指向同一个对象才相等】。
         System.out.println(s6  ==  s5);  //true

         String s7  =  "疯狂";
         String s8  =  "java";
         //由于s7、s8都是变量，他们的值只有在运行时才能确定下来
         //因此s9、s10的值只能在运行是动态的确定,都不会缓存，因此无法直接使用缓存中的值
         String s9  =  s7  +  s8;
         String s10  =  s7  +  s8;
         System.out.println(s9  ==  s10);

         /*
         final String s11 = "fkjava";
         final String s12 = ".org";
         String s13 = s11 + s12;
         String s14 = s11 + s12;
         System.out.println(s13 == s14);  //true */

         // final修饰的变量，【声明时就指定了初始值】,但他们的初始值在编译时不能确定,        //所以不能执行宏替换,所以s11、s12只有在运行时才能确定
         final String s11 = s9; //s11的字符序列是：疯狂java
         final String s12 = s10;//s12的字符序列是：疯狂java
         String s13 = s11 + s12;
         String s14 = s11 + s12;
         System.out.println(s13 == s14);  //false

         //final修饰的变量，【声明时就指定了初始值】，【而且初始值在编译就可以确定】
         //那么这个变量就不存在,s15/s16会执行“宏替换”，也就是这两个变量根本就不存        //在，所有出现s15的地方都会替换成"fkjava",s16替换成".org"
         //final String s15 = "fkjava";
         //final String s16 = ".org";
         /*String s17 = s15 + s16;
         String s18 = s15 + s16;*/

         String s17 = "fkjava" + ".org";
         String s18 = "fkjava" + ".org";
         System.out.println(s17  ==  s18);  //true

     }
 }

　　3、final修饰方法：

　　　final修饰的方法不能被重写@Override；

　　　好处:禁止父类的方法被重写,避免破坏父类方法

　　　注意点:final与private结合没有实际意义,两者存一即可(private本身就不能被重写)。

　　4、final修饰类:

　　　final类不能有子类,由于它不能有子类,所以它的方法能可以被更好的保护,典型的final类有:String、System、Math和包装类。