精华内容
下载资源
问答
  • 关键字super
    千次阅读
    2021-07-26 20:07:37

    1.super是一个关键字,全部小写

    2.super和this关键字对比着学习

    this:能出现在实例方法和构造器中

    this的语法:"this." 或者"this()"

    this不能使用在静态方法中

    this.大部分时间可以省略,在区分局部变量和实例变量不可以省略。

    this()只能出现在构造器中的第一行,通过当前的构造器去调用本类中的其他构造器,

    目的是方法的调用。

    super:能出现在实例方法和构造器中

    super的语法:“super.”或者“super()”

    super.属性名【访问属性名】

    super.方法名(实参) 【访问父类的方法】

    super(实参)  【调用父类的构造器】

    super不能使用在静态方法中

    super.大部分时间可以省略,

    super()只能出现在构造器中的第一行,通过当前的构造器去调用父类中的其他构造器,

    目的是创建子类对象的时候,先初始化父类型特征

    重要结论:(1)当一个构造器的第一行,既没有this(),又没有super()的话,默认会有一个

    super();

    (2)表示通过当前子类的构造器去调用父类的无参构造器,所有必须保证父类的无参构造器是存在的。

    (3)this() 和 super() 不能共存,它们都是只能出现在构造器中的第一行。

    * super关键词的使用:
    * 1、理解为父亲的...
    * 2、可以用来调用:属性(不会被覆盖、重写)、方法、构造器
    * 3、我们可以在子类的方法和构造器中,通过使用super.属性或super.方法的方式,显示的调用父类中声明的属性或方法。
    *    但是通常情况下,我们可以省略"super."
    *    特殊情况下:当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性,则必须显示的使用“super.属性”
    *    的方式,表明调用的是父类中声明的属性。
    *    特殊情况:当子类中重写了父类的方法以后,我们想在子类的方法中调用父类中被重写的方法时,则显示的使用“super.方法”
    *    的方式,表明调用的是父类中被重写的方法。
    * 4、我们可以在子类的构造器中显示的使用“super(形参)”的方式,调用父类中声明的指定的构造器
    *    “super(形参)”的使用,必须声明在子类构造器的首行(跟this一样)
    *    我们在类的构造器中,针对于“this(形参)”和“super(形参)”只能二选一,不能同时出现。
    *    在构造器的首行,没有显示的声明“this(形参)”和“super(形参)”,则默认调用的是父类中空参的构造器:super();
    *    在类的多个构造器中,至少有一个类的构造器中使用了“super(形参)”,调用父类中的构造器。

    (4)super 不是引用,也不保存内存地址,也不指向任何对象

    (5)super 只是代表当前对象内部的那一块父类型的特征

    更多相关内容
  • Java中关键字super

    2022-04-09 09:53:30
    二、使用步骤1.super关键字示例2.调用父类的构造器三、this和super区别 一、super的作用? 在Java类中使用super来调用父类中的指定操作: 1)super可用于访问父类中定义的属性 2)super可用于调用父类中定义的成员...


    一、super的作用?

    在Java类中使用super来调用父类中的指定操作:
    1)super可用于访问父类中定义的属性
    2)super可用于调用父类中定义的成员方法
    3)super可用于在子类构造器中调用父类的构造器

    注意:
    1)尤其当子父类出现同名成员时,可以用super表明调用的是父类中的成员
    2)super的追溯不仅限于直接父类
    3)super和this的用法相像,this代表本类对象的引用,super代表父类的内存空间的标识

    二、使用步骤

    1.super关键字示例

    //关键字super举例
    class Person {
    	protected String name = "张三"; 
    	protected int age;
    	public String getInfo() {
    	return "Name: " + name + "\nage: " + age;
    	}
    }
    class Student extends Person {
    	protected String name = "李四";
    	private String school = "New Oriental";
    	public String getSchool() {
    	return school;
    }
    	public String getInfo() {
    	return super.getInfo() + "\nschool: " + school;
    	}
    }
    public class StudentTest {
    	public static void main(String[] args) {
    	Student st = new Student();
    	System.out.println(st.getInfo());
    	}
    }
    
    

    2.调用父类的构造器

    1)子类中所有的构造器默认都会访问父类中空参数的构造器
    2)当父类中没有空参数的构造器时,子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器。同时,只能”二选一”,且必须放在构造器的首行
    3)如果子类构造器中既未显式调用父类或本类的构造器,且父类中又没有无参的构造器,则编译出错

    三、this和super区别

    在这里插入图片描述


    展开全文
  • 主要介绍了java 关键字super详解及用法的相关资料,需要的朋友可以参考下
  • 测试结果如下,sleep函数和eat函数的显示结果已经发生了改变 super关键字 如果想利用父类中已经被覆盖的方法和属性,就要使用super 比如我们可以在Chinese这个类中进行类似操作 class Chinese extends Person{ ...

    方法重写的概念

    子类对父类中继承来的方法进行改造、重置、覆盖,利用同名进行再编写

    重写规定

    权限修饰符 返回值类型 方法名(形参列表)

    1、子类对父类进行重写的时候,方法名与形参和父类的一致

    2、权限修饰符在界定权限的时候,子类的权限一定是大于等于父类的,子类的权限是不可以小于父类的

    3、返回值类型,若父类被重写的方法返回值是void,那么子类重写的方法结果也只能是void;若父类被重写的方法的返回值类型是A类,那么子类重写的返回值可以是A类或者是A的子类

    可以总结为,若父类被重写的方法的返回值类型是基本数据类型,那么子类重写方法的数据类型就与父类被重写的返回值类型一致;但是如果返回的类型是类,那么就可以是该类的子类

    重写在子父类继承中尤为重要

    public class Person
    {
        private String name;
        private int age = 1;
        private boolean isMale;
        public void eat()
        {
            System.out.println("人可以吃饭");
        }
        public void sleep()
        {
            System.out.println("人可以睡觉");
        }
        public void talk(String language)
        {
            System.out.println("人可以说话,使用的是:"+language);
        }
    
        public String getName() {
            return name;
        }
    
        public int getAge() {
            return age;
        }
    
        public boolean isMale() {
            return isMale;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public void setMale(boolean male) {
            isMale = male;
        }
    };
    class Chinese extends Person{
        private String nation;
    
        public void setNation(String nation) {
            this.nation = nation;
        }
    
        public String getNation() {
            return nation;
        }
        
        public void sleep()
        {
            System.out.println("中国人会睡觉");
        }
        
        public void eat()
        {
            System.out.println("中国人会睡觉");
        }
    
        public void talk(String language)
        {
            System.out.println("中国人可以说话,说的是"+ language);
        }
    }

    上述举例中,在Chinese这个子类中,eat()和sleep()全是对于Person类中的重写,接下来我们进行测试

    public class Persontext
    {
        public static void main(String[] args)
        {
            Chinese c1 = new Chinese();
            c1.sleep();
            c1.eat();
    
            System.out.println("******************************");
    
            Person p1=new Person();
            p1.sleep();
            p1.eat();
        }
    };

    测试结果如下,sleep函数和eat函数的显示结果已经发生了改变

    super关键字

    如果想利用父类中已经被覆盖的方法和属性,就要使用super

    比如我们可以在Chinese这个类中进行类似操作

    class Chinese extends Person{
        private String nation;
    
        public void setNation(String nation) {
            this.nation = nation;
        }
    
        public String getNation() {
            return nation;
        }
    
        public void sleep()
        {
            System.out.println("中国人会睡觉");
            super.sleep();
        }
    
        public void eat()
        {
            System.out.println("中国人会睡觉");
            super.eat();
        }
    
        public void talk(String language)
        {
            System.out.println("中国人可以说话,说的是"+ language);
        }
    }

    再利用和上次测试代码进行测试,会发现这个时候原本的输出结果已经发生了改变

    如图所示,在已经重写的方法后面,再次打印了之前没有重写的内容

    使用super的注意事项

    1、在子类和方法或者构造器中可以显式的调用父类的方法和属性

    2、当子父类中有同名属性,若子类调用父类中的属性,则此时就可以利用super

    3、能调用父类中已经被重写的方法,如果该方法没有被重写,那么不是没有利用super,而是super已经被省略了

    4、在构造器的首行,实际上都有一个super(),调用了父类的构造器(此处需要注意的一定是在首行),只不过是默认省略super(),this()和super()只能够调用一个,但是每个构造器的首行,都至少有this()和super()其中之一

    这里稍微提一下关于子类对象实例化的过程

    1、创建子类对象时在堆空间中会先加载父类的相关属性

    2、通过子类的构造器,一定会直接或者间接的调用到父类构造器,直到调用到Object的空参构造器,加载过父类结构,所以才可以看到内存中有父类结构

    注:object类可以说是所有类的直接或者间接父类

    虽然无数次的调用父类的构造器,但是实际上创造对象的从始至终都只有object类的构造器,所以无论调用多少次,都只会创建一个对象

    展开全文
  • 关键字super在构造方法中的含义: 1、当用子类的构造方法创建一个对象时,子类的构造方法总是先调用父类的某个构造方法; 2、当子类的构造方法没有明确地指明使用父类的哪个构造方法,那么子类就默认调用父类中不...

    关键字super在构造方法中的含义:

    1、当用子类的构造方法创建一个对象时,子类的构造方法总是先调用父类的某个构造方法;

    2、当子类的构造方法没有明确地指明使用父类的哪个构造方法,那么子类就默认调用父类中不带参数的构造方法;

    3、需要注意:当某个类中定义了一个或多个构造方法时,那么Java系统就不提供默认的无参数的构造方法了;

    如下代码↗:

    当子类的构造方法中没有 super() ; 关键字时,系统默认该方法有 super(),此时就调用了父类没有参数的构造方法;

    当子类的构造方法中有 super(); 关键字时,系统就调用父类相应参数的构造方法;

    //父类
    public class superKeyword {
    	//父类的成员变量
    	int numberFa;
    	//无参数构造方法
    	superKeyword(){
    		System.out.println("系统默认调用了父类无参数构造方法 ");
    	} 
    	superKeyword(int numberFa){
    		this.numberFa = numberFa;
    		System.out.println("父类的手机号码: "+numberFa);
    	}
    }
    
    //父类
    public class superKeyword_Test extends superKeyword {
    	//成员变量
    	int age,number;
    	double Fraction;
    	
    	//没有super();的情况时,系统默认该方法有 super(),此时就调用了父类没有参数的构造方法
    	superKeyword_Test(int age,int number){
    		this.age = age;
    		this.number = number;
    		System.out.println("子类的年龄:"+age+" 子类的手机号码: "+number+"\n");
    	}
    
    	//有super();的情况时,系统就调用父类相应参数的构造方法
    	superKeyword_Test(double Fraction, int number) {
    		super(117330111);
    		this.Fraction = Fraction;
    		this.number = number;
    		System.out.println("子类的分数:"+Fraction+" 子类的手机号码: "+number);
    	}
    	
       public static void main(String[] args){
    	   //调用没有super()的构造方法
    	   superKeyword_Test skt = new superKeyword_Test(18,117120);  
               //调用有super()的构造方法
    	   superKeyword_Test skt1 = new superKeyword_Test(111.11,117110);     
       }
    }
    

    代码输出结果:

    系统默认调用了父类无参数构造方法 
    子类的年龄:18 子类的手机号码: 117120


    父类的手机号码: 117330111
    子类的分数:111.11 子类的手机号码: 117110


    需要注意的是:

    当子类构造方法中没有 super() 关键字,而且父类中没有无参数构造方法,却有一个或多个有参数构造方法时,是错误的;

    如下代码↗:

    //父类
    public class superKeyword {
    	//父类的成员变量
    	int numberFa;
    	superKeyword(int numberFa){
    		this.numberFa = numberFa;
    		System.out.println("父类的手机号码: "+numberFa);
    	}
    }
    
    //子类
    public class superKeyword_Test extends superKeyword {
    	//成员变量
    	int age,number;
    	double Fraction;
    	
    	//没有super();的情况时,系统默认该方法有 super(),此时就调用了父类没有参数的构造方法
            //当父类中没有无参数构造方法,却有一个或多个有参数构造方法时,是错误的;
    	superKeyword_Test(int age,int number){
    		this.age = age;
    		this.number = number;
    		System.out.println("子类的年龄:"+age+" 子类的手机号码: "+number+"\n");
    	}
    
       public static void main(String[] args){
    	   //调用没有super()的构造方法
    	   superKeyword_Test skt = new superKeyword_Test(18,117120);  
       }
    }
    

    代码报错:Implicit super constructor superKeyword() is undefined. Must explicitly invoke another constructor 

                      未定义隐式超级构造函数superKeyword()。必须显式调用另一个构造函数


     

    关键字 super 操作隐藏的成员变量和方法:

    1、子类在继承父类的成员变量和方法时,一旦隐藏了父类某个成员变量和方法,那这些成员变量和方法就被分配给关键字 super 所拥有;

    2、则子类调用这些被隐藏的成员变量和方法,就需要使用关键字 super 才行;

    3、当 super 调用被隐藏的方法时,该方法中出现的成员变量是 被子类隐藏的成员变量 或 继承的成员变量;

    如下代码↗:

    //父类
    public class superKeyword {
        //声明父类的成员变量和方法
    	double Fa = 456.456;
    	void methodFa(int x,int y){
    		Fa = x*y;
    		System.out.println("父类的方法,x*y后 Fa的值="+Fa);
    	}
    }
    //父类
    public class superKeyword_Test extends superKeyword {
    	
    	//进行重写,对父类的成员变量和方法进行隐藏
    	double Fa = 111.111;
    	void methodFa(int x,int y){
    		Fa = x+y;
    		System.out.println("子类的方法,调用自己的成员变量Fa,x+y后 Fa的值="+Fa);
    		//调用父类被隐藏的成员变量
    		super.Fa = x-y;
    System.out.println("子类的方法,通过super调用被隐藏的成员变量Fa,x-y后 Fa的值="+super.Fa);
    	//调用父类被隐藏的方法,此时方法中操作的成员变量是被子类隐藏的成员变量 或 继承的成员变量
    		super.methodFa(11, 11);
    	}
    	
       public static void main(String[] args){
    	   //创建对象
    	   superKeyword_Test skt = new superKeyword_Test();
    	   //调用方法
    	   skt.methodFa(100, 10);
       }
    }
    

    代码输出结果:

    子类的方法,调用自己的成员变量Fa,x+y后 Fa的值=110.0
    子类的方法,通过super调用被隐藏的成员变量Fa,x-y后 Fa的值=90.0
    父类的方法,x*y后 Fa的值=121.0


    需要注意的是:

    在类主方法 main() 中是不能进行 super.XXX 操作的;

    会报错:Cannot use super in a static context ;  // 不能在静态上下文中使用super

     

    展开全文
  • Java关键字 ——super

    2022-05-04 19:58:25
    super理解为:父类的,super可以用来调用:属性、方法、构造器 1.调用属性和方法 在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式,显式的调用父类中声明的属性或方法。但是,通常情况下,...
  • 关键字super

    2018-03-31 14:10:39
    使用关键字super可以引用被子类隐藏的父类的成员变量或方法。super引用的语句格式为: super.成员变量名; super.方法名(实参列表); super引用父类对象,主要的使用形式由如下几种。 1.在子类的构造方法内部引用...
  • Java5-2关键字super final

    2020-12-07 20:03:52
    关键字super final 1.super 关键字 子类可以隐藏从父类继承的成员变量和方法,如果要在子类中使用被隐藏的成员变量或者方法,则使用super关键字 super关键字用法: 使用super调用父类的构造方法:子类不继承父类的...
  • java中关键字 super表示的真正对象java中的super,大家都知道是表示一个父类的引用。上次群里见到一个网友询问 super.getClass().getName()的输出问题,大部分都知道输出的是当前这个类的类名。而不是父类的名称。...
  • 案例: public class Father { ... //super指代父类 String name = super.name; } public class Test { public static void main(String[] args) { Son son = new Son(); System.out.println(so...
  • 关键字super,子类调用父类属性

    千次阅读 2021-07-01 21:35:25
    在继承中,子类要调用父类的属性,需要使用super关键字 VSthis: 代表的对象不同 this:代表调用这个对象 super:代表父类对象的应用 前提 this:没有继承也可以使用 super:只能在...
  • Java——super关键字

    千次阅读 2022-02-17 21:59:18
    1、super关键字,全部小写。 2、super和this对比: this: this能出现在实例方法和构造方法中。 this的语法: “this.” 、 “this ()” this不能使用在静态方法中。 this.大部分情况下可以省略,在区分局部...
  • JavaScript-ES6之面向对象,子类的继承,关键字super.
  • 介绍this关键字super关键字和 this 与 super 的对比 一、this this可以看成一个隐藏属性,它指向它自己这个对象 细节 this关键字可以用来访问本类的属性、方法、构造器 this用于区分当前类的属性和局部变量 访问...
  • 1.关键字this:是指调用对象本身的引用名。可以用this关键字引用对象的实例成员,例如:下面的代码使用this来显示地引用对象的radius以及调用它的getArea()方法。但是this引用可以省略掉的。 public class Circle{...
  • this关键字super关键字详解

    万次阅读 多人点赞 2018-02-02 12:17:03
    一.this关键字 1.实例一: (1)需求:使用Java类描述一个动物; (2)实例: class Animal{ String name; //成员变量 String color; public Animal(String n,String c){ name = n; color = c; } ...
  • 详细内容本篇文章给大家带来的内容是介绍java关键字super和this是什么?有什么区别?,让大家了解关键字super和this的作用,关键字super和this的区别,以及简单介绍一下superL()和this()。有一定的参考价值,有需要...
  • java关键字super

    2021-12-20 23:23:59
    java中的super用法!!!
  • Super关键字详解

    千次阅读 2020-10-30 08:43:43
    super关键字的用法如下: super可以用来引用直接父类的实例变量。 super可以用来调用直接父类方法。 super()可以用于调用直接父类构造函数 1.super用于引用直接父类实例变量 可以使用super关键字来访问父类...
  • java中super关键字主要有两种用法: 1.在子类的构造方法中可以显示的调用父类的构造方法,将参数传给父类的构造方法。 super(参数); 该语句必须是子类构造方法中的第一句语句。 2.父类和子类中有相同的...
  • // super 关键字调用父类普通函数 //注意点: // 继承中的属性或者方法查找原则: 就近原则 // 1. 继承中,如果实例化子类输出一个方法,先看子类有没有这个方法,如果有就先执行子类的 // 2. 继承中,如果子类里面...
  • 1.定义: 在JAVA类中使用super来引用父类的成分,用this来引用当前对象,如果一个类从另外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个...super关键字一般用于含有继承关系,我们还是用例
  • 子类一旦隐藏了继承的成员变量,那么子类创建的对象就不再拥有该变量,该变量将归关键字super所有,同样,子类一旦隐藏了继承的方法,那么子类创建的对象就不能调用被隐藏的方法,该方法的调用由关键字super负责。...
  • 一.this关键字代表什么 this代表当前对象的引用 有关this关键字的注意事项: 1.this代表当前对象的引用 2.在静态方法内部,不能够使用this(j静态不依赖于对象 ,而this代表对象的引用产生矛盾) 3. a.this通过点号 ...
  • this、super关键字讲解

    2020-12-17 21:40:12
    一、this关键字 this是一个引用,它指向自身的这个对象。 看内存分析图: 假设我们在堆内存new了一个对象,在这个对象里面你想象着他有一个引用this,this指向这个对象自己,所以这就是this,这个new出来的...
  • Java关键字super的使用 在java中派生类继承基类,如果想访问派生类和基类的方法,我们可以重写父类的方法,并且通过super调用父类的方法就可以实现访问父类的方法 代码实例 public class People { public void eat...
  • 内容一、方法的重写二、super关键字 一、方法的重写 1. 为什么要重写方法? 在子类继承父类方法的过程中难免需要对继承的方法进行一些修改,于是就有了方法的重写操作。 2. 重写方法需要注意的点 重写的方法名和...
  • java 关键字super

    2018-10-12 01:33:04
    java 关键字superjava关键字的使用demo java关键字的使用 super:可用来修饰属性、方法、构造器 当子类与父类中有同名的属性时,可用通过“super.此属性”显示调用父声明的属性。 若想调用子类的同名...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 216,949
精华内容 86,779
关键字:

关键字super