Java中继承this关键字super关键字

Posted 2021-12-06 苦海123

继承:

概述：当多个类中存在相同属性和行为时，将这些相同的内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承抽离出来的这个类即可。

子类：当某个类继承了另一个类的时候，可以把这个某类称为子类。

父类：当某个类被继承时，这个被继承的类可以称为父类（也称为超类或基类）。

定义：子类继承父类的属性或行为，使得子类对象具有父类的相同的属性或行为，子类可以直接访问父类中的私有属性和行为。

继承的优点：代码重复利用；类与类存在关系，是多态的前提。

// 1.定义一个父类：FatherClass类：定义父类跟定义普通的类没有任何区别，如：
public class FatherClass{
    // 定义父类中的方法和属性：
    String FatherStr1 = "这是FatherClass父类中的FatherStr1";
    public static void FatherMethods(){
        System.out.println("父类FacherClass中的FatherMethods方法执行了");
    }

    // 定义与子类重名的属性和方法：
    String SameProp = "这是父类中：子类和父类中重名都有的属性SameProp";
    public static void SameMethods(){
        System.out.println("这是父类中：子类和父类中重名都有的方法SameMethods");
    };
    
    // 6-2：通过方法访问成员变量或成员方法的情况：
    public void msf(){
        System.out.println(SameProp);//这是父类中：子类和父类中重名都有的属性SameProp   
        SameMethods();//这是父类中：子类和父类中重名都有的方法SameMethods

        // 访问子类中不同名的属性或方法：
        // System.out.println(name2);//FatherClass.java:22: 错误: 找不到符号：System.out.println(name2)中name2;
        // method2();//错误: 找不到符号：method2()中method2;
    }

    // 定义不同名属性和方法供子类mss方法访问：
    String name1 = "父类中name1";
    public static void method1(){
        System.out.println("父类中的method1");
    }

    // 7-2:当局部变量和子类中成员变量及父类中成员变量同时重名时的访问规则：
    String threeSameStrs = "父类中的threeSameStrs";
}

// 2.定义一个继承了FatherClass类的子类SonClass：子类的定义需要使用关键字:extends,如：
public class SonClass extends FatherClass{//定义子类的基本格式：public class 子类名 extends 父类名{}
    // 定义子类中的方法和属性：
    String SonStr1 = "这是子类SonClass中的SonStr1";
    public static void SonMethods(){
        System.out.println("子类SonClass中的SonMethods方法执行了");
    }   

    // 定义与父类重名的属性和方法：
    String SameProp = "这是子类中：子类和父类中重名都有的属性SameProp";
    public static void SameMethods(){
        System.out.println("这是子类中：子类和父类中重名都有的方法SameMethods");
    };

     // 6-2：通过方法访问成员变量或成员方法的情况：
     public void mss(){
        System.out.println(SameProp);//这是子类中：子类和父类中重名都有的属性SameProp 
        SameMethods();//这是子类中：子类和父类中重名都有的方法SameMethods
        
        // 访问父类中不同名的属性或方法：
        System.out.println(name1);//父类中name1
        method1();//父类中的method1
    }

    // 定义不同名属性和方法供父类msf方法访问：
    String name2 = "子类中name2";
    public static void method2(){
        System.out.println("子类中的method2");
    }
    
    // 7-1:当局部变量和子类中成员变量及父类中成员变量同时重名时的访问规则：
    String threeSameStrs = "子类中的threeSameStrs";
    public void threeSameStr(){
        String threeSameStrs = "局部变量中的threeSameStrs"; 
        System.out.println(threeSameStrs);//局部变量中的threeSameStrs
        System.out.println(this.threeSameStrs);//子类中的threeSameStrs
        System.out.println(super.threeSameStrs);//父类中的threeSameStrs
        // 访问局部变量直接写，访问本类中变量通过this.变量名，访问父类中的变量通过super.变量名;
    }
}

// 3.定义一个TestSonObj类，用于测试继承关系中子类访问父类中的属性或方法：
public class TestSonObj{
    public static void main(String[] args){
        // 4-1：使用子类SonClass类创建一个对象：sonObj,如：
        SonClass sonObj = new SonClass();

        // 4-2：通过子类SonClass定义的sonObj对象调用父类FatherClass中的成员变量和方法，如：
        System.out.println(sonObj.FatherStr1);//这是FatherClass父类中的FatherStr1
        sonObj.FatherMethods();//父类FacherClass中的FatherMethods方法执行了
        //虽然子类中没有定义以上两个方法和变量，但是通过继承可以将父类中的属性或行为继承到子类中，子类可以定义多个来继承父类，这样可以节省很多公共代码。

        // 4-3:访问子类和父类重名的属性和方法：
        // 直接通过.的方式访问：
        System.out.println(sonObj.SameProp);//这是子类中：子类和父类中重名都有的属性SameProp
        sonObj.SameMethods();//这是子类中：子类和父类中重名都有的方法SameMethods

        // 创建一个FatherClass类对象：fo,用来测试重名属性和方法：
        FatherClass fo = new FatherClass();
        System.out.println(fo.SameProp);//这是父类中：子类和父类中重名都有的属性SameProp
        fo.SameMethods();//这是父类中：子类和父类中重名都有的方法SameMethods
        // 对于子类和父类中重名的属性和方法直接通过对象.点出属性或方法时，点.左边对象是用谁创建的就用（访问）谁的重名方法或属性；

        //间接通过方法访问成员变量或成员方法的情况：
        sonObj.mss();
        // 对于子类和父类中重名的属性或方法通过方法间接访问时，各自访问的是自己本身的属性或方法；
        // 对于子类和父类中不重名且本类中没有的属性或方法通过方法间接访问时，子类会向父类中查找，没有则会报错，而对于父类而言，不会像子类查找，本类没有则直接报错；

        // 7-3:当局部变量和子类中成员变量及父类中成员变量同时重名时的访问规则：
        sonObj.threeSameStr();
        // 访问局部变量直接写，访问本类中变量通过this.变量名，访问父类中的变量通过super.变量名;
    }
}

// 5.定义一个TestFatherObj类，用于测试继承关系中是否有父类访问子类中的属性或方法的关系：
public class TestFatherObj{
    public static void main(String[] args){
        // 6-1：使用父类FatherClass类创建一个fatherObj对象：
        FatherClass fatherObj = new FatherClass();
        // System.out.println(fatherObj.SonStr1);//TestFatherObj.java:5: 错误: 找不到符号：System.out.println(fatherObj.SonStr1)中SonStr1;
        // fatherObj.SonMethods();//TestFatherObj.java:7: 错误: 找不到符号:fatherObj.SonMethods()中的SonMethods;
        // 父类是无法访问子类中的属性和方法的，也就是说继承中没有父类访问子类中的属性或方法的关系。

        // 6-2:访问子类和父类重名的属性和方法：
        // 直接通过点访问属性或方法的情况：
        System.out.println(fatherObj.SameProp);//这是父类中：子类和父类中重名都有的属性SameProp
        fatherObj.SameMethods();//这是父类中：子类和父类中重名都有的方法SameMethods
        
        // 创建一个SonClass类对象：so,用来测试重名属性和方法：
        SonClass so = new SonClass();
        System.out.println(so.SameProp);//这是子类中：子类和父类中重名都有的属性SameProp
        so.SameMethods();//这是子类中：子类和父类中重名都有的方法SameMethods
        // 对于子类和父类中重名的属性和方法直接通过对象.点出属性或方法时，点.左边对象是用谁创建的就用（访问）谁的重名方法或属性；

        //间接通过方法访问成员变量或成员方法的情况：
        fatherObj.msf();
        // 对于子类和父类中重名的属性或方法通过方法间接访问时，各自访问的是自己本身的属性或方法；
        // 对于子类和父类中不重名且本类中没有的属性或方法通过方法间接访问时，子类会向父类中查找，没有则会报错，而对于父类而言，不会像子类查找，本类没有则直接报错；
    }
}

成员方法重写：

子类和父类中出现重名且方法参数一致的成员方法时，这种情况称为方法重写，也叫方法覆盖，方法覆写；与方法重载需区别，重载是方法名相同，但是方法参数列表不同。

注解：@Override

@Override用于检测是否存在方法重写，其使用规则为：在定义方法时在public上一行直接写@Override，注意，后面不能跟标点符号。

public class OverrideFather{
    public void overRideMethod(){
        System.out.println("父类中的overRideMethod方法");
    }

    // 1-1:方法重写中：子类的返回值的范围一定要小于等于父类返回值范围，如：
    public Object messages(){
        return "123";
    }
    // 2-1:子类方法的权限修饰符必须大于父类方法的权限修饰符，权限修饰符权限大写：public > protected > (default,留空什么也不写) > private
    Object say(){
        return "hello";
    }
}

public class OverrideSon extends OverrideFather{
    @Override
    public void overRideMethod(){
        super.overRideMethod();//父类中的overRideMethod方法
        System.out.println("子类中的overRideMethod方法");//子类中的overRideMethod方法
    }

      // 1-2:方法重写中：子类的返回值的范围一定要小于等于父类返回值范围，如：
      public String messages(){
        return "123456";
    }

    // 2-1:子类方法的权限修饰符必须大于父类方法的权限修饰符，权限修饰符权限大写：public > protected > (default,留空什么也不写) > private
    public Object say(){
        return "hello123";
    }

    // 3.子类的构造方法中会默认调用父类的无参构造方法,其是用super()调用；
    // 继承关系中，父子类构造方法的访问特点：
    // 3-1： 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
    // 3-2： 子类构造可以通过super关键字来调用父类重载构造。
    // 3-3： super的父类构造调用，必须是子类构造方法的第一个语句。不能一个子类构造调用多次super构造。
    // 子类必须调用父类构造方法，不写则赠送super()；写了则用写的指定的super调用，super只能有一个，还必须是第一个。
    
    public OverrideSon(){//子类构造方法：
        super();//子类无参构造器中默认会调用父类无参构造方法，super()调用必须是第一个语句，如果构造方法自己写了，那么一定要记得调用父类的构造方法：使用super()调用即可。
    }
    /*
    总结：super关键字的用法有三种：
    1. 在子类的成员方法中，访问父类的成员变量：super.变量名
    2. 在子类的成员方法中，访问父类的成员方法：super.方法名()
    3. 在子类的构造方法中，访问父类的构造方法：super()
    */

    // 4.this关键字：用来访问本类中的内容，用法有三种：
    // 4-1：在本类的成员方法中访问本类的成员变量：
    String strthis = "123456";
    public void testThis(){
        String strthis = "123";
        System.out.println(strthis);//123,访问的为局部变量
        System.out.println(this.strthis);//123456,访问的为成员变量
    } 
    // 4-2：在本类的成员方法中访问另一个成员方法，如：this.methods(),这种方式只是起强调作用，直接通过方法名()也可以调用:methods();
    // 4-2:在本类的构造方法中访问另一构造方法，如：
    public OverrideSon(){
        this(String hello);//在本类中的无参构造方法中调用了有参构造方法,这里也必须是构造方法中的第一语句，因此它们不能同时使用。
    }
    public OverrideSon(String str){
        
    };
}

public class OverrideSonObj{
    public static void main(String[] args){
        OverrideSon orobj = new OverrideSon();
        orobj.overRideMethod();
        System.out.println(orobj.messages());//123456
        System.out.println(orobj.say());//hello123
        // 覆盖重写常用于对老的类的更新，但是并非更新原文件，而是通过继承和方法重写，重新写一个类。
    }
}

java语言继承的特点：

1.java语言是单继承的：父类只能有一个（只能继承一个类），但是可以多级继承（继承一个继承了某类的类）。

2.一个类可以被多个类继承。

提示：本文图片等素材来源于网络，若有侵权，请发邮件至邮箱：[e-mail]联系笔者删除。
笔者：苦海