Java-变量的隐藏和方法的重写（覆盖）

变量的隐藏

子类定义的属性的名字跟从父类中继承过来的属性名字一致，子类新定义的属性会覆盖从父类中继承过来的属性

public class Test1 {
    public static void main(String[] args) {
        Boss boss=new Boss();
        System.out.print(boss.name);//刘备
    }
}
class Person{
    String name="关羽";
}
class Boss extends Person{
    String name="刘备";
}

方法重写（方法覆盖）

子类可以覆盖从父类中继承过来的同名的方法
1)只能在父类和子类之间出现
2)返回值类型，方法名，参数列表都必须跟父类继承过来同名方法一致

public class Test1 {
    public static void main(String[] args) {
        Eoo2 eoo2=new Eoo2();
        System.out.println(eoo2.function1(10, 10));
    }
}
class Eoo1{
    int function1(int num1,int num2){
        return num1+num2;
    }
}
class Eoo2 extends Eoo1{
    int function1(int num1,int num2){
        return num1*num2;
    }
}

方法重载和方法重写的区别
1)方法重载是在一个类的内部
方法重写是在父类和子类之间
2)方法重载是一个类当中包含多个同名的方法，但参数不同
方法重写是子类的方法覆盖父类中同名的方法

public class Test1 {
    public static void main(String[] args) {
        Foo2 foo2=new Foo2();
        foo2.show(12);
        foo2.show(12, 23.1);
    }
}
class Foo1{
    void show(int num1){
        System.out.println(num1);
    }
}
class Foo2 extends Foo1{
    void show(int num1,double num2){//方法重载
        System.out.println(num1);
        System.out.println(num2);
    }
    void show(int num1){//方法重写
        System.out.println("num1+1="+(num1+1));
    }
}

this和super
1、this.方法：调用当前子类的方法
super.方法：调用被覆盖父类的方法

public class Test1 {
    public static void main(String[] args) {
        Koo2 koo2=new Koo2();
        koo2.f1(10, 10);
    }
}
class Koo1{
    void function1(int num1,int num2){
        int sum=num1+num2;
        System.out.println(sum);
    }
}
class Koo2 extends Koo1{
    void function1(int num1,int num2){
        int result=num1*num2;
        System.out.println(result);
    }
//编写f1方法：先执行：num1+num2（父类function1方法）
//           再执行：num1*num2（子类function1方法）
    void f1(int num1,int num2){
        System.out.println("调用父类被重写的function1");
        super.function1(num1, num2);
        System.out.println("调用子类的function1");
        this.function1(num1, num2);
    }
}

2、构造方法调用
super(参数)：调用父类带参数的构造方法
this(参数)：调用子类的其他的构造方法

public class Test1 {
    public static void main(String[] args) {
        Eoo2 eoo2=new Eoo2("张",23,5500.0);
        System.out.println(eoo2.name+","+eoo2.age+","+eoo2.salary);
    }
}
class Eoo1{
    String name;
    int age;
    Eoo1(String name,int age){
        this.name=name;
        this.age=age;
    }
}
class Eoo2 extends Eoo1{
    double salary;
    Eoo2(String name,int age,double salary){
        super(name,age);//调用父类的带参数的构造方法
        this.salary=salary;
    }
}

public class Test1 {
    public static void main(String[] args) {
        Aoo1 aoo=new Aoo1(12,"刘");
        aoo.show();
        Aoo1 aoo1=new Aoo1(22,"张",5000,"上海");
        aoo1.show();
    }
}
class Aoo1{
    int age;
    String name;
    double money;
    String address;
    Aoo1(int age,String name){
        this.age=age;
        this.name=name;
    }
    Aoo1(int age,String name,double money,String address){
        this(age,name);//this（参数）：调用本类中的其他构造方法
        this.money=money;
        this.address=address;
    }
    void show(){
        System.out.println(name+","+age+","+money+","+address);
    }
}

完

Java-变量的隐藏和方法的重写（覆盖）

猜你喜欢