精华内容
下载资源
问答
  • java中super关键字的三种用法
  • Java中super关键字及super()的使用

    万次阅读 多人点赞 2020-07-06 22:52:15
    super关键字使用: (1)super是一个关键字; (2)super和this很类似,我们对比着学习。 先复习一下this关键字的使用。 this关键字: this能出现在实例方法和构造方法中; this的语法是“this.”和“this()”; ...

    Java中super关键字及super()的使用:

    1、super的使用:

    (1)super是一个关键字。

    (2)super和this很类似,我们对比着学习。


    2、先复习一下this关键字的使用。

    (1)this能出现在实例方法和构造方法中;
    (2)this的语法是“this.”和“this()”;
    (3)this不能出现在静态方法中;
    (4)this大部分情况下是可以省略的;
    (5)this.什么时候不能省略呢?
    在区分局部变量和实例变量时不能省略。例如:

    Public void setName(String name){
    	this.name = name;
    }
    

    (6)this()只能出现在构造方法的第一行,通过当前的构造方法去调用“本类”中的对应的构造方法,目的是:代码复用。


    3、super关键字:

    (1)super能出现在实例方法和构造方法中。

    (2)super的语法是“super.”和“super()”。

    (3) super不能出现在静态方法中。

    (4) super大部分情况下是可以省略的。

    (5)super.什么时候不能省略呢?
    别急,我们想一下this指向的是什么,是当前对象自己。super和this类似,它指向了当前对象自己的父类型特征(也就是继承过来的那些东西)。

    super和this区别是:this可以看做一个引用变量,保存了该对象的地址,是当前对象整体,而super代表的是父类型特征,是子类局部的一些东西,这些继承过来的东西已经在子类里面了,你可以输出整体this,但不能输出父类型特征super。因为super指向的东西不是一个整体,没法打印输出。

    System.out.println(this);  //输出this.toString()的值
    System.out.println(super);  //编译报错,需要'.'
    

    当在子类对象中,子类想访问父类的东西,可以使用“super.”的方式访问。例如:方法覆盖后,子类内部虽然重写了父类的方法,但子类也想使用一下父类的被覆盖的方法,此时可以使用“super.”的方式。当子类中出现和父类一样的属性或者方法,此时,你要想去调用父类的那个属性或者方法,此时“super.”不能省略。

    this和super都只能在对象内部使用。
    this代表当前对象本身,super代表当前对象的父类型特征。


    总结:“this.”是一个实例对象内部为了区分实例变量和局部变量。
    而“super.”是一个实例对象为了区分是子类的成员还是父类的成员。
    父类有,子类也有,子类想访问父类的,“super.”不能省略。**


    (6)super()只能出现在构造方法的第一行,通过当前的构造方法去调用“父类”中的对应的构造方法,目的是:创建子类对象时,先初始化父类型特征。

    用通俗的话来讲,要想有儿子,得先有父亲。


    我们来看下面代码:
    写两个类,Animal和Cat,Cat继承Animal。

    //父类,Animal类
    class Animal {
    	//构造函数
    	public Animal() {
    		System.out.println("Animal类的无参数构造函数执行");
    	}
    }
    
    //子类,Cat类
    class Cat extends Animal{
    	//构造函数
    	public Cat() {
    		System.out.println("Cat类的无参数构造函数执行");
    	}
    }
    

    执行下面一行代码:

    Cat c1 = new Cat(); 
    

    运行输出结果为:
        Animal类的无参数构造函数执行
        Cat类的无参数构造函数执行

    我们发现实例化一个子类的对象,也就是调用了子类的构造方法,为什么父类的无参数构造方法也执行了,并在子类构造方法执行之前就已经执行了父类的无参数构造方法,好奇怪。

    刚刚在上面的super关键字的使用第6点,我已经说了,super()和this()方法一样,都只能在构造方法的第一行出现。我们猜想,难道子类的构造方法第一行有一个隐形的super()方法?答案是肯定的。

    我们把子类的构造方法的第一行给它加上super():

    //子类,Cat类
    class Cat extends Animal{
    	//构造函数
    	public Cat() {
    		super();
    		System.out.println("Cat类的无参数构造函数执行");
    	}
    }
    

    再执行下面代码:

    Cat c1 = new Cat(); 
    

    运行输出结果为:
        Animal类的无参数构造函数执行
        Cat类的无参数构造函数执行

    和刚才的子类构造方法没加super()是一样的。

    所以说当子类的构造方法内第一行没有出现“super()”时,系统会默认给它加上无参数的"super()"方法。


    阅读仔细的人会发现,为什么是没有“this()和super()”就写上“super()”?有“this()”就不能写上“super()”吗?那我问你,当构造方法第一行有"this()"时,你还能手动添加“super()”吗?显然不行,因为“this()”也只能出现在第一行,你不能在它前面写任何代码。所以我们又得出一个结论:构造方法中“this()”和“super()”不能同时出现,也就是“this()”和“super()”都只能出现在构造方法的第一行。

    上面谈的都是无参数的“super”方法,我们也可以在构造方法的第一行使用有参数的“super(父类构造函数的参数列表)”,但值得注意的是,当子类构造方法执行有参数的“super(参数列表)”方法,你得确保父类中也有对应的有参数构造方法,不然会编译报错。同样我要提醒一下,当子类构造方法的第一行执行super()无参数方法,那么父类中一定要有无参数构造方法,有的人可能会在父类中写了有参数的构造方法,却忽略了写无参数构造方法,那么在子类构造方法内就会报错,因为当你在一个类中写了有参数的构造方法时,无参数构造方法就会不存在,你需要自己补上无参数的构造方法,这是一个良好的编程习惯。

    无论你子类构造方法有没有“this()”和“super()”方法,实例化子类对象一定一定会执行对应的父类构造方法,即不管实例化了一个怎样的孩子,它一定会先实例化一个对应的父亲。


    下面给道例题练习一下this()和super()方法:

    public class MyTest {
    	
    	public static void main(String[] args) {
    		new Cat(); 
    	}
    }
    
    //父类,Animal类
    class Animal {
    	//构造函数
    	public Animal() {
    		super();
    		System.out.println("1:Animal类的无参数构造函数执行");
    	}
    	public Animal(int i) {
    		super();
    		System.out.println("2:Animal类的有int参数构造函数执行");
    	}
    }
    
    //子类,Cat类
    class Cat extends Animal{
    	//构造函数
    	public Cat() {
    		this("");
    		System.out.println("3:Cat类的无参数构造函数执行");
    	}
    	public Cat(String str) {
    		super(5);
    		System.out.println("4:Cat类的有String参数构造函数执行");
    	}
    }
    

    输出结果为:
    2:Animal类的有int参数构造函数执行
    4:Cat类的有String参数构造函数执行
    3:Cat类的无参数构造函数执行

    我们又可以得出一个结论:不管你创建什么对象,Object对象的无参数构造方法一定会先执行,因为Object是所有类的根类。


    说了这么多,super()到底什么时候使用?来看下面代码:

    public class MyTest {
    	
    	public static void main(String[] args) {
    		Cat c1 = new Cat(3); 
    		System.out.println("名字:" + c1.getName() + ",年龄:" + c1.getAge());
    	}
    }
    
    //父类,Animal类
    class Animal {
    	//私有属性:名字
    	private String name;
    	
    	//setter and getter
    	public void setName(String name) {
    		this.name = name;
    	}
    	public String getName() {
    		return name;
    	}
    	
    	//构造函数
    	public Animal() {
    		
    	}
    	public Animal(String name) {
    		this.name = name;
    	}
    }
    
    //子类,Cat类
    class Cat extends Animal{
    	//私有字段:年龄
    	private int age;
    	
    	//setter and getter
    	public void setAge(int age) {
    		this.age = age;
    	}
    	public int getAge() {
    		return age;
    	}
    	
    	//构造函数
    	public Cat() {
    		
    	}
    	public Cat(int age) {
    		this.age = age;
    	}
    }
    

    输出结果:名字:null,年龄:3

    我们也知道,没有给c1的name赋值嘛,当然为默认值null啦。
    确实如此,所以我们给Cat加一个构造方法,给name和age都赋值。
    如下:

    public Cat(String name, int age) {
    	this.name = name; //报错
    	this.age = age
    }
    

    显然这样做是会报错的,因为name已经被父类封装成private的了,不能直接访问,可能有的人会这样做:

    public Cat(String name, int age) {
    	setName(name);
    	this.age = age;
    }
    

    显然这样做的确可以做到给父类的name赋值,但这样做是不建议的,我们在构造方法中通常只调用构造方法,不会去调用实例方法,况且当不止一个变量时,用set方法时,我们就要调用好多个实例方法去完成多个变量的赋值。这时候为什么不考虑使用super()方法呢?如下:

    public Cat(String name, int age) {
    	super(name);
    	this.age = age;
    }
    

    这样就显得文雅,美观多了。


    总结:
    1、this和super一样,都是对象内部的引用变量,只能出现在对象内部;

    2、 this指向当前对象自己,super指向当前对象的父类型特征,故this的东西比super多,也就是super是this的一部分;

    3、 this()和super()都只能出现在构造方法的第一行,故this()和super()方法不能共存,当一个类的构造方法第一行中没有this(),也没有super(),系统默认有super()方法;

    4、this()是构造方法中调用本类其他的构造方法,super()是当前对象构造方法中去调用自己父类的构造方法。


    展开全文
  • Java中super关键字使用 1、使用super操作呗隐藏的成员变量和方法 ​ 子类一旦隐藏了继承的成员变量,那么子类创建的对象就不再拥有该变量,该变量将归super所拥有。同样的,对于隐藏的方法调用也是有super所有。...

    Java中super关键字的使用

    1、使用super操作呗隐藏的成员变量和方法

    ​ 子类一旦隐藏了继承的成员变量,那么子类创建的对象就不再拥有该变量,该变量将归super所拥有。同样的,对于隐藏的方法调用也是有super所有。下面将举例说明用法:

    public class SuperTest {
        static class Sum{
            int n;
            int f(){
               int sum = 0;
                for (int i = 1; i <= n; i++) {
                    sum += i;
                }
                return sum;
            }
        }
    
        static class Average extends Sum{
            int n;
    
            float a(){
                super.n = n;
                float c;
                c = super.f();
                return c/n;
            }
        }
    
        public static void main(String[] args) {
            Average average = new Average();
            average.n = 100;
            float a = average.a();
            System.out.println("平均值为:" + a);
        }
    }
    

    输出结果为:平均值为:50.5

    2、使用super调用父类的构造方法

    ​ 当用子类的构造方法创建一个子类的对象时,子类的构造方法总是先调用父类的某个构造方法,也就是说,如果子类的构造方法没有明显的指明使用父类的哪个构造方法,子类就调用父类的不带参数的构造方法。

    ​ **由于子类不继承父类的构造方法,因此,子类在其构造方法中需要使用super来调用父类的构造方法,而且super必须是子类构造方法中的头一条语句。**即如果在子类的构造方法中没有明显的写出super关键字来调用父类的构造方法时,则默认有super();

    public class SuperTest01 {
        static class Student{
            int number;
            String name;
            //无参构造
            Student(){
    
            }
            //有参构造
            Student(int number,String name){
                this.number = number;
                this.name = name;
                System.out.println("我的名字是:" + name + "\n" + "我的学号是:" + number);
            }
        }
    
        static class UniverStudent extends Student{
            boolean married;
            UniverStudent(boolean married, int number, String name){
                super(number,name);
                this.married = married;
                System.out.println("婚否:" + married);
            }
        }
    
        public static void main(String[] args) {
            UniverStudent univerStudent = new UniverStudent(false, 101, "小梁");
        }
    }
    

    输出结果:

    我的名字是:小梁
    我的学号是:101
    婚否:false

    展开全文
  • 主要介绍了javasuper关键字用法实例解析,较为详细的分析了super关键字的用法及内存分布,需要的朋友可以参考下
  • Java中super关键字用法

    2019-08-02 16:35:30
    super关键字主要用在子类继承父类时,咱们程序员在子类的方法里面想要调用父类的方法,变量时。在子类的main方法里面是不让用super、this的,因为main是static修饰的,static修饰的方法里面不让用这两个关键字。 1...

    super关键字主要用在子类继承父类时,咱们程序员在子类的方法里面想要调用父类的方法,变量时。在子类的main方法里面是不让用super、this的,因为main是static修饰的,static修饰的方法里面不让用这两个关键字。

    1、super.父类的变量

    注意,父类的变量如果是private修饰的不可被调用,而如果是public、protected、以及默认(就是没有加访问修饰符的)的访问修饰权限,则根据这三个访问修饰的访问权限而定。public肯定是可以被访问到的,protected的话就是不同包的非子类无法访问到,默认的就是只要在同包就可以,不同包就不行。

    2、super.父类的方法(参数列表)

    这个就是调用父类的方法,记得传参数以及它的访问权限和上面是一样的。

    3、super(参数列表),写在构造函数第一行!!!

    第三个方法是最重要的,super(参数列表),在子类的方法(一般是构造方法)里面调用父类的构造函数,并且编译器会根据你参数列表的不同,给你匹配对应的父类的构造方法,这句代码写在子类构造函数的第一行。一般当你用eclipse的自动生成构造函数时,它会自己给加这句代码。所以,咱们实例化子类的对象时,就会出现父类的构造函数先执行,然后才是子类的构造函数。

    注意这种情况:super(),调用父类的无参构造函数,而我们知道,当一个类没有人为的写明构造函数时,这个类会有一个默认的无参构造函数,当我们只要自己写了构造函数之后,这个默认的无参构造函数便会失效。这个概念在这里同样适用:当没有在构造函数里面写明super(参数列表)时,编译器会自动在第一行加上super(),用来调用父类的无参构造函数。如果我们写明super(参数列表),那么编译器就不加那句话了。

    展开全文
  • 1.JAVA中super关键字使用

    千次阅读 2019-09-09 00:16:29
    1.super()的使用示例——子类重写,调用父类方法 public class A { private String nameA="父"; public void getName() { System.out.println("父类:"+nameA); } public static void main(String[] ...

    1.super的使用 一一一子类重写父类的方法

    public class A {
    	
    	private String nameA="父";
    	
    	public void getName() {
    		System.out.println("父类:"+nameA);
    	}
    	public static void main(String[] args) {
    		
    	}
    	
    }
     //========================================
     public class B extends A{
    	private String nameB="子";
    	
    	@Override
    	public void getName() {
    		System.out.println("子类:"+nameB);
    		super.getName();
    	}
    	
    	public static void main(String[] args) {
    		B b=new B();
    		b.getName();
    	
    	}
    }
    

    运行结果
    在这里插入图片描述
    结果分析:

    在子类B中,重写了父类的getName方法,如果在重写的getName方法我们去调用父类的相同方法,就必须要通过super关键字显示的指明出来。

    如果不明确出来,MyEclipse会因父类子类混乱而报错“如图一”,(在其他博主中有这样提到:*按照子类优先的原则,相当于还是再调用重写的getName()方法,此时就形成了死循环,执行后会报java.lang.StackOverflowError异常。*然而我测试的却直接报错)当我将super改成this时就会出现上面提到的死循环“如图二”。
    图一:
    在这里插入图片描述
    图二:在这里插入图片描述

    2.super的使用 一一一子类重写父类的变量

    public class A {
    
    	 String nameA="父";
    }
     
    public class B extends A{
    	 String nameA="子";
    //=======================================	
    	
    	public void getName() {
    		System.out.println("子类:"+nameA);
    		System.out.println("父类:"+super.nameA);
    	}
    	
    	public static void main(String[] args) {
    		B b=new B();
    		b.getName();
    	
    	}
    }
    

    运行结果:
    在这里插入图片描述
    分析:

    因为子类B中有一个和父类一样的字段,所有父类字段被隐藏了,为了获得父类的字段我们就必须使用关键字super
    注:通过super是不能访问父类private修饰的变量和方法的,因为这个只属于父类的私有成员。

    3.super的使用 一一一子类的构造方法中

    在子类中使用super调用超(父)类的构造方法时,super语句必须放在子类的构造方法中,并作为子类构造方法的第一条语句。

    总结
    1、调用父类被子类重写的方法;

    2、调用父类被子类重定义的成员变量;

    3、调用父类的构造方法;

    注:在子类的构造方法中,如果没有显式使用super关键字调用超(父)类的某个构造方法,系统会默认在子类中执行super()语句,即自动调用无参构造方法。如果此时超(父)类没有提供无参的构造方法,编译器就会报错。因此用super调用超类构造方法时要保证超类中定义了相对应的构造方法。

    例:
    在这里插入图片描述在这里插入图片描述因为Employee类中没有显式使用super调用超类的构造方法,所以系统自动调用超类的无参构造方法,但是超类无法提供无参构造方法。所以报错。

    改正代码:
    在这里插入图片描述在这里插入图片描述
    此时只需要在超(父)类中添加一个无参构造方法即可。

    展开全文
  • JAVASUPER关键字的三种用法 1.在子类成员方法中,访问父类的成员变量 2.在子类的成员方法中,访问父类的成员方法 3.在子类的构造方法中,访问父类的构造方法 子类 package demo08; /* * 1.在子类成员方法中,访问...
  • 主要介绍了Java super关键字用法,结合具体案例形式分析了java super关键字调用父类构造方法、属性及方法等相关操作技巧与注意事项,需要的朋友可以参考下
  • java中super关键字详解

    2021-09-16 10:28:53
    super是用于子类对象访问父类内容时的关键字 示例代码: //先创建两个类,父类和子类。 //父类有有参构造方法和无参构造方法。 class Father { String name; String age; int id = 1001; public Father...
  • java中super关键字是一个引用变量,用于引用父类对象。关键字“super”以继承的概念出现在类。主要用于以下情况: 1.使用super与变量:当派生类和基类具有相同的数据成员时,会发生此情况。在这种情况下,JVM...
  • Java中super关键字

    2020-12-22 19:41:07
    因为子类的成员变量或方法名优先级高,所以子类的同名成员变量或方法隐藏了父类的成员变量或方法,但是我们如果想要使用父类的这个成员变量或方法,需要用到super。  3.super(参数):调用
  • super关键字用法有三种: 1.在子类的成员方法中,访问父类的成员变量。 2.在子类的成员方法中,访问父类的成员方法。 3.在子类的构造方法中,访问父类的构造方法。 public class Zi extends Fu { int num = 20; ...
  • Java编程中super关键字用法

    千次阅读 2016-11-29 23:02:14
    详解Java编程中super关键字用法 作者:孤傲苍狼 字体:[增加 减小] 类型:转载 时间:2015-10-19 我要评论 这篇文章主要介绍了Java编程this与super关键字用法,包括从内存结构方面分析super的作用域,需要的...
  • 在子类的成员方法中,访问父类的成员变量 在子类成员方法中,访问父类的成员方法 在子类的构造方法中,访问父类的构造方法: 可以看一下这偏文章:https://blog.csdn.net/gymaisyl/article/details/102821856...
  • Java中super关键字及其作用

    千次阅读 2020-03-30 18:08:34
    Java中super关键字及其作用 super关键字及其作用 A:super关键字指代父类对象引用(super代表父类存储空间的标识) B:作用: a:访问被子类隐藏的父类同名成员变量和成员方法 ; b:调用父类构造方法,且必须在子类构造...
  • Java 常识(013):Java中super关键字

    千次阅读 2019-08-10 23:39:00
    文章目录1、Java super 是什么2、为什么要用 super 关键字3、Java super用法3.1、使用 super 调用父类的构造方法3.2、引用父类实例变量3.3、调用父类方法4、super 关键字与 this 关键字的区别 1、Java ...
  • Java中super关键字详解

    千次阅读 2018-12-30 14:48:36
    Java的基础学习,慢慢接触到许多陌生的关键字,今天来讲一下我所认识的super关键字 它的使用场景为:有继承在⭐(必须在继承下才能使用super) 一.super调用(父类)构造方法 看下面这段代码 class Person{...
  • super( )的用法 1. super.XXX 说明:这里的XXX指的是父类的成员变量名即父类的属性 2. super.XXX( ) 说明:这里的XXX是父类的其中一个方法名 3. super( ) 说明:这种形式指的是:调用父类没有参数的构造方法...
  • Java中super关键字

    万次阅读 多人点赞 2018-05-18 11:20:04
    本文重点介绍super关键字,在Java中的作用以及用法。一、定义 它是一个指代变量,用于在子类中指代父类对象。二、应用2.1 应用范围 只能用于构造函数和实例方法中,不能用于类(静态)方法中。原因是super指代的...
  • Java中super关键字用法

    千次阅读 2021-01-05 11:02:28
    1.在子类的成员方法中,访问父类的成员变量 2.在子类的成员方法中,访问父类的成员方法 3.在子类的构造方法中,访问父类的构造方法 下面有一些代码关于this和super在继承... System.out.println("super关键字用法");
  • Java中super关键字介绍

    2020-09-18 23:09:08
    由于子类不能继承父类的构造方法,因此,如果要调用父类的构造方法,可以使用 super 关键字super 可以用来访问父类的构造方法、普通方法和属性。 super 关键字的功能: 在子类的构造方法中显式的调用父类构造方法...
  • 主要介绍了Javasuper关键字与instanceof运算符使用方法,是Java入门学习的基础知识,需要的朋友可以参考下
  • 主要介绍了Java super关键字使用方法详解的相关资料,希望通过本文能帮助到大家,让大家对super关键字彻底掌握,需要的朋友可以参考下
  • super关键字 1. super.属性和super.方法 如下,有一父类Transport package test2; public class Transport { String typeOfVehicle="小汽车";//车辆类型 float speed=150.2f;//车速 public void run() { ...
  • Javasuper关键字详解

    2021-01-03 23:46:23
    这里分享下一java中super关键字的相关知识。 super关键字: super关键字代表了父类空间的引用。 super关键字的作用: 1. 子父类存在同名的成员时,在子类默认是访问子类的成员,可以通过super关键字指定访问父类的...
  • 今天来谈一下super用法以及使用时应该注意的事项。 下面先列举出容易出错的地方: 图一 图一中第十五行编译报错:There is no default constructor available in ‘AddClass’(这里缺少缺省函数),在处理这个...
  • 主要介绍了Java编程this与super关键字用法,包括从内存结构方面分析super的作用域,需要的朋友可以参考下
  • Java中this关键字和super关键字用法

    千次阅读 2016-11-03 20:21:20
    Java中,this通常指当前对象,super则指父类的。当你想要引用当前对象的某种东西,比如当前对象的某个方法,或当前对象的某个成员,你便可以利用this来实现这个目的,当然,this的另一个用途是调用当前对象的另一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 126,191
精华内容 50,476
关键字:

java中super关键字的用法

java 订阅