import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

class A {
	int x;
	static double y;
	char z;

	A(char z) {
		this.z = z; // this訪問成員變數，以區分同名引數
	}

	A(double newy, char newz) {
		double y = newy; // this訪問成員變數，以區分同名區域性變數
		char z = newz;
		this.y = y; // 因y是靜態成員變數，最好使用className.staticMemberVarName即A.y訪問
		this.z = z;
	}

	A(int a, double b, char c) {
		this(b, c);// 使用this(paramList)呼叫另一個構造方法必須放在第一句位置
		this.x = a;// 此處無法再使用this(x);理由同上
	}

	void OutPut() {
		if (this.equals(this))// this作為物件引用使用，當然此條件永遠=true
			System.out.println("我是類" + GetClassName() + "的方法"
					+ GetInvokeMethodName());
	}

	String GetClassName() {
		return this.getClass().getName();
	}

	String GetInvokeMethodName() {
		String TempName = new Exception().getStackTrace()[1].getMethodName();
		return TempName;
	}

	static void showStaticFieldValue(Object obj) throws Exception { //
		Field fields[] = obj.getClass().getDeclaredFields();
		String fieldName, fieldModifier, fieldType;
		Object val;
		for (int i = 0; i < fields.length; i++) {
			Field field = fields[i];
			if (field.toString().indexOf("static") != -1) {
				// System.out.println(field.toString());
				fieldName = field.getName();
				fieldType = field.getType().getName();
				fieldModifier = Modifier.toString(field.getModifiers());
				field.setAccessible(true);
				val = field.get(obj);
				System.out.println(fieldModifier + " " + fieldType + " "
						+ fieldName + " = " + val);
			}
		}
	}

	void getStaticFieldValue() {
		try {
			showStaticFieldValue(this);
		} catch (Exception e) {

		}
	}
}

class B extends A {
	static double x;// 隱藏超類A的成員變數x
	int y = (int) this.x + 1;// 隱藏超類A的成員變數y，有人說this必須在方法體中使用，無情的擊破其謠言。

	// 繼承了超類A的成員變數z，仍為char z;

	B(char c) {
		super(c);/*
				 * super(c)呼叫超類建構函式的目的在於初始化自然繼承的超類成員，若子類完全隱藏了超類的成員變數， 則可以不用super
				 * super(ParamList)訪問超類建構函式 疑問： 1.類B隱藏且改變了類A的成員變數，
				 * super(b)是否僅僅改變了B中包含的A物件的值， 而B中的static double x的值仍然為預設值?(待驗證)
				 * 2.java的構造方法屬於例項方法還是靜態方法？
				 */
		x = super.y + 1.0;// super訪問超類被隱藏的成員變數double y，也可以寫成A.y
		y = super.x;// super訪問超類被隱藏的成員變數int x
	}

	String GetClassName() {// 重寫超類A的GetClassName()
		return "類類類BBB";
	}

	String GetInvokeMethodName() {// 重寫超類A的GetInvokeMethodName()
		return "方法名稱方法名稱方法名稱";
	}

	void OutPut() { // 重寫超類的OutPut例項方法.
		System.out.println("super呼叫超類被重寫的兩個方法輸出：類名="
				+ super.GetClassName() + "，方法名=" + super.GetInvokeMethodName());// super呼叫超類的例項方法
		System.out.println("用類B的重寫方法輸出：類名=：" + GetClassName() + ","
				+ "，方法名="+GetInvokeMethodName());// 呼叫自己的方法
	}

	static void showStaticFieldValue(Object obj) throws Exception { // 隱藏超類的靜態方法
		System.out.println("static Field doulbe x=" + x);
	}

	void getStaticFieldValue() {
		try {
			System.out.println("super呼叫超類A的方法輸出靜態成員變數");
			super.showStaticFieldValue(this); // super呼叫超類被隱藏的靜態方法
			System.out.println("類B自己的方法輸出靜態成員變數");
			showStaticFieldValue(this);// 類B自己的方法
		} catch (Exception e) {
		}
	}
}

class Example3_15 {
	public static void main(String[] args) {
		A myA = new A(8, 6.0, 'k');
		B myB = new B('哦');
		myA.getStaticFieldValue();
		myA.OutPut();
		System.out.println("====================");
		myB.getStaticFieldValue();
		myB.OutPut();
	}
}