论编程中的父与子

        编程语言中的继承就好比日常生活中的遗传和模仿。通过遗传，儿子获得了父亲的某些基因，对外表现出某种特性，通俗的说法就是我们常听到人们说“张三的眼睛......长得和他父亲很像”之类的话；通过模仿，儿子的一些行为、动作、处事方式会和父亲很像。我们在编程过程中所接触的继承实质与这很相似，这里的“某种特性”就相当于编程中的“属性”，这里的“一些行为、动作、处事方式”就相当于编程中的“成员函数”。照此说来，继承就是子类继承了父类的属性和方法。但在编程语言中继承还是有别于生活的，遗传和模仿所获得的仅仅只是一部分，而继承则是继承了父类所有的属性和方法。话虽如此，但是当子类不能调用父类的私有属性，在实例化子类对象的时候，会开辟一定的存储空间用来存储从父类继承的私有属性，但这些属性是无法被调用的，所以可以理解为子类不能继承父类的私有属性。

       当子类中重写了父类的方法时，实例化一个子类对象，调用的是子类重写后的方法。

//父类
public class People {
	private String name;
	
	public void Action(){
		System.out.println(name+"的行动");
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

//子类
public class Child extends People{
	private String name;
	private int age;
	
	public void Action(){
		System.out.println(name+"的行动");
	}

}


//测试类
public class Test {

	public static void main(String[] args) {
				
		People people=new People();
		people.setName("Mike");
		people.Action();

		
		Child child=new Child();
		child.setName("Bob");
		child.Action();
		

 

      结果：

       发生继承时，子类继承的其实严格来说应该是父辈，而不是直系父亲，每个子类都有且只有一个父类，就像生活中每个人都只有一个亲生父亲一样。当子类发生继承时，被继承的类不一定是该子类的父亲，只能说是父辈，父辈只是用来显示告诉子类其父亲有哪些方法和属性，当子类没有发生重写，即没有自己独有的属性和方法时，它可以利用父辈的方法和属性，这时改变的是父辈的方法和属性，并且影响自己的属性和方法（可以理解为子类和父类共有一套方法和属性），而当子类重写了父类的方法，或者定义了自己的属性时，利用父辈的方法，改变的是自己的属性和方法。
       特别值得注意的一点是：因为子类构造器都会默认调用父类的无参构造器，所以每一个子类对象的产生 必然伴随着一个父类对象的诞生。每一个类都会有一个默认的构造器，子类的构造器其实是这样的：

public  子类类名（）｛

       super（）；

｝

如果父类中重载了有参的构造器，则在创建子类对象时会报错，如下：

public class People {
	private String name;
	private int IDnum;
	private int age;
	//构造器
	public People(String name){
		this.name=name;
	}
｝


public class Child extends People{
	private String name;
	private int age;
	
	public void Action(){
		System.out.println(name+"的行动");
	}

}

 则会报错如下：

 意思是父类没有定义无参构造器

解决办法有两种：

1.在父类中把默认的无参构造器显示化的写出来，即

public  People（）｛

 

｝

2.在子类中把无参构造器重写一下，在该构造器内调用父类有参的构造器，即

public Child（）｛

    super（“张三”）；

｝

 

自动转型：

       可以将子类自动转成父类，即将子类看作是父类，但是我们不能将父类看作是子类。

格式：

                                       父类类名   对象名=new  子类类名（）;

       形象点来说，在一堆小轿车中随机找出一辆，它既是小轿车，同时又是车。在生活中，我们可以把小轿车看作是车，但车却不一定都是小轿车，还会有其他类型的车，例如：客车、货车......

public class People {
	private String name;

	
	public void play(){
		System.out.println(name+"的行动");
	}
	
	public void Action(){
		System.out.println(name+"正在行动");
	}
	

	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	
}


public class Adult extends People{
	private String name;
	
	public void play(){
		System.out.println(name+"的行动");
	}
        
        public void rest(){
                System.out.println(name+"在休息");
        }

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	

}



public class Test {

	public static void main(String[] args) {
		People people=new People();
		people.setName("李四");
		
		People adult=new Adult();
		adult.setName("张三");
              }
                     
}

 

    当在Test类的主函数中执行  adult.play();  [子类重写了父类的方法] 时，结果如下：

                                          张三的行动

   当执行：adult.Action(); [父类特有的方法] 时，结果如下：

                                          null在行动

   当测试类是这样写时：

public class Test {

	public static void main(String[] args) {
		People people=new People();
		people.setName("李四");
		
		People adult=new Adult();
		
		
		adult.Action();
		
		adult.play();
		
		
		

	}

}

   结果如下：

                    null正在行动

                    null的行动

 

   当执行：adult.rest();时，会出现下面的报错

 错误显示的是rest()方法在父类中没有定义，由此可知自动转型产生的对象不能调用子类中所特有的方法。

       上面这些测试，结果表明：自动转型产生的对象不能够调用子类所特有的方法；当子类重新定义了自己的属性并重写父类的方法时，自动转型产生的对象调用的是子类所重写的方法。

 

 

       其实还有一种比较常用的自动转型，比较隐蔽，容易忽视

       在创建界面时，向窗体上添加各种组件的add(comb)方法原代码为

 public Component add(Component comp) {
        addImpl(comp, null, -1);
 return comp;
    }
它的形参是Component类型的，但是add方法它却可以添加JButton、JCheckBox、JComboBox等类型的对象，其实JButton、JCheckBox、JComboBox都是Component的子类，这里就是把子类自动转型成父类了。

        此外，在写数组队列的添加对象功能时，形参是Object类型的，这里也应用到了自动转型，Object是所有类的父类。