Java基础：子类与父类、子类与对象的关系、子类与父类同包时、不同包时的继承性

继承：是一种由已有的类创建新类的机制。

1、利用继承这个机制，可以先定义一个共有属性的一般类，根据这个类再分别定义具有特殊属性的子类，子类继承了一般类的属性和方法，并根据自己的需求创建新的属性和方法；

2、使用Java关键字 extends 来定义一个类的子类，来实现继承机制；

基本格式如下：

class Student extends People {

....
}

类 Student 为子类，其父类为 People 类 ；

---

子类与父类的关系：

1、由继承得到的类称为子类，被继承的类则称为父类；

2、子类只能有一个父类，除了 Object 类，因为 Object 类是所以类的祖先类；

3、一个类可以有多个或者零个子类，即一个类，可以被多个类继承；

4、如果一个类没有使用关键字 extends 声明父类，那这个类就被系统默认为是 Object 类的子类；

如：声明 " class Student{} " 等价于 " class Student extends Object{} " ;

---

子类与父类同包时的继承性：

1、子类与父类同包时，子类则继承父类中不是 private 权限的成员变量和方法，作为自己的成员变量和方法；

2、子类所继承的成员变量和方法的访问权限是不变的；

如下代码↗：

//声明一般类People
package Chapter_Five;
public class People { 
    int age,leg = 2,hand = 2;
    protected void showPeopleMess() {
       System.out.print(age+"岁,"+leg+"只脚,"+hand+"只手");
    }    
}

//声明了一个Student子类，继承了People类
package Chapter_Five;
public class Student extends People {
	   int number;
	   void tellNumber() {
	       System.out.print(" 学号:"+number); 
	   }
	   int add(int x,int y) {
	      return x+y;
	   } 
} 

//声明了一个子类UniverStudent子类，继承了Student类
package Chapter_Five;
public class UniverStudent extends Student {
	   int multi(int x,int y) {
	      return x*y;
	   }  
}

//声明了一个测试类 Test 
package Chapter_Five;
public class Test {
	   public static void main(String args[]) {
	      Student zhang = new Student();
	      zhang.age = 19;           //访问继承的成员变量
	      zhang.number=123412;
	      zhang.showPeopleMess();  //调用继承的方法
	      zhang.tellNumber();        
	      int x=10,y=1;
	      System.out.print(" 会做加法:");
	      int result=zhang.add(x,y);
	      System.out.println(x+"+"+y+"="+result);
	      UniverStudent geng = new UniverStudent();
	      geng.age = 20;          //访问继承的成员变量
	      geng.number=123411;
	      geng.showPeopleMess();  //调用继承的方法
	      geng.tellNumber();        //调用继承的方法
	      System.out.print(" 会做加法:");
	      result=geng.add(x,y);      //调用继承的方法
	      System.out.print(x+"+"+y+"="+result);
	      System.out.print(" 会做乘法:");
	      result=geng.multi(x,y);
	      System.out.println(x+"*"+y+"="+result);
	   }
	} 

测试类Test 的输出结果：

19岁,2只脚,2只手 学号:123412 会做加法:10+1=11
20岁,2只脚,2只手 学号:123411 会做加法:10+1=11 会做乘法:10*1=10

---

子类与父类不同包时的继承性：

1、子类与父类不同包时，子类则继承父类中不是 private 和 友好 权限的成员变量和方法，作为自己的成员变量和方法；

2、子类所继承的成员变量和方法的访问权限是不变的；

如下代码↗：

//声明了一般类StudentFater
package Chapter_One;
public class StudentFater {
	int StudentID;
	protected int age;
	public String sex;
    protected void showPeopleMess() {
       System.out.print(age+"岁,性别："+sex);
    }   
}

package Chapter_Five;
import Chapter_One.StudentFater;

//继承不同一个包中的类StudentFater 
public class Student extends StudentFater {
	   //子类自己声明的成员变量与方法
	   int number;
	   void tellNumber() {
	       System.out.println(" 学号:"+number); 
	   }
	   public static void main(String[] args){
		   Student st = new Student();
		   //调用自己的成员变量和方法
		   st.number = 12345611 ;
		   st.tellNumber();
		   //调用从父类继承过来的 protected、public 类型的成员变量和方法
		//   st.StudentID = 1234561; //错误的，StudentID类型为 友好 ；
		   st.age = 18 ;
		   st.sex = "男" ;
		   st.showPeopleMess();
	   }
} 

代码输出结果：

 学号:12345611
18岁,性别：男

---

子类与对象的关系：

1、当用子类的构造方法创建一个子类的对象时，不仅子类中声明的成员变量被分配了内存，而且父类的成员变量也都被分配了内存空间；

2、子类和父类在同一个包的情况下，虽然父类被分配了内存空间，但只将子类继承的那部分成员变量分配给子类对象，也就是子类将不继承父类 private 类型的成员变量；

3、子类和父类不在同一个包的情况下，子类将不继承父类 private 和 友好 类型的成员变量；

4、没有被子类继承的那些成员变量并不会占用内存空间，因为子类中可以操作从父类继承过来的方法，而那些方法里面是可以对那些成员变量进行操作的；

子类和父类在同一个包的情况，如下代码↗：

//声明了一般类StudentFater
package Chapter_Five;
public class StudentFater {
        private int sum;
	int StudentID;
	protected int age;
	public String sex;
    protected void showPeopleMess() {
       sum = 1111;     //操作private类型的变量
       System.out.print(age+" 岁,性别："+sex+" sum的值="+sum+" StudentID的值："+StudentID);
    }   
}

package Chapter_Five;
//继承同一个包中的类StudentFater 
public class Student extends StudentFater {
	   public static void main(String[] args){
		   Student st = new Student();
		   //调用从父类继承过来的 protected、public、友好 类型的成员变量和方法
           //      st.sum = 1111;         //错误的，子类不能继承父类private类型的成员变量
		   st.StudentID = 1234561;
		   st.age = 18 ;
		   st.sex = "男" ;
		   st.showPeopleMess();
	   }
} 

代码输出结果：

18岁,性别：男 sum的值=1111 StudentID的值：1234561

子类和父类不在同一个包的情况，如下代码↗：

//声明了一般类StudentFater
package Chapter_One;
public class StudentFater {
        private int sum;
	int StudentID;
	protected int age;
	public String sex;
    protected void showPeopleMess() {
        sum = 1111;    //操作private类型的变量
       System.out.print(age+"岁,性别："+sex+" sum的值="+sum);
    }   
}

package Chapter_Five;
import Chapter_One.StudentFater;

//继承不同一个包中的类StudentFater 
public class Student extends StudentFater {
	   public static void main(String[] args){
		   //调用从父类继承过来的 protected、public 类型的成员变量和方法
             //    st.sum = 1111;         //错误的，子类不能继承父类private类型的成员变量 
	     //    st.StudentID = 1234561; //错误的，子类不能继承父类 好友 类型的成员变量 
		   st.age = 18 ;
		   st.sex = "男" ;
		   st.showPeopleMess();
	   }
} 

代码输出结果：

18岁,性别：男 sum的值=1111