技術標籤：java

1.static \ this \ super \ final 關鍵字的用法

1.static--靜態的【提前分配記憶體】

修飾的變數就是靜態成員變數【類變數】，可以用類名訪問，也可以用物件訪問
修飾的方法就是靜態方法【類方法】，可以用類名訪問，也可以用物件訪問
例如:

package com.wangxing.staticdemo1;
//static---關鍵字【被賦予特殊含義的單詞】
//含義：靜態的【提前分配記憶體】
//位置：1.變數資料型別前面【成員變數】---靜態成員變數【類變數】
//      靜態成員變數【類變數】命名時：變數名稱全字母大寫
//      例項變數命名時：變數名稱全字母小寫
//    2.方法的返回值前面----靜態方法【類方法】
public class TestStatic {
	//1.變數資料型別前面【成員變數】----靜態成員變數【類變數】
	//靜態成員變數【類變數】命名時：變數名稱全字母大寫
	public static String NAME="zhangsan";
	public String name="小趙";
	//2.方法的返回值前面---靜態方法【類方法】
	public static void staticMethod(){
		System.out.println("");
	}
	
	 //1.靜態成員變數【類變數】/靜態方法【類方法】可以使用類名呼叫，也可以用物件呼叫
	public void shiliMethod(){
		//類名訪問類變數
		System.out.println("TestStatic.NAME=="+TestStatic.NAME);
		//物件訪問類變數
		System.out.println("t1.NAME=="+new TestStatic().NAME);
	}
	 //2.靜態成員變數【類變數】可以在同類物件之間共享資料
	 //（同類物件即指建立物件時用不同的變數名稱儲存相同的物件。然後改變其中一個物件的資料，剩下的都會跟著改變，這就是資料共享）
	
	/*
	 * 3.靜態方法【類方法】不能出現this關鍵字
	public static void staticMethod2(){
		System.out.println("this.NAME=="+this.NAME);
	}
	*/
	
	/*
	 * 4.靜態方法【類方法】中不能訪問例項變數/例項方法
	public static void staticMethod2(){
		System.out.println(name);
		System.out.println(Lei.name);
		Lei.shiliMethod();
	}
	*/
}
 

//測試類
package com.wangxing.staticdemo1;
public class TestMain {

	public static void main(String[] args) {
		TestStatic t1=new TestStatic();
		TestStatic t2=new TestStatic();
		t1.shiliMethod();
		System.out.println("=========================");
		//靜態變數可以在同類物件之間共享資料
	   System.out.println("t1.NAME=="+t1.NAME);
 	   System.out.println("t2.NAME=="+t2.NAME);
 	   t1.NAME="lisi";
 	   System.out.println("t1.NAME=="+t1.NAME);
 	   System.out.println("t2.NAME=="+t2.NAME);		
	}
}
 

總結：1.靜態成員變數【類變數】/靜態方法【類方法】可以使用類名呼叫，也可以用物件呼叫
2.靜態成員變數【類變數】可以在同類物件之間共享資料（一個改變賦的值，其他的都會跟著改變，資料是共享的）
3.靜態方法【類方法】不能出現this關鍵字
4.靜態方法【類方法】中不能訪問例項變數/例項方法

2.this---本類物件【出現在哪一個類中就表示哪一個類的物件】

1.本類中呼叫本類的例項變數\類變數\例項方法\類方法，可以省略
2.this是不能出現在靜態方法中
例如:

package com.wangxing.test1;
//this--關鍵字【當前類的物件】
//this出現在哪一個類中就表示哪一個類的物件
public class TestThis {
	//例項變數
	public  String  testname="TestThis例項變數";
	/*
	public  TestThis(){
		System.out.println("無引數構造方法");
	}
	*/
	public  TestThis(String name){
		System.out.println("有引數構造方法，引數是name=="+name);
	}
	public  TestThis(int name){
		System.out.println("有引數構造方法，引數是name=="+name);
	}
	//例項方法
	public void  shiliMethod(){
		//在這個例項方法中使用一下當前類TestThis這個類的物件
		    TestThis  tt1=new TestThis(); //當前類TestThis這個類的物件
		//我們要在TestThis這個類中的例項方法中訪問當前類的例項變數
		//例項變數只能通過物件訪問
		    System.out.println(new TestThis().testname);
		    System.out.println(tt1.testname);
		//this--當前類的物件
		//this===new TestThis(); 等價
		//同一個類中例項方法訪問例項變數，預設this.例項變數，this可以省略
		    System.out.println(this.testname);
		    System.out.println(testname);
	}
 

總結：因為類中的變數【不包括區域性變數】和方法【不包括構造方法】，可以通過物件訪問
那麼我們在訪問類中的變數和方法是，就需要先建立物件
1.本類之外的其他類中，我們建立物件new 構造方法()
2.本類中，我們建立物件new 構造方法()，本類中new 構造方法()建立物件可以用this代替
這時我們認為本類的物件就是this
所以在本類中訪問本類的變數和方法使用this是可以的
java程式=物件+訊息（資訊就是指訪問，我要訪問你，給你發個資訊）

3.super--子類中表示父類物件

1.子類中訪問父類構造方法“super([引數])”。
2.子類中訪問父類的例項方法/例項變數”super.例項變數/例項方法”。
例如:

package com.wangxing.test1;
//super---父類物件
//位置:子類中
//構造方法--super([引數]);在子類中訪問父類的構造方法
//          --super.變數/方法;在子類中訪問父類的變數/方法[super==父類物件]  
//例項方法--super.變數/方法;在子類中訪問父類的變數/方法[super==父類物件]
//類方法--不能出現super關鍵字
//注意:預設我們雖創建出來的java類會繼承java.lang.Object
//java.lang.Object表示一個物件類【一切皆物件】
public class TestSuper {
//無參構造方法
	public  TestSuper(){
		super();
		new Object().getClass();
		//super===》new Object()---父類物件
		super.getClass();
	}
//有參構造方法
	public  TestSuper(String  name){
		super();
	}
//例項方法	
	public void  shiliMethod(String  name){
		//super();
		new Object().getClass();
		//super===》new Object()---父類物件
		super.getClass();	
	}
//類方法	
	public static  void  staticMethod(String  name){
		//super();
		new Object().getClass();
		//super.getClass();
	}
}

4.final---最終的

1.final修飾的變數不能被重新賦值。
2.fianl修飾的靜態成員變數叫靜態常量。【靜態常量全字母大寫】
例如: public final static String TEXT="java";
3.final修飾的方法不能被重寫。
4.final修飾的類不能被繼承，沒有子類。
例如:

//父類
package com.wangxing.finaldemo1;
//final---最終的
//final可以修飾java類，沒有子類  （即不能被繼承）
//final可以修飾java類中的方法，可以繼承，不能被重寫
//注意：抽象類/介面中的抽象方法不能使用final修飾
//final可以java類中的變數， 修飾後不能被修改【即常量】

//The type SunFinal cannot subclass the final class TestFinal
//public final class TestFinal {

public class TestFinal {
	public final String name="zhangsan";
	public static final String NAME="waangwu";
	//final修飾java類中的方法，可以被繼承但是不能被重寫
	public final void test1(){
		System.out.println("父類的方法");
	}
	public void test2(){
		final String testname="lisi";
		System.out.println("testname=="+testname);
		//final修飾的變數不能在修改
		//testname="wangwu";
	}
}

//子類
package com.wangxing.finaldemo1;
public class SunFinal extends TestFinal {
	//不能重寫被繼承的final修飾的方法
	/*Multiple markers at this line
	   - overrides  覆蓋
	  com.wangxing.finaldemo1.TestFinal.test1  位置*/

	/*public void test1(){
		System.out.println("子類重寫父類的方法");
	}*/
}

//測試類
package com.wangxing.finaldemo1;
public class TestMain {

	public static void main(String[] args) {
		//建立一個子類物件
		SunFinal sf=new SunFinal();
		sf.test1();
		//建立一個父類物件
		//final修飾的變數是常量，不能修改
		TestFinal tf=new TestFinal();
		System.out.println(tf.name);
		//tf.name="lisi";
		System.out.println(TestFinal.NAME);
		//TestFinal.NAME="wangxing";
	}

}