Java 对于继承的初级理解

概念：继承，是指一个类的定义可以基于另外一个已存在的类，即子类继承父类，从而实现父类的代码的重用。两个类的关系：父类一般具有各个子类共性的特征，而子类可以增加一些更具个性的方法。类的继承具有传递性，即子类还可以继续派生子类，位于上层的类概念更加抽象，位于下层的类的概念更加具体。

1.定义子类：

语法格式

[修饰符] class 子类名 extends 父类名{

　　子类体

}

修饰符：public private protected default

子类体是子类在继承父类的内容基础上添加的新的特有内容，可以包含成员变量、成员方法、类、接口、构造方法等等。

举个栗子，在一个公司中，雇员是公司聘请的工作人员，经理是管理公司的一种特殊雇员，这类特殊雇员不仅拥有普通雇员的属性和方法，还有属于他自己的一些属性和方法，例如，特殊津贴。

代码如下

public class EmployeeClass{
    private String name; // 名字
    private int id;  //公司编号
    private double salary;  //薪水
    private String department;// 部门
    
    public EmployeeClass(){}
    
    public EmployeeClass(String name,int id,double salary,String department){
            this.name = name;
            this.id = id;
            this.salary = salary;
            this.department = department;
      }

    public String getName() {
        return name;
    }

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    @Override
    public String toString() {
        return "EmployeeClass [name=" + name + ", id=" + id + ", salary="
                + salary + ", department=" + department + "]";
    }

}        

这是雇员类的代码，其中有四个属性，姓名，编号，工资，部门。

public class ManagerClass extends EmployeeClass{
    private double specialsalary;
    
    public ManagerClass(){super();}
    
    public ManagerClass(String name,int id,double salary,String department,double specialsalary){
        super(name,id,salary,department);
        this.specialsalary = specialsalary;
    }

    public double getSpecialsalary() {
        return specialsalary;
    }

    public void setSpecialsalary(double specialsalary) {
        this.specialsalary = specialsalary;
    }

    @Override
    public String toString() {
        return super.toString() + "\nspecialsal:" +specialsalary;
    }
    

}

这是子类，经理类，拥有一个自己的属性，特殊津贴。

 

2.子类对父类成员的可访问特性

子类可以继承父类的成员，但是对父类成员的访问却是由访问特性控制。

 

父类与子类在一个包中：不能直接访问private，但是我们可以通过具有public访问属性的成员方法来取得 父类的private成员。

父类与子类不在同一个包中：不能直接访问private和默认，但是我们可以通过具有public和protected访问属性的成员方法来取得 父类的private成员。

 

3.类成员方法的重载与覆盖

当子类中定义的新成员变量的名字与父类中某个成员变量名字相同时，子类会把父类中相应成员变量隐藏起来。

当子类中定义的成员方法的名字与父类中某个成员方法的名字相同时属于成员方法的重载或覆盖。

(1)成员方法的重载

在前面举到的雇员与经理栗子中，我们可以在雇员类中定义一个成员方法

public void setInfo(String name,int id,double salary,String department){
        this.name = new String(name);
        this.id = id;
        this.salary = salary;
        this.department = new String(department);
        
    }

在经理类中可以定义为：

public void setInfo(String name,int id,double salary,String department,double specialsalary){
            super(name,id,salary,department);
             this.specialsalary = specialsalary;
             
        }

这就是成员方法的重载

(2)成员方法的覆盖

通常有两种形式：

①在子类定义的成员方法中，首先调用父类中被覆盖的成员方法，再添加一些操作语句。

②在子类定义的成员方法中，不调用父类覆盖的成员方法，而是重新写一个语句组。这样实现了对父类的完全覆盖。当子类的某项操作与父类对象操作完全不同时，应采取这种方法实现。

栗子：

在object类中有一个判断两个对象是否相等的成员方法equals（），其代码为：

public boolean euqals(Object obj){
        return (this == obj);
    }

可以看到，这个成员方法是比较两个对象是否同时引用一个对象。

但是我们现在希望能够实现一个比较两个同类型的对象的内容是否相等的功能。所以我们下面设计有了一个复数类，每个复数类由一个实部和虚部组成。设计功能可以比较两个复数是否相等。代码如下：

public class ComplexNumber {
    private double re;
    private double im;
    
    public ComplexNumber(){re = 0.0;im = 0.0;}
    public ComplexNumber(double re,double im){
        this.re = re;
        this.im = im;
    }
    public double getRe() {
        return re;
    }
    public void setRe(double re) {
        this.re = re;
    }
    public double getIm() {
        return im;
    }
    public void setIm(double im) {
        this.im = im;
    }
    
    public boolean equals(Object otherObject){
        if(this == otherObject) return true;
        if(otherObject == null) return false;
        if(getClass() != otherObject.getClass()) return false;
        
        ComplexNumber other = (ComplexNumber)otherObject;
        if((re == other.re) && (im == other.im)) return true;
        else return false;
    }
    public String toString(){
        String str = "";
        if(re != 0) str += re;
        if(im == 0) return str;
        if( im < 0 ) str += im +"i";
        else str += " + " + im +"i";
        return str;
    }
    
    public static void main(String[] args) {
        ComplexNumber c1,c2;
        c1 = new ComplexNumber(2,3);
        c2 = new ComplexNumber(2,-3.4);
        if(c1.equals(c2)){
            System.out.println("("+c1+") == ( " + c2 +")" );
        }
        else{
            System.out.println("("+c1+") <> ( " + c2 +")" );
        }
    }
}

结果为(2.0 + 3.0i) <> ( 2.0-3.4i)