继承：在Java中使用extends关键字来实现类的继承  ，extends意思就是派生，所以子类也叫派生类，继承的主要目的是扩展类的内容

操作格式： class A{}; class B extends A{};

子类B可以继承父类A中的公用方法，也可以扩展自己的方法

示例代码：

package OOP2;

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{

private String school;

public void setSchool(String school){

this.school = school;

}

public String getSchool(){

return this.school;

}

};

public class extendsOne {

public static void main(String[] args) {

// TODO Auto-generated method stub

Student stu = new Student();

stu.setName("李帅");

stu.setAge(20);

stu.setSchool("霍格沃茨");

System.out.println("名字:"+stu.getName()+","+"年龄"+stu.getAge()+","+"学校："+stu.getSchool());

}

}

继承的限制：Java中只允许单继承，意思就是一个子类只能继承一个父类，一个孩子只能有一个亲爸

但是可以进行多层继承，意思就是父类还可以有父类

访问限制：在父类中的私有成员不能被子类访问，所以通过setter 和getter方法供子类访问父类中的非私有方法。

在Java机制中，首先执行父类中的内容，再执行子类中的内容，即没有父亲就没有孩子，对于子类的构造方法中，隐含了super();，所以有时也将父类称为超类。

方法的覆写：在继承的关系中也存在方法的覆写，即子类中覆写父类中的方法。但是被子类覆写的方法不能拥有比父类更低的访问权限。 目前接触的权限有：private

如果子类中的方法权限实在低于父类中的权限，只能通过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 OverrideDemo03{

public static void main(String args[]){

Student s = new Student() ;

s.print() ;

}

};

研究此问题意义不大。

方法重载和覆写的区别：

super关键字

super关键字的作用是在子类中调用父类的指定操作，例如：调用属性、方法、构造等。

但在子类中要调用父类的有参构造，必须要声明参数，super(参数，参数)

继承的应用：

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

A：排序类，实现数组的排序

B：数组反转类，实现数据的反向存放

代码：

class Array{// 表示数组

private int temp[] ;// 整型数组

private int foot ;// 定义添加位置

public Array(int len){

if(len>0){

this.temp = new int[len] ;

}else{

this.temp = new int[1] ;// 最少维持空间是1个

}

}

public boolean add(int i){// 增加元素

if(this.foot

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() ;

}

};

class ReverseArray extends Array{// 反转操作类

public ReverseArray(int len){

super(len) ;

}

public int[] getArray() {

int t[] = new int[super.getArray().length] ;// 开辟一个新的数组

int count = t.length - 1 ;

for(int x=0 ;x

t[count] = super.getArray()[x] ;// 数组反转

count-- ;

}

return t ;

}

};

public class ArrayDemo{

public static void main(String args[]){

// ReverseArray a = null ;// 声明反转类对象

// a = new ReverseArray(5) ;// 开辟5个空间大小

SortArray a = null ;

a = new SortArray(5) ;

System.out.print(a.add(23) + "\t") ;

System.out.print(a.add(21) + "\t") ;

System.out.print(a.add(2) + "\t") ;

System.out.print(a.add(42) + "\t") ;

System.out.print(a.add(5) + "\t") ;

System.out.print(a.add(6) + "\t") ;

print(a.getArray()) ;

}

public static void print(int i[]){// 输出数组内容

for(int x=0;x

System.out.print(i[x] + "、") ;

}

}

};