1. 程式人生 > >(java)面向物件 ---- final

(java)面向物件 ---- final

(1)關鍵字final

     1)final 修飾類  :最終類   不能被繼承    但是使用方式沒有變化,可以建立物件,呼叫方法。

     2)final修飾方法    :父類中被final修飾的方法,在子類中不能被重寫,但可以繼承使用

     3)final修飾區域性變數   : 

                                final  int  i = 11;// 被final修飾,一次賦值,終身不變

                                final修飾引用變數,變數儲存記憶體地址,終身不變

    4)final修飾成員變數   : 

/*
 *final修飾成員變數 固定的不是記憶體的預設值,固定的是手動賦值
 *

 * 成員變數的兩種賦值方式:
 * (1)定義的時候直接賦值   
 * (2)採用構造方法賦值  (成員變數需要在建立物件前賦值,構造方法是建立物件中的事情)
 * 
 * 被 final 修飾的成員變數,只能被賦值一次
 */
public class Person {
// 1.直接賦值
	final int i= 10; 
// 2.構造方法賦值
//	final int age; 
//	public Person(int age){
//		this.age = age;
//	}
}

(2)關鍵字static

/*
 *   定義Person類
 *   定義物件的特有資料,和物件的共享資料
 *   
 *   物件的特有資料(非靜態資料)    呼叫者只能是  new 物件
 *   物件的共享資料(靜態資料)  呼叫者可以是new 物件,也可以是類名
 */
public class Person {
	
	String name;
	static int i = 100;
	
}

public class Test {

	public static void main(String[] args) {
		
		Person p1 = new Person();
		Person p2 = new Person();
		
		p1.name = "luo";
		p2.name = "zhang";
		p1.i = p1.i - 20;
		
		System.out.println(p1.name);     // luo
		System.out.println(p1.i);        // 80
		System.out.println(Person.i);    // 靜態變數直接使用    類名.  呼叫 
		
		System.out.println(p2.name);	 // zhang
		System.out.println(p2.i);        // 80

	}

}

【static的記憶體圖】

 

static注意事項:

  成員變數屬於物件的,靜態變數屬於自己的類的

1)靜態不能呼叫非靜態(因為生命週期,靜態優先於非靜態儲存於記憶體中)

2)靜態不能寫this 、super

3)靜態常量宣告:public  static  final  String/int......變數名(大寫)

4)static 修飾成員變數,成員方法

5)靜態屬於類,不屬於物件(物件的多型性)

【匿名物件】

public static void main(String[] args) {
		
		// 有名字的物件,引用型別變數,可以反覆使用
		Fu fu = new Fu();
		fu.fun1();
		
		// 1.匿名物件,沒有引用型別變數,只能使用一次
		new Fu().fun1();
		
		// 2.匿名物件可以當做引數
		method(new Fu());
		
		// 3.Fu型別可以當做返回值型別
		Fu p = method();
		p.fun1();
	}
	// 方法返回值型別是Fu型別
	// 方法return 的是這個型別的物件
	public static Fu method(){
		return new Fu();
//		Fu p = new Fu();
//		return p;
	}
	
	public static void method(Fu fu){
		fu.fun1();
	}

【內部類的呼叫】

/*
 *  將內部類定義在了外部類的    【成員位置】
 *  外部類Outer  內部類Iner
 *  
 *  成員內類,可以使用成員修飾符 public static...
 *  也是個類 ,可以繼承,實現介面
 */
public class Outer {
	int i = 1;
	private int a = 1;
	
	/*
	 *  定義內部類
	 *  呼叫規則:
	 *    內部類  可以使用  外部類  成員,包括私有
	 *    外部類  使用  內部類成員,必須建立內部類物件
	 */
	 class Iner{
		 int i = 2;
		 public void inner(){
			 int i = 3;
			 /* 
			  * 成員 內部類 的同名變數呼叫 
			  *  System.out.println("內部類"+ Outer.this.i); //列印的是   :內部類1  訪問的是Outer類的成員變數
			  *  System.out.println("內部類"+ this.i);       //列印的是   :內部類2   訪問的是Iner類的成員變數
			  */
			 System.out.println("內部類"+ i);               //列印的是   :內部類3
		 }	
	}
}

/*
 * 成員內部類測試
 */
public class Test {

	public static void main(String[] args) {
		/*
		 *  呼叫外部類中 內部類的 inner方法
		 *  格式:
		 *  外部類名.內部類名  變數 = new 外部類物件(). new 內部類物件();
		 *  變數.內部方法();
		 */
		Outer.Iner oi = new Outer().new Iner();
		oi.inner();
	}
}

【區域性 內部類】

public class Outer {
	
	public  void  out(){
		// 區域性 內部類
		class Iner{
			public void iner(){
				System.out.println("區域性內部類 方法");
			}
		}
	    
		Iner in = new Iner();
		in.iner();
	}

}

public class Test {

	public static void main(String[] args) {
		// 呼叫區域性內部類的方法
		new Outer().out(); // 列印結果:區域性內部類 方法  
		
	}

}

【匿名內部類】

匿名內部類,簡化問題:定義實現類,重寫方法,建立實現物件,合為一步完成。

public interface Smoking {
	public abstract  void smoking();

}
/*
 *   介面 實現類
 *   public  class  XXX implements Smoking{
 *   	// 重寫抽象方法
 *   	public void  smoking(){ 
 *      }
 *   }
 * 
 *  // 建立XXX物件
 *   XXX  s = new XXX();
 *   s.smoking();
 *  // 多型
 *   Smoking s1 = new XXX();
 *   s1.smoking();
 */

public class Test {
	/*
	 *  匿名內部類
	 *    定義實現類,重寫方法,建立實現物件,合為一步完成。
	 *  格式:
	 *    new 介面或父類(){
	 *    	重寫抽象方法
	 *    };
	 *   從new 到分號結束   這部分程式碼相當於  建立了實現介面類的物件
	 */
	public static void main(String[] args) {
		
		new Smoking(){
			public void smoking(){
				System.out.println("人在吸菸");
			}
		}.smoking();

        //		Smoking s = new Smoking(){
//			public void smoking(){
//				System.out.println("人在吸菸");
//			}
//		};
//		s.smoking();
    }
}

【許可權修飾符】

注意:protected許可權第三種使用方法:有A、B兩個類分別在不同的包(package),B繼承A,A中protected的方法,只能在B裡面使用(B類物件不能呼叫)。

【程式碼塊】

靜態程式碼塊,只執行一次

構造程式碼塊,new一次,就執行一次,優先於構造方法

構造方法,new一次,就執行一次