Java 的继承举例与详解
类的继承是将现有类作为父类派生出新的子类;通过类的继承可以实现以最少的代码快 速创建新类的目的,即可以提高代码复用率。
1. 类的继承
继承是面向对象程序设计的三大特征之一(封装、继承、多态),被继承的类称为父类 或超类,由继承而得到的类称为子类。
一个父类可以有多个子类,但一个子类只能拥有一个父类,这有点像层次结构。
子类可以自动拥有其父类允许被继承的所有成员,同时子类可以重写或添加自己独有的 成员变量和成员方法。
Java中,所有类都是java.lang.Object的直接或间接子类。
2. 子类的创建
在定义一个类时,如果该类要继承某类,需要用 extends 关键字标识出来,语法格式 如下:
class ChildClass extends ParentClass{… …}
其中,ChildClass继承ParentClass,即 ChildClass是ParentClass的子类,ParentClass 是ChildClass的父类。
继承有一个特点,子类的对象也是其父类的对象,反之则不然。举例来说,老虎类是动 物类的子类,那么老虎类的对象假设为东北虎,可以说东北虎是动物,但不能说动物是东北 虎,逻辑上有错误。
package ch08; class Person{ //从这里看不出该类是不是父类
private String name;
private int age;
public Person(){
System.out.println("调用了个人类的构造方法Person()");
}
public void setNameAge(String name, int age){
this.name=name; this.age=age;
}
public void show(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
class Student extends Person{
//从这里可以看出:父类为Person,子类为Student private String department;
public Student() {
System.out.println("调用了学生类的构造方法Student()");
}
public void setDepartment(String dep){
department=dep; System.out.println("我是"+department +"的学生");
}
}
public class Demo{
public static void main(String[] args){
Student stu=new Student();
stu.setNameAge("张小三",21); //子类调用父类方法
stu.show(); //子类调用父类方法
stu.setDepartment("计算机系"); //子类调用自己的方法
}
}
结论:
(1)在同一包中,父类的非私有(private)成员可以继承给子类;在不同的包中,子 类只能继承父类的受保护(protected)和共有的(public)成员。
(2)在执行子类的构造方法之前,先执行父类的无参构造方法,因为父类的无参构造 方法可能要初始化一些成员。
(3)构造方法不能被继承,但子类可以调用父类的构造方法。
3.调用父类中特定的构造方法
使用super()语句调用父类特定的构造方法。
示例:
package ch08;
class Person{
private String name;
private int age;
public Person(){
System.out.println("调用了Person类的无参构造方法");
}
public Person(String name, int age){
System.out.println("调用了Person类的有参构造方法");
this.name=name;
this.age=age;
}
public void show(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
class Student extends Person{
private String department;
public Student(){
System.out.println("调用了学生类的无参构造方法Student()");
}
public Student (String name,int age,String dep){
super();
//super(name,age); //调用父类特定的构造方法
department=dep;
System.out.println("我是"+department +"的学生");
System.out.println("调用了学生类的有参构造方法Student(String name,int age,String dep) ");
}
}
public class Demo{
public static void main(String[] args){
Student stu1=new Student();
Student stu2=new Student("李小四",23, "信息系");
stu1.show(); stu2.show();
}
}
结论:
(1)子类调用父类特定的构造方法,使用super([参数列表])语句,并且必须将其放在 子类构造方法的第一行;
(2)如果子类的构造方法中没有 super()语句,且父类存在有参的构造方法,则父类 必须提供无参的构造方法,否则编译错误;
(3)关于super()和this(): ? super()语句是子类调用父类的构造方法;this()是在类的内部,一个构造方法 中调用另一个构造方法。 ? super()和this()必须放在构造方法中的第一行。
4.在子类中访问父类的成员
在子类中访问父类的成员可以用super直接访问父类允许访问的成员,
语法格式如下:
super.成员变量;
super.成员方法();
在这里,可以把super是看作是父类的对象。
示例:
package ch08;
class Person{
protected String name;
protected int age;
public Person() {}
public Person(String name, int age){
this.name=name;
this.age=age;
}
protected void show(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
class Student extends Person{
private String department;
int age=20;
public Student (String xm,String dep){
name=xm;
department=dep;
super.age=25;
System.out.println("子类 Student中的成员变量age="+age);
super.show();
System.out.println("系别:"+ department );
}
}
public class Demo{
public static void main(String[] args){
Student stu=new Student("李小四","信息系");
}
}
回忆:protected访问修饰符 被 protected 修饰的成员变量或成员方法,只能被该类自身、其子类(可以在不同包 中),或同一包中的其他类访问。
5. 用父类的对象访问子类的成员
这类对象称为“上转型对象”或“上转对象”,即将子类对象赋值给父类对象(父类对 象指向子类对象),语法格式如下:
ParentClass pc = new ChildClass(); //而非:ParentClass pc = new ParentClass ();
示例:
package ch08;
class Person{
protected String name;
protected int age;
public Person(String name, int age){
this.name=name; this.age=age;
}
protected void show(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
class Student extends Person{
private String department;
public Student (String name,int age,String dep){
super(name,age);
department=dep;
}
protected void show(){
System.out.println("系别:"+ department);
}
public void subShow(){
System.out.println("我在子类中");
}
}
public class Demo{
public static void main(String[] args){
//以下一行父类对象指向子类对象
Person per=new Student("王永涛",24, "电子");
per.show();
//per.subShow();
}
}
结论:
(1)父类对象访问子类成员,仅限于上转对象的情况,并且只能访问覆盖类型的方法;
(2)普通的父类对象不能访问子类的成员;相反,子类的对象可以访问父类允许访问 的成员。