java_父類和接口的引用類型的代碼及其詳解_原創

今天學習了java中的一個知識點，很是重要，自己就把他做了一個詳細的註解，避免忘記！

主要是java中有關於抽象了和接口的引用類型變量保存子類或實現類得訪問的問題，好了，其它的廢話不多說了，直接看代碼，和代碼的詳細註解！

以下代碼都是通過eclipse編輯和運行通過的

下面是接口A.java的代碼

/**
 * 抽象類A，中有抽象方法，普通方法和成員變量
 * */

package com.zj.inter;

public abstract class A {
	//成員變量
	public int i = 20;
	public String name = "小米";

	//抽象類
	public abstract void m1();

	//普通方法
	public void m2() {
		System.out.println("A.m2()..");
	}

	public void m3() {
		System.out.println("A.m3()..");
	}
}

下面是接口Inf1.java的代碼

/**
 * 接口Inf1，有抽象方法m4()
 * */
package com.zj.inter;

interface Inf1 {
	//抽象方法m4()
	public abstract void m4();
}

下面是接口Inf2.java的代碼

/**
 * 接口Inf2，有抽象方法m5()
 * */
package com.zj.inter;

interface Inf2 {
	//抽象方法m5()
	public abstract void m5();
}

下面是接口B.java的代碼

/**
 * B類，繼承了抽象類A類，實現了接口Inf1和Inf2
 * */

package com.zj.inter;

public class B extends A implements Inf1, Inf2 {

	public int i = 3;//隱藏了A中的i
	public int j = 6;

	// 抽象類A中抽象方法的重寫
	@Override
	public void m1() {
		System.out.println("B.m1()..");
	}

	// 抽象類A中的普通方法的重寫
	public void m2() {
		System.out.println("B.m2()..");
	}

	// 接口Inf1中的抽象方法的實現
	@Override
	public void m4() {
		System.out.println("B.m4()..");
	}

	// 接口Inf2中的抽象方法的實現
	@Override
	public void m5() {
		System.out.println("B.m5()..");
	}

	/**
	 * fun1()是測試創建B的引用類型（B b = new B()）後，b所能夠訪問的成員
	 * */
	public void fun1() {
		
		B b = new B();//創建B的引用類型變量

		// B中的i隱藏了A中的i
		System.out.println("b.i = " + b.i);

		// 不是靜態，不能這樣訪問A中的i
		// System.out.println(b.A.i);

		System.out.println("b.name = " + b.name);
		System.out.println("b.j = " + b.j);//訪問的B類中的成員變量j

		b.m1();// B.m1().. B重寫A類中的抽象方法
		b.m2();// B.m2().. B中重寫A類中的m2()
		b.m3();// A.m3().. 調用A類中被繼承的普通函數
		b.m4();// B.m4().. B類中實現了Inf1中的接口
		b.m5();// B.m5().. B類中實現了Inf2中的接口
	}

	/**
	 * fun2():父類A的引用類型變量保存子類B的對象 此時引用類型變量訪問成員方法時只能訪問父類中出現的成員方法，如果引用 的對象所屬子類
	 * */
	public void fun2() {
		A a = new B();
		/**
		 * 成員變量的訪問與成員函數的訪問不同，成員變量不是公用的，是每個對象各自有一份，
		 * 故A的引用只訪問A的成員變量，不管子類或實現類得接口
		 * */
		System.out.println("a.i = " + a.i);// A中的i
		System.out.println("a.name = " + a.name);
		// 父類A的引用類型，只能訪問A中
		// System.out.println(a.j);

		/**
		 * A a = new B() A的引用類型保存子類的對象，使用引用類型訪問成員方法
		 * 時只能訪問A類中有的成員方法，如果A類中的成員方法在子類中有重寫的這訪問到的 是重寫的方法
		 * */
		a.m1();// B.m1()..
		a.m2();// B.m2()..
		a.m3();// A.m3().. 沒有重寫，訪問到的是父類的
		// a.m4();// A類中沒有m4()函數
		// a.m5();// A類中沒有m5()函數
	}

	/**
	 * 父類（接口）引用類型保存子類（實現類）的對象，使用引用類型訪問成員方法 時只能訪問父類（接口）中有的成員方法，如果父類（接口）中的成員方法在子
	 * 類（實現類）中有重寫，則這訪問到的是重寫的成員方法
	 * */
	public void fun3() {
		Inf1 inf1 = new B();

		/**
		 * 註釋了的不是接口Inf1中成員，故沒辦法通過Inf1創建的引用類型變量來訪問
		 * */
		// System.out.println(inf1.i);
		// System.out.println("inf1.name = "+inf1.name);
		// System.out.println(inf1.j);

		// inf1.m1();
		// inf1.m2();
		// inf1.m3();
		inf1.m4();// 只有在接口類中有的才能被訪問
		// inf1.m5();
	}

	public static void main(String[] args) {
		B b1 = new B();

		b1.fun1();// 調用fun1函數
		System.out.println("======1======");

		b1.fun2();// 調用fun2函數
		System.out.println("======2======");

		b1.fun3();// 調用fun3函數
		System.out.println("======2======");
		
	}

}

註冊CSDN還是有段時間了，自己學了的重新寫一遍還是很有必要的，以後常寫~~