首页 > 代码库 > 成员变量的隐藏,方法的覆盖,super关键字

成员变量的隐藏,方法的覆盖,super关键字

成员变量的隐藏:当父类和子类有相同的成员变量时,即定义了与父类相同的成员变量时,就会发生子类对父类变量的隐藏。对于子类的对象来说,父类中的同名成员变量被隐藏起来,子类就会优先使用自己的成员变量,父类成员隐藏。

public class yincang {
public static void main(String []args)
{
SonA son=new SonA();
son.showson();
FatherA father=new FatherA();
father.showfather();
}
}
class FatherA{
int x1=1;
int x2=2;
void showfather(){
System.out.print("x1="+x1+"\n");
System.out.print("x2="+x2+"\n");
}
}
class SonA extends FatherA
{
int x1=11;
int y1=22;
void showson(){
System.out.print("x1="+x1+"\n");
System.out.print("x2="+x2+"\n");
System.out.print("y1="+y1+"\n");

}
}

ps:该程序隐藏了父类中的x1输出了子类中的x1.隐藏和类型无关,当父类中的x1改为double型,子类还是int型,那么输出的还是子类的int型。

隐藏与修饰符无关,父类中的x1 的修饰符该为protected子类x1 的修饰符还是不变,保持默认。

 

方法的覆盖:子类和父类可以定义相同的方法名,这时候,对于子类的对象,调用的是自己的成员,覆盖的是父类的成员方法。

public class fugai {
public static void main(String []args)
{
FatherB father=new FatherB();
father.show();
SonB son=new SonB();
son.show();
}
}
class FatherB{
int x1=10;
int x2=20;
void show(){
System.out.print("x1="+x1+"\n");
System.out.print("x2="+x2+"\n");
}
}
class SonB extends FatherB{
int y1=30;
int y2=40;
void show(){
System.out.print("y1="+y1+"\n");
System.out.print("y2="+y2+"\n");
}

}

ps:在该程序中,在父类FatherB中有一个成员方法show(),在子类SonB中也有一个成员方法show(),那么创建子类的对象son,调用的是自己的成员方法show(),父类中的成员方法就被覆盖了。只有创建父类的对象father,调用的才是自己的成员方法。成员变量的覆盖必须是方法名,参数类型,顺序,个数,返回值完全相同。

如果方法名相同,参数类型,个数,顺序不一样是时子类继承下来形成的是重载。重载要求方法名相同,参数类型,个数,顺序不同。

public class chongzai {
int get(int x){
return x;
}
class B extends chongzai{
int get(int x,int y){
return x+y;
}
}
class test1{
public void main(String []args){
B bb=new B();
System.out.print(bb.get(4));
System.out.print(bb.get(4,5));
}
}
}

 ps:在该程序中,父类的get()方法带一个参数,子类的get()方法带两个参数,子类把父类中的方法继承下来,两个get()方法形成重载关系。创建子类的对象,语句“bb.get(4)”匹配的是父类中的get()方法。而语句“bb.get(4,5)”匹配的是子类自己的方法。

如果方法名,参数类型,个数,顺序完全相同,只有返回值不同那么不是重载也不是覆盖。

不能覆盖父类中的final方法,如果父类中的方法为final,表示为最终方法,不能 被子类覆盖,也就是说最终方法能被子类继承和使用,但不能在子类中修改或重新定义它,这和常量的概念类似。

不能覆盖父类中的static方法但可以隐藏。也就是说,在子类中声明的同名静态方法实际上隐藏了父类的静态方法。

super关键字:如果子类和父类有相同的成员变量和方法时,子类会隐藏和覆盖或父类的成员变量和成员方法,使用子类自己的成员变量和方法。但如果子类想访问父类的成员变量和成员方法,怎么解决呢?解决的方法就是使用super关键字,要使用父类中被隐藏和覆盖的成员时,使用super,格式如下:

super.父类成员变量名

super.父类成员方法名

例如:

public class superlei {
public static void main(String []args)
{
Employee emp=new Employee();
emp.sete();
emp.show();
}
}
class Person{
protected String name;
protected char sex;
void show(){
System.out.println("父类中的名字为:"+name);
System.out.println("性别为:"+sex);
}
}
class Employee extends Person{
protected int salary;
protected String name;
void sete(){
name="张倩";
super.name="李斯";
salary=3000;
sex=‘男‘;
}
void show(){
System.out.println("子类中的名字为:"+name);
System.out.println("性别为:"+sex);
}

}

ps:要给父类的成员变量name赋值,必须采用一个super调用给父类的成员变量name赋值“super.name="李斯"”。同样,子类和父类有相同的输出方法show()方法,在子类的show()方法中,要调用父类的show()方法也必须通过super来调用“super.show();”.

 

子类构造方法:在前面的 程序中,父类都没有写构造方法,这时候父类默认有一个无参的构造方法。定义子类时,必须无条件继承父类中的无参构造,也就是说子类默认调用父类中的默认无参构造。当父类存在有参数的构造方法时,子类必须调用父类中的构造方法。子类调用父类的构造方法原则是:

1:对于父类中不含参数构造方法,子类无条件继承。

2:如果父类中是有参数的构造方法,子类这时不能默认继承无参构造,必须写super调用父类构造方法。

3:如果在子类构造方法中通过this()调用本类中其他构造方法,就不再默认调用super()。

public class gouzaofangfa {
public static void main(String []args)
{
Qun qun=new Qun(3,4,5,4.5f);
qun.show();
qun.quntity();
}
}
class Rect{
int length;
int width;
int high;
Rect(int l,int w,int h){
this.length=l;
this.width=w;
this.high=h;
}
int vert(){
int v=length*width*high;
return v;
}
}
class Qun extends Rect{
float p;
Qun(int lx,int wx,int hx,float px){
super(lx,wx,hx);
p=px;
}
void quntity(){
float m;
m=p*vert();
System.out.println("质量为"+m);
}
void show(){
System.out.println("长为:"+length);
System.out.println("宽为:"+width);
System.out.println("高为:"+high);

}
}

ps:父类Rect长方形类中定义了一个有参数的构造方法,给长,宽,高赋值。在他的派生类Qun类中,必须定义一个有参数的构造方法,并且一般要带4个参数,这是因为子类的构造方法需要给父类中的长宽高和自己的密度赋值。在子类的构造方法中,第一句语句必须是用super调用父类的构造方法“super(lx,wx,hx);”,他不能放在其他语句“p=px”后面。

 

成员变量的隐藏,方法的覆盖,super关键字