Java常見關鍵字及其用法（上）

1. final
2. static
3. this
4. super

1.final（四種用法）

1.修飾局部變量（只能一次賦值，終生不變）

• 修飾基本數據類型：修飾的數據變量值不可變
• 修飾引用數據類型：地址值不可變，內容能夠變

注意事項：

1. 1 錯誤：

public static void main(String[] args) {
        final int c = 0;
        for (int i=0;i<10;i++)
        {
            c=i;                        //錯誤：沒法爲最終變量c分配值
        }
    }

1. 2正確：

public static void main(String[] args) {
        for (int i=0;i<10;i++)
        {
            final int c = 0;            //正確：局部變量，每次循環釋放掉
        }
    }

2. 修飾成員變量（變量的數據值不可變）

• 成員變量有默認值，final修飾後須要手動賦值
• 經過構造方法對final修飾的成員變量進行賦值，須要保證全部重載的構造方法對final修飾的成員變量進行賦值，保證其修飾變量的初始化

選其一：

public class Demo {
    private final String name = "桑鳳嬌";//直接賦值
    public Demo(){}
    }

public class Demo2 {
    private final String name ;
public Demo2()
	{
    		name = "桑鳳嬌";//經過構造方法賦值
	}
 public Demo2(String name) {
        this.name = name;//經過構造方法賦值
    }
}

3.修飾類

用final修飾的這個類不能有任何子類

注意：一個類若是是final修飾的，其中全部的成員方法都沒法進行覆蓋（由於沒有子類）

• 被final修飾的類，final類中的成員變量能夠根據本身實際須要設計成final
• final類中的成員方法都會被隱式指定爲final方法

修飾方法

用final修飾的方法不能被覆蓋（不能重寫：override）

2.static

static修飾的內容（隨類的加載而加載，且加載一次；存儲於固定的內存區域(靜態區)，因此直接用類名進行調用；優先於對象存在，因此能夠被全部對象共享）

修飾成員變量和成員方法，其中被修飾的成員都屬於類，而不是單單屬於某個對象，使用時用類能夠直接調用，而不須要建立對象

• 類變量定義格式：static int num = 10;（static 數據類型 變量名;）
• 類方法定義格式：public static 返回值類型 方法名(){ }

 

1. 沒有被static修飾的成員變量稱爲實例變量，實例變量屬於某個對象
2. 類方法使用及其注意事項：

使用：

• static修飾的方法都屬於靜態方法（類方法），使用類名.方法名調用
• 定義格式：public static 返回值類型 方法名（參數列表）{}

注意：

package com.day02;
/**
 * @author SFJ
 * @date 2019/11/8
 * @time 22:19
 **/
public class Test1 {
    private String name="桑鳳嬌";
    static String idCard ="3709211998092033**";
    public static void method1()
    {
        method2();//錯誤，靜態方法不能夠直接訪問非靜態成員方法
        new Test1().method2();//正確，靜態方法建立匿名對象訪問非靜態成員方法
        System.out.println(name);//錯誤，不能夠直接訪問非靜態成員變量
        System.out.println(idCard);//正確，能夠直接訪問靜態成員變量
    }
    public void method2()
    {
        System.out.println(idCard);//正確，非靜態方法能夠訪問靜態變量
        method1();//正確，非靜態方法能夠訪問靜態方法
    }
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        test1.method2();
    }
}

• 靜態方法不能直接訪問普通變量和成員方法，須要建立對象進行訪問
• 靜態方法能夠直接訪問靜態方法和靜態成員變量
• 在非靜態方法中能夠訪問靜態方法和靜態成員變量
• 在靜態方法中，不能直接使用super和this關鍵字

靜態代碼塊：

• 定義在類的內部，任何方法的外部
• 定義格式： static{}

主要做用是給類變量進行初始化賦值

3.this(表示對當前對象的引用)

• 區分同名的函數參數和成員變量（this.成員變量名=參數----最經常使用）
• 在構造方法中(this()或者this(參數列表)，只能引用一個構造方法且只能在第一句)
• 注意：this不能用在static修飾的方法中，由於static修飾的方法屬於類，而this指的是對對象的引用，衝突矛盾

• package com.day02;
  
  /**
   * @author SFJ
   * @date 2019/11/8
   * @time 22:53
   **/
  public class Test3 {
          private int i=0;
          Test3(int i) {//第一個構造器：有一個int型形參
              this.i = i + 1;//此時this表示引用成員變量ｉ，而非函數參數ｉ
              System.out.println("Int constructor i——this.i:  " + i + "——" + this.i);
              System.out.println("i-1:" + (i - 1) + "this.i+1:" + (this.i + 1));
              //從兩個輸出結果充分證實了i和this.i是不同的！
          }
          Test3(String s){ //  第二個構造器：有一個String型形參
              System.out.println("String constructor:  "+s);
          }
          Test3(int i,String s){//  第三個構造器：有一個int型形參和一個String型形參
              this(s);//this調用第二個構造器
              this.i=i++;//this以引用該類的成員變量
              System.out.println("Int constructor:  "+i+"/n"+"String constructor:  "+s);
          }
          public Test3 increment(){//增量
              this.i++;
              return this;//返回的是當前的對象，該對象屬於（Test3）
          }
          public static void main(String[] args){
              Test3 t0=new Test3(21);
              Test3 t1=new Test3("桑鳳嬌");
              Test3 t2=new Test3(21,"桑鳳嬌");
              System.out.println(t1.increment().increment().increment().i);
              //t0.increment()返回一個在t0基礎上ｉ++的Test3對象，
              //接着又返回在上面返回的對象基礎上i++的Test3對象！
          }
  
      }

   

4.super(表示父類的引用)

• 子父類存在着同名的成員（包括變量和方法）時，在子類中默認是訪問子類的成員，能夠經過super關鍵字指定訪問父類的成員；
• 建立子類對象時，默認會先調用父類無參的構造方法，能夠經過super關鍵字指定調用父類的構造方法：

1. 若是在子類的構造方法上沒有指定調用父類的構造方法，jvm會在子類的構造方法內加上super()語句
2. super關鍵字調用父類構造函數時，該語句必需要是子類構造函數中的第一個語句
3. super與this關鍵字不能同時出如今同一個構造函數中調用其餘的構造函數。由於兩個語句都須要第一個語句
4. 繼承中，只要建立子類對象，默認必定會先調用父類無參構造方法建立父類對象

   package com.day02;
   
   /**
    * @author SFJ
    * @date 2019/11/8
    * @time 23:08
    **/
   public class Test4 {
       public static void main(String[] args) {
           Son s = new Son(3);
           System.out.println();  //4   
       }
   }
   class Father {
       int x = 1;
       Father() {
           System.out.println("父類無參的構造方法");
       }
       Father(int x) {
           this.x = x;
           System.out.println("父類有參的構造方法");
       }
       void speak() {
           System.out.println("我是父類");
       }
   }
   class Son extends Father {
       int y = 1;
       Son() {
           System.out.println("子類無參的構造方法");
       }
       Son(int y) {
           this.y = y+x;
           System.out.println("子類帶參的構造方法");
       }
       void run() {
           super.speak(); //訪問父類的函數
           System.out.println("我是子類");
       }
   }