Java学习之面向对象(方法的重写 overwrite，super的使用，继承中的构造方法)

 

 

 

1.方法的重写

（1）在子类中可以根据对从基类中继承的方法进行重写。

（2）重写方法必须和被重写方法具有相同方法名称，参数列表和返回类型。

（3）重写方法不能使用比被重写方法更严格的访问权限。

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 name;
}
public int getAge(){
return age;
}
public String getInfo(){
return "name"+"\t"+name+"\n"+"age"+"\t"+age;
}
}
class Student extends Person{
private String school;
public void setSchool(String school){
this.school=school;
}
public String getSchool(){
return school;
}
public String getInfo(){
return "name"+"\t"+ getName()+"\n"+"age"+"\t"+getAge()+"\n"+"school"+"\t"+school;
}
}
public class textoverwrite {
public static void main(String arg[]){
Student student=new Student();
Person person=new Person();
person.setName("none");
person.setAge(1000);
student.setName("John");
student.setAge(18);
System.out.println(person.getInfo());
System.out.println(student.getInfo());
}

}

 

输出结果:

name none
age 1000
name John
age 18
school null

 

2.super的使用

（1）在Java类中使用super来引用基类(父类)的成分。

（2）注意:与this的区别(this是对当前对象的引用)。

class FatherClass{
public int value;
public void f(){
value=100;
System.out.println("FatherClass.value="+value);
}
}
class ChildClass extends FatherClass{
public int value;
public void f(){
super.f();
value=200;
System.out.println("ChildClass.value="+value);
System.out.println("value="+value);
System.out.println(super.value);
}
}
public class Textinberit {
public static void main(String arg[]){
ChlidClass cc=new ChlidClass();
cc.f();

}

}

 

 输出结果:

FatherClass.value=100
ChildClass.value=200
200
100

 

内存图如下:

3.继承中的构造方法规则：

（1）子类的构造的过程中必须调用其基类的构造方法。

（2）子类可以在自己的构造方法中使用super（argument_list）调用基类的构造方法。

注意：a.使用this（argument_list）调用本类的另外的构造方法。

　　　b.如果调用super，必须写在子类构造方法的第一行。

（3）如果子类的构造方法中没有显示的调用基类构造方法，则系统默认调用基类无参数的构造方法。

（4）如果子类构造方法中既没有显示调用基类构造方法，而基类中又没有无参数构造方法，则编译出错。

 

class SuperClass{
private int n;
SuperClass(){
System.out.println("SuperClass()");
}
SuperClass(int n){
System.out.println("SuperClass("+n+")");
this.n=n;
}
class Subclass extends SuperClass{
private int n;
Subclass(int n){

//super();
System.out.println("SubClass("+n+")");
this.n=n;
｝

｝
Subclass(){
super(300);    //对super的调用必须是构造函数的第一个语句。
System.out.println("SubClass");
}
}

public class TextSupersub {
public static void main(String arg[]){
SubrClass sc1=new SubClass();
SubClass sc2=new SubClass(400);
}
}

 

输出结果：

SuperClass(300)
SubClass
SuperClass()                  [反映了规则(3)]
SubClass(400)

 

 

 

 

class Person{
private String name;
private String location;
Person(String name){
location="beijing";
this.name=name;
}
Person(String name,String location){
this.name=name;
this.location=location;
}
public String info(){
return "name"+"\t"+name+"\t"+"location"+"\t"+location;
}
}
class Teacher extends Person{
private String capital;
Teacher(String name, String capital) {
this(name,"beijing",capital);    
}
Teacher(String name,String location,String capital){
super(name,location);
this.capital=capital;
}
public String info(){
return super.info()+"\t"+"capital"+"\t"+capital;
}


}
public class TextTeacher {
public static void main(String[] args){
Person p1=new Person("A");
Person p2=new Person("B","shanghai");
Teacher t1=new Teacher("C1","professor");
Teacher t2=new Teacher("C2","shanghai","professor");
System.out.println(p1.info());
System.out.println(p2.info());
System.out.println(t1.info());
System.out.println(t2.info());
}
}

 

 

输出结果:

name A location beijing
name B location shanghai
name C1 location beijing capital professor
name C2 location shanghai capital professor