publicclassTest{
publicstaticvoidmain（Stringargs[]）{
Studentsst=newStudents（）;
st.setName（"zhangsan"）;
st.setAge（30）;
st.setSchool（"sichuanagricultureuniversity"）;
System.out.println（"nameis:
"+st.getName（）+",ageis:
"+st.getAge（）+",schoolis:
"+st.getSchool（））;
st.print（）;
}
}
classPerson{
privateStringname;
privateintage;
publicPerson（）{
System.out.println（"super'sconstractormethod"）;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicvoidsetAge（intage）{
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicintgetAge（）{
returnage;
}
voidprint（）{//父类中的方法
System.out.println（"=====super====="）;
}
}
classStudentsextendsPerson{
privateStringschool;
publicStudents（）{
super（）;//默认隐藏
System.out.println（"theson'sconstractormehod"）;
}
publicvoidsetSchool（Stringschool）{
this.school=school;
}
publicStringgetSchool（）{
returnschool;
}
publicvoidprint（）{//子类覆写父类的方法
System.out.println（"=====extends====="）;
}
}
从之前的正确操作中可以发现，如果现在子类将父类的方法覆写了，调用的时候肯定是调用了被覆写的方法，那么如果现在非要调用父类的方法该怎么办呢？
----通过super关键字就可以完成功能，super关键字可以从子类访问父类中的内容。
如果要访问被覆写的方法：
super.方法；
publicvoidprint（）{//子类覆写父类的方法
super.print（）;//申明调用父类的方法，不一定放在首句，也可以放在下面
System.out.println（"=====extends====="）;
}
如果要使用super不一定非要在方法覆写之后使用，也可以明确的表示某个方法是从父类中继承而来的，使用super只是更加明确的说，要从父类中查找，就不从子类中找了。
问题：
如果现在在父类中使用private关键字什么申明了一个方法，那么在子类中使用default权限算是扩大权限吗？
否。
此时并没有被覆写，而是相当于在子类中又重新定义了一个新的方法出来。
属性的覆盖
方法的覆写有很多要求，属性的覆盖，主要是指在子类中申明了与父类同名的属性。
但是此概念意义不大，很少使用。
publicclassPerson
{
publicstaticvoidmain（String[]args）
{
Studentsst=newStudents（）;
System.out.print（st.name）;
}
}
classst{
publicStringname="xzl";
}
classStudentsextendsst{
publicStringname="mark";
}
方法的重载（overloading）与覆写（overriding）的区别：
Super关键字
Super表示的是从子类调用父类中的指定操作，例如：
调用属性、方法、构造等。
因为在子类实例化的时候会默认调用父类中的无参构造，如果现在希望调用有参构造，则必须在子类中明确的申明。
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
Studentsst=newStudents（"zhangsan",30,"sichuanagricultureuniversity"）;
System.out.print（st.getInfo（））;
}
}
classPerson{
privateStringname;
privateintage;
publicPerson（Stringname,intage）{
this.setName（name）;
this.setAge（age）;
}
publicvoidsetName（Stringname）{
this.name=name;
}
publicvoidsetAge（intage）{
this.age=age;
}
publicStringgetName（）{
returnname;
}
publicintgetAge（）{
returnage;
}
publicStringgetInfo（）{
returnthis.getName（）+this.getAge（）;
}
}
classStudentsextendsPerson{
privateStringschool;
publicStudents（Stringname,intage,Stringschool）{
super（name,age）;//必须申明，因为是有参构造,这里如果不申明，则会出现编译错误
this.school=school;
}
publicvoidsetSchool（Stringschool）{
this.school=school;
}
publicStringgetSchool（）{
returnschool;
}
publicStringgetInfo（）{
returnsuper.getInfo（）+this.getSchool（）;
}
}
不管任何时候，子类实例化的时候永远要先去调用父类中的构造方法，默认调用的是无参构造。
this与super的区别：
对于this和super本身都可以调用构造方法，而且调用的时候必须放在构造方法的首行，所以这两个关键字肯定不能同时出现。
实例：
定义一个整形数组类，要求包含构造方法，增加数据及输出数据成员方法，并利用数组实现动态内存分配。
在此基础上定义出以下子类：
·排序类------实现排序
·反转类------实现数据反向存放
分析：
实现的代码如下：
publicclassTest{
publicstaticvoidmain（Stringargs[]）{
//ReverseArraya=null;//申明反转
//a=newReverseArray（5）;//开辟5个空间大小
SortArraya=null;//申明排序
a=newSortArray（5）;
System.out.print（a.add（23）+"\t"）;
System.out.print（a.add（26）+"\t"）;
System.out.print（a.add（28）+"\t"）;
System.out.print（a.add（29）+"\t"）;
System.out.print（a.add（21）+"\t"）;
System.out.print（a.add（24）+"\t"）;
print（a.getArray（））;
}
publicstaticvoidprint（inti[]）{
for（intx=0;xSystem.out.print（i[x]+"、"）;
}
}
}
classArray{//表示数组
privateinttemp[];//整形数组
privateintfoot;//定义添加位置
publicArray（intlen）{//构造方法
if（len>0）{
this.temp=newint[len];
}else{
this.temp=newint[1];//最少维持空间是1
}
}
publicbooleanadd（inti）{//增加元素
if（this.footthis.temp[foot]=i;//增加元素
this.foot++;//修改角标
returntrue;
}else{
returnfalse;
}
}
publicint[]getArray（）{
returnthis.temp;
}
}
classSortArrayextendsArray{//排序类
publicSortArray（intlen）{
super（len）;
}
publicint[]getArray（）{//覆写方法
java.util.Arrays.sort（super.getArray（））;//排序操作
returnsuper.getArray（）;
}
}
classReverseArrayextendsArray{//数组反转类
publicReverseArray（intlen）{
super（len）;
}
publicint[]getArray（）{
intt[]=newint[super.getArray（）.length];//开辟一个新的数组t[]
intcount=t.length-1;//定义最大角标
for（inti=0;it[count]=super.getArray（）[i];//数组反转
count--;
}
returnt;
}
}
升级会员 