继承：在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<default<public。
如果子类中的方法权限实在低于父类中的权限，只能通过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.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() ;
}
};
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.length;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) + " ") ;
System.out.print(a.add(21) + " ") ;
System.out.print(a.add(2) + " ") ;
System.out.print(a.add(42) + " ") ;
System.out.print(a.add(5) + " ") ;
System.out.print(a.add(6) + " ") ;
print(a.getArray()) ;
}
public static void print(int i[]){ // 输出数组内容
for(int x=0;x<i.length;x++){
System.out.print(i[x] + "、") ;
}
}
};