继承的基本实现

1.1 类的继承格式

在JAVA中使用extends关键字完成类的继承关系

class 父类{}      //定义父类
class 子类 extends 父类{}//使用extends关键字实现继承

继承：子类继承父类，并扩展已有类的功能

class Person
{
    private String name ;
    private int age ;
    public void setName(String name)
    {
        this.name = name ;
    }
    public void setAge(int age)
    {
        this.age = age ;
    }
    public String getName()
    {
        return this.name ;
    }
    public int getAge()
    {
        return this.age ;
    }
}
class Student extends Person
{
}
public class ExtDemo01
{
    public static void main(String[] args)
    {
        Student stu = new Student() ;//实例化子类对象
        stu.setName("IronMan") ;    //给子类属性赋值
        stu.setAge(20) ;
        System.out.println("姓名："+stu.getName()+"年龄："+stu.getAge()) ;
    }
}

将父类中内容拿到子类中使用，子类中如果有重复内容，就不用重新定义了。

1.2继承的限制

在JAVA中允许单继承，但不能使用多重继承，即 一个子类只能继承一个父类，但是允许多层继承，

class A{}
class B extends A{} //多层继承
class C extends B{} //多层继承

1.2.1 访问限制
在使用继承的时候，子类不能直接访问父类中的私有成员，但是子类可以调用父类中的非私有方法，但是不能直接调用父类中的私有成员。

class Person
{
    private String name ;
    private int age ;
    public void setName(String name)
    {
        this.name = name ;
    }
    public void setAge(int age)
    {
        this.age = age ;
    }
    public String getName()
    {
        return this.name ;
    }
    public int getAge()
    {
        return this.age ;
    }
}
class Student extends Person //定义类Student并继承父类
{
    System.out.println("父类中的name属性：" + getName()) ; //简介访问
    System.out.println("父类中的年龄属性：" + getAge()) ;    //简介访问
}

可以使用set()和get()简介访问

2.1 子类对象的实例化过程

在继承操作中，对于子类对象的实例化有要求：
子类对象在实例化之前，必须首先调用父类中的构造方法 之后 再调用子类中的构造方法

2.1.1 方法的覆写

在继承关系中，存在着方法覆写的概念，就是指，子类定义了与父类同名的方法，但是在方法覆写是必须考虑到权限，即，被子类覆写的方法不能拥有比父类方法更加严格的访问权限。
所以，如果在父类中使用public定义的方法，子类的访问权限必须是public，否则程序无法编译。
使用super关键字可以从子类访问父类中的内容 super.方法 ()

class Person    //定义父类
{
    void print() //默认的访问权限
    {
        System.out.println("Person --> void print") ;
    }
}
class Student extends Person //定义类继承父类
{
    public void print()
    {
        super.print() ;//访问父类中被子类覆写过的方法
        System.out.println("Student--> void print") ;
    }
}
public class OverrideDemo01
{
    public static void main(String[] args)
    {
        Student stu = new Student() ;
        stu.print() ;//对象.方法完成调用。
    }
}

2.2 super 关键字

super表示的是从子类调用父类中的指定操作，例如，调用属性，调用方法，调用构造。因为在子类实例化的时候，会默认调用父类中的无参构造，如果现在希望调用有参构造，则必须在子类中明确声明。

2.3继承的应用

要求：定义一个整型数组类，要求包含构造方法，增加数据及输出数据成员方法，并利用数组实现动态内存分配，在此基础上定义一下子类：
A 排序类–实现排序

class Array     //定义一个数组
{
    private int temp[] ;    //整型数组
    private int foot ;      //声明添加位置，即角标

    public Array(int len)   //构造方法
    {
        if(len>0)                     //如果数组长度大于0
        {
            this.temp = new int[len] ;//给类中属性赋值
        }
        else
        {
            this.temp = new int[1] ; //最小空间是1
        }
    }

    public boolean add(int i)   //数组中增加元素
    {
        if(this.foot<this.temp.length)  //表示还有空间
        {
            this.temp[foot] = i ;//增加元素
            this.foot ++ ;      //修改角标，为下一次添加指明位置
            return true ;
        }
        else
        {
            return false ;
        }
    }

    public int[] getArray()
    {
        return this.temp ;
    }
}
class SortArray extends Array   //排序类
{
    public SortArray(int len)
    {
        super(len) ;
    }
    public int[] getArray() //覆写方法
    {
        java.util.Arrays.sort(super.getArray()) ;   //排序操作
        return super.getArray() ;   //返回排序后数组
    }
}
public class ArrayDemo01
{
    public static void main(String[] args)
    {
        SortArray a = null ;    //声明对象
        a = new SortArray(5) ;  //实例化对象 开辟5个空间大小
        System.out.print(a.add(2)+"\t") ;
        System.out.print(a.add(5)+"\t") ;
        System.out.print(a.add(32)+"\t") ;
        System.out.print(a.add(26)+"\t") ;
        System.out.print(a.add(24)+"\t") ;
        System.out.print(a.add(12)+"\t") ;
        print(a.getArray()) ;
    }
    public static void print(int i[])   //输出数组内容
    {
        for(int x=0;x<i.length;x++)
        {
            System.out.print(i[x]+",") ;
        }
    }

}