精华内容
下载资源
问答
  • 主要介绍了Java super关键字用法,结合具体案例形式分析了java super关键字调用父类构造方法、属性及方法等相关操作技巧与注意事项,需要的朋友可以参考下
  • 主要介绍了Java super关键字使用方法详解的相关资料,希望通过本文能帮助到大家,让大家对super关键字彻底掌握,需要的朋友可以参考下
  • Java super关键字用法

    千次阅读 2015-03-20 14:02:15
    分别介绍了在构造方法和非构造方法super关键字的四种不同的用法

    构造方法中的super关键字

    在Java子类的构造方法中可以通过super关键字来调用父类的构造方法。其用法为:
    1) super(); 访问父类中的无参构造函数
    2) super (paras…); 访问父类中的成员函数yyy
    super()来调用父类无参的构造方法,但即使不使用super(),默认也会调用父类无参的构造方法。父类无参的构造方法可以是自定义的无参构造方法,也可以是编译器自动生成的默认构造方法。但如果父类中定义了有参的构造方法,但没有定义无参的构造方法,这时编译器不会生成默认构造函数,也就不能通过super()来调用构造方法。此外,如果父类中定义了private的无参构造方法,也不同通过super()来调用。
    super(paras…);用来调用父类中某个有参的构造方法。
    super调用父类的构造方法,必须放在子类构造方法的第一行中执行。如果调用的有参的父类构造方法,在super的参数中不能用子类中的非static成员变量(可以使用static成员变量,因为static成员变量在构造方法执行前就已经初始化),也不能使用this或super的相关调用。例如super(super.getClass().getName());
    在构造方法中也可以使用super关键字来访问父类中的成员变量和成员函数。其用法和非构造方法中的super关键字用法相同。

    非构造方法中的super关键字

    在Java子类中可以通过通过super关键字来调用父类中的成员变量和方法。其用法是。
    1) super.xxx; 访问父类中的成员变量xxx
    2) super.yyy(paras…); 访问父类中的成员函数yyy
    super关键字访问父类的成员变量和成员函数时不能越过访问权限的控制,不能访问父类中private的成员变量和方法。例如:

    class a {
        private int mNum = 0;
    }
    class b extends a {
        public void setNum(int i) {
            super.mNum = i;     //错误,不能访问父类的private成员
        }
    }

    在有多层的继承关系时,super调用只能自身父类的成员变量和方法,不能越过父类直接调用父类的父类中的成员变量或方法。当然如果父类的父类中的成员变量或方法被父类继承,那么是可以通过super来调用该成员变量和方法的,但这时实际调用的是父类中的成员变量和方法。例如:

    class a {
        protected int mNum = 0;
        public void setNum(int i) {
            mNum = i;
        }
    }
    class b extends a {
        public void setNum(int i) {
            mNum = i * i;
        }
    }
    class c extends b {
        public void setNum(int i) {
            super.setNum(i);        //调用的是b中的setNum()方法
            super.super.setNum(i);  //错误,不支持的用法
        }
    }
    class a {
        protected int mNum = 0;
        public void setNum(int i) {
            mNum = i;
        }
    }
    class b extends a {
    }
    class c extends b {
        public void setNum(int i) {
            super.setNum(i);    //正确,虽然b中没有实现setNum(),但b中继承了a的setNum()函数,
                                //c中调用super.setNum()调用的是b的setNum()函数,可以执行。
        }
    }
    展开全文
  • 主要介绍了javasuper关键字用法实例解析,较为详细的分析了super关键字的用法及内存分布,需要的朋友可以参考下
  • java super关键字

    千次阅读 2019-02-20 17:32:16
    java中有很多关键字,我们需要掌握和理解这些...如果你的子类重写了父类中的方法,你可以通过使用super关键字来回调父类中被重写的方法。你也可以使用super关键字来查询一个隐藏域。考虑下面这两个类,父类Supe...

    在java中有很多关键字,我们需要掌握和理解这些关键字怎么使用,这样我们才可以写出更健壮和高效的程序,这篇文章主要来说一下java中的关键字super。super关键字有两种用途,分别是:

    1. 可以使用super关键字来访问父类的成员

    如果你的子类重写了父类中的方法,你可以通过使用super关键字来回调父类中被重写的方法。你也可以使用super关键字来查询一个隐藏域。考虑下面这两个类,父类SuperClass和子类SubClass:

    package com.java8.learn;
    
    public class SuperClass {
    
        public void printMethod(){
            System.out.println("superClass printMethod");
        }
    }
    
    
    package com.java8.learn;
    
    public class SubClass extends SuperClass {
        @Override
        public void printMethod() {
            super.printMethod();
            System.out.println("subClass printMethod");
        }
    
        public static void main(String[] args){
            SubClass subClass = new SubClass();
            subClass.printMethod();
        }
    }
    
    

    控制台输出结果:

    superClass printMethod
    subClass printMethod
    

    从上面的程序运行结果可以看出,创建SubClass的对象并调用了该类中的printMethod方法,而该方法中又使用了super关键字调用了父类中的printMethod方法,所以最终的打印结果如上图所示。

    1. 可以使用super关键字来访问父类的构造方法

    通过使用super关键字调用父类的构造方法必须在子类构造方法的第一行。可以是调用无参的super();也可以是调用父类有参数的构造方法super(parameter,list);

    如果构造函数未显式调用超类构造函数,则Java编译器会自动插入对超类的无参数构造函数的调用。 如果超类没有无参数构造函数,则会出现编译时错误。

    在这里插入图片描述

    展开全文
  • 1.JAVAsuper关键字使用

    千次阅读 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关键字及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()是当前对象构造方法中去调用自己父类的构造方法。


    展开全文
  • javasuper关键字的三种用法
  • Java super关键字详解

    万次阅读 多人点赞 2016-07-15 17:14:48
    一.super关键字作用 1:主要存在于子类方法中,用于指向子类对象中父类对象。 2:访问父类的属性 3:访问父类的函数 4:访问父类的构造函数 二.super注意的地方 this和super很像,this指向的是当前对象的调用,...
  • Java编程中super关键字用法

    千次阅读 2016-11-29 23:02:14
    详解Java编程中super关键字用法 作者:孤傲苍狼 字体:[增加 减小] 类型:转载 时间:2015-10-19 我要评论 这篇文章主要介绍了Java编程中this与super关键字用法,包括从内存结构方面分析super的作用域,需要的...
  • Javasuper关键字使用 1、使用super操作呗隐藏的成员变量和方法 ​ 子类一旦隐藏了继承的成员变量,那么子类创建的对象就不再拥有该变量,该变量将归super所拥有。同样的,对于隐藏的方法调用也是有super所有。...
  • JAVASUPER关键字的三种用法 1.在子类成员方法中,访问父类的成员变量 2.在子类的成员方法中,访问父类的成员方法 3.在子类的构造方法中,访问父类的构造方法 子类 package demo08; /* * 1.在子类成员方法中,访问...
  • 在子类的成员方法中,访问父类的成员变量 在子类成员方法中,访问父类的成员方法 在子类的构造方法中,访问父类的构造方法: 可以看一下这偏文章:https://blog.csdn.net/gymaisyl/article/details/102821856...
  • super( )的用法 1. super.XXX 说明:这里的XXX指的是父类的成员变量名即父类的属性 2. super.XXX( ) 说明:这里的XXX是父类中的其中一个方法名 3. super( ) 说明:这种形式指的是:调用父类没有参数的构造方法...
  • Java super关键字的三种用法 1、在子类的成员方法中,访问父类的成员变量 2、在子类的成员方法中,访问父类的成员方法 3、在子类的构造方法中,访问父类的构造方法 图片笔记:
  • super关键字用法有三种 : 1.在子类的成员方法中,访问父类的成员变量 2.在子类的成员方法中,访问父类成员方法 3.在子类的构造方法中访问父类的构造方法 public class Fu { int num=50; public void ...
  • #this关键字使用方法代码分析 package basic.Filea; /** * this的介绍 * this是一个引用,this变量保存了内存地址指向自己 * 每一个对象都有一个this * this不能出现在static静态方法中 * 1.this的使用方法有...
  • Java中的super关键字

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

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

    千次阅读 2021-01-05 11:02:28
    1.在子类的成员方法中,访问父类的成员变量 2.在子类的成员方法中,访问父类的成员方法 3.在子类的构造方法中,访问父类的构造方法 下面有一些代码关于this和super在继承... System.out.println("super关键字用法");
  • java中的super关键字是一个引用变量,用于引用父类对象。关键字“super”以继承的概念出现在类中。主要用于以下情况: 1.使用super与变量:当派生类和基类具有相同的数据成员时,会发生此情况。在这种情况下,JVM...
  • Java super关键字

    2018-06-07 13:19:09
    super 可以用在子类中,通过点号(.)来获取父类的成员变量和方法super 也可以用在子类的子类中,Java 能自动向上层类追溯。父类行为被调用,就好象该行为是本类的行为一样,而且调用行为不必发生在父类中,它能自动...
  • super关键字用法有三种: 1.在子类的成员方法中,访问父类的成员变量。 2.在子类的成员方法中,访问父类的成员方法。 3.在子类的构造方法中,访问父类的构造方法。 public class Zi extends Fu { int num = 20; ...
  • Java super关键字(超详细!)

    千次阅读 多人点赞 2021-04-20 19:13:00
    super是一个关键字,全部小写。 2.怎么学?super和this对比着学习。 this: this能出现在实例方法和构造方法中。 this的语法是:“this.”、“this()” this 不能 使用在静态方法中。 this. 大部分情况下是可以省略...
  • javasuper关键字详解

    2021-09-16 10:28:53
    super是用于子类对象访问父类内容时的关键字 示例代码: //先创建两个类,父类和子类。 //父类中有有参构造方法和无参构造方法。 class Father { String name; String age; int id = 1001; public Father...
  • Javasuper关键字详解

    2021-01-03 23:46:23
    这里分享下一javasuper关键字的相关知识。 super关键字: super关键字代表了父类空间的引用。 super关键字的作用: 1. 子父类存在同名的成员时,在子类中默认是访问子类的成员,可以通过super关键字指定访问父类的...
  • this关键字 this关键字,this指向对象本身,一个类可以通过this来获得一个代表它自身的对象变 量。this使用在如下三种情况中: 调用实例变量。 调用实例方法。 调用其他构造方法使用this变量的示例代码: ...

空空如也

空空如也

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

javasuper关键字用法

java 订阅