java类的构造与父子类之间的转换问题

package com.zhao.impl;
public interface RideCar {
	public void CanRideCar();
}

package com.zhao.impl;
public interface RidePlane {
		public void CanRidePlane();
}

package com.zhao.impl;
abstract public class Person {
	public String name;
	public int age;
	static 
	{
		//无用abstract 声明为抽象类的话就会执行并左最先
		System.out.println("Person's static block");
	}
	public Person()
	{
		name = "adult";
		age = 18;
		System.out.println("Person's default construction");
	}
	public Person(String name,int age)
	{
		//有this()的话就会调用自己的默认构造成方法
		//this();
		this.name=name;
		this.age=age;
		System.out.println("Person's seft construction");
	}
}

package com.zhao.impl;
import com.zhao.impl.Person;
import com.zhao.impl.RideCar;
public class Father extends Person implements RideCar {
	static public int spfi = 1;
	static public int spfi2 = spMethod();
	static public int spfi3;
	static 
	{
		spfi3=111;
		System.out.println("Father's static block");
	}
	public int pfi = 3;
	public int pfi2 = pMethod();
	public int pfi3;
	{
		pfi3=333;
		System.out.println("Father's instance block");
	}
	
	public Father() {
		//super();
		System.out.println("Father's default construction");
	}
	public Father(String name,int age)
	{
		super(name,age);
		System.out.println("Father's seft construction");
	}

	public void CanRideCar() {
		System.out.println("Father can ride a car");

	}
	
	private static int spMethod() {
		System.out.println("Father's static Method");
		return 11;
	}
	private int pMethod() {
		System.out.println("Father's instance Method");
		return 33;
	}

}

package com.zhao.impl;
public class Child extends Father implements RidePlane {
	static public int spci = 2;
	static public int spci2 = spMethod();
	static public int spci3;
	static 
	{
		spci3=222;
		System.out.println("Child's static block");
	}
	
	public int pci = 4;
	public int pci2 = pMethod();
	public int pci3;
	{
		pci3=444;
		System.out.println("Child's instance block");
	}
	
	public Child() {
		//有没有super()都会调用父类的默认构造方法
		//super(); 
		System.out.println("Child's default construction");
	}
	public Child(String name,int age) {
		//不能再有super();或this();
		//原因:constructor call must be the first statement in the constructor
		//super(name,age);就不会调用父类的默认构造方法而调父类两参数的构造方法
		super(name,age);
		System.out.println("Child's self construction");
	}

	public void CanRidePlane() {
		System.out.println("Child can ride a plane");

	}

	private static int spMethod() {
		System.out.println("Child's static Method");
		return 22;
	}
	private int pMethod() {
		System.out.println("Child's instance Method");
		return 44;
	}
}

package com.zhao.test;
import com.zhao.impl.Child;
import com.zhao.impl.Father;
import com.zhao.impl.Person;
import com.zhao.impl.RideCar;
public class TestClass {
	public static void main(String[] args) {

		Child c;
		System.out.println("program start");   
		System.out.println("Child's spci:"+Child.spci);
		c = new Child("zhao",24);
		c.CanRidePlane();
		System.out.println("program end");
		
		System.out.println("second program start");
		Father d; //Child d; 显示是一样的
		d = new Child();
		System.out.println("second program end");
	}
}

program start
Person's static block
Father's static Method
Father's static block
Child's static Method
Child's static block
Child's spci:2
Person's seft construction
Father's instance Method
Father's instance block
Father's seft construction
Child's instance Method
Child's instance block
Child's self construction
Child can ride a plane
program end
second program start
Person's default construction
Father's instance Method
Father's instance block
Father's default construction
Child's instance Method
Child's instance block
Child's default construction
second program end

package com.zhao.test;
import com.zhao.impl.Child;
import com.zhao.impl.Father;
import com.zhao.impl.Person;
import com.zhao.impl.RideCar;
public class TestClass2 {
	public static void main(String[] args) {
		Person p;
		Father f;
		Child c;
		
		f = new Child();
		System.out.println("f的class:"+f.getClass());
		//f是Child类型
		//不把f强调转换成Child类型是无Child类型的属性和方法的，
		//尽管它是用Child的构造器建起，但它的类型是Father
		System.out.println(((Child)f).pci);
		c = new Child("zhao",24);
		System.out.println(c.name+","+c.age);
		p=f;
		System.out.println(p.name+","+p.age);
		System.out.println(f.name+","+f.age);
		f = c;
		System.out.println(f.name+","+f.age);
		
		// c= p 不能通过编译
		//总结，子类变量可以赋值给父类变量，反之不行。
		//如人是父类，程序员是子类，程序员可赋值给人，是因为所有程序员都是人。
		//人不能赋赋值程序员，因为所有人不是全部是程序员，还有医生，老师~~~
		
		RideCar rc = new Child();
		rc.CanRideCar();
		System.out.println(rc.getClass());
		System.out.println(((Child)rc).name);
		System.out.println(((Father)rc).name);
		
		Father fa = new Father();
		//System.out.println(((Child)fa).name);
		//不能所fa强调转换成Child,因为它本身是father
		Child ch = new Child("zhao",120);
		System.out.println(((Father)ch).name);
		//子类程序员可以强制转换成父类人的原因是，子类有父类的所有属性，
		//反之不能，是因为父类无子类的所有属性。
	}
}

f的class:class com.zhao.impl.Child
4
zhao,24
adult,18
adult,18
zhao,24
class com.zhao.impl.Child
adult
adult
zhao

总结:
一.
1.有没有super()都会调用父类的默认构造方法
2.super();this();super(name,age);这些调用构造器的语句只能用一个.原因:
  constructor call must be the first statement in the constructor
  用了super(name,age);就不会调用父类的默认构造方法而调父类两参数的构造方法
3.用abstract 声明为抽象类的话,好像static块就不执行.
4.Father d = new Child(); 和Child d = new Child();输出结果是一样的.
二.
1.赋值,子类变量可以赋值给父类变量，反之不行。
2.强制转换,子类变量可以强制转换成父类.
3.实际类型,用了什么类的构造成器构造,实际类型就是什么,如Father d = new Child();  ,d的实际上就是Child类型.RideCar rc = new Child(); ,rc实际上也是Child类型.