精华内容
下载资源
问答
  • java 关键字super

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

    java 关键字super

    java关键字的使用

    1. super:可用来修饰属性、方法、构造器

    2. 当子类与父类中有同名的属性时,可用通过“super.此属性”显示调用父声明的属性。

    3. 若想调用子类的同名的属性“用this.属性”调用

    4. 当子类重写父类的方法以后,在子类中若想调用父类的方法,就需要显示调用父类中的方法,用“super.方法”

    demo

    public class Person {
    
    	private String name;
    	private int age;
    	int id;//身份证
    	...
    	public void eat() {
    		System.out.println("吃饭");
    	}
    }
    
    public class Student extends Person {
    	private String schoolName;
    	private int id;//学号
    	public Student(String schoolName, int id) {
    		super();//调用父类的构造器结构,加载父类的属性
    		this.schoolName = schoolName;
    		this.id = id;
    	}
    	
    	public void show() {
    		//默认this.id
    		System.out.println(this.id);		
    		System.out.println(super.id);
    	}
    }
    
    展开全文
  • java关键字super

    2020-03-16 02:53:11
    java关键字super super用来引用直接父类对象,每当创建子类的实例时,父类的实例被隐式创建,由super关键字引用变量引用 1,用法 ①引用直接父类的实例变量,调用直接父类方法 class Animals{ String color = "red...

    java关键字super

    super用来引用直接父类对象,每当创建子类的实例时,父类的实例被隐式创建,由super关键字引用变量引用
    1,用法
    ①引用直接父类的实例变量,调用直接父类方法

    class Animals{
        String color = "red";
        void output(){
            System.out.println("this is father......");
        }
    }
    class Dog extends Animals{
        String color = "green";
        void output(){
            System.out.println("this is son.......");
            super.output();//调用父类方法
            System.out.println(color);
            System.out.println(super.color);//引用父类变量
    
        }
    
    }
        public class ex {
            public static void main(String[] args) {
               Dog dog = new Dog();
               dog.output();
            }
        }
    

    运行结果

    this is son.......
    this is father......
    green
    red
    

    我觉得super调用直接父类的方法有种撤销子类函数覆盖的意思,函数覆盖之后想要是被覆盖了的父类函数显现出来,用到super关键字
    ②引用直接父类的构造函数

    class Animals{
        Animals(){
            System.out.println("Father's constructor");
        }
    }
    class Dog extends Animals{
        Dog(){
            super();//若果没有这行代码,编译器也会自动的添加上
            System.out.println("Son's constructor");
    
        }
    
    }
        public class ex {
            public static void main(String[] args) {
               Dog dog = new Dog();
            }
        }
    
    

    运行结果

    Father's constructor
    Son's constructor
    
    Process finished with exit code 0
    
    

    当创建一个子类实例的时候,一定会隐式的创建一个父类实例,既然创建了父类实例,就一定得调用父类的构造函数,所以上例的super();可写可不写,但注意,写了必须放在子类构造函数的第一行。
    2,小实例应用
    体会一下super的用法

    class Student{
        String name;
        int id;
        Student(int id,String name){
            this.name = name;
            this.id = id;
        }
    }
    class MiddleStudent extends Student{
        int grade;
        MiddleStudent(int grade,int id,String name) {
            super(id,name);//此行代码必须要有
            this.grade = grade;
        }
    }
        public class ex {
            public static void main(String[] args) {
               MiddleStudent s = new MiddleStudent(8,1234,"Mary");
               System.out.println(s.grade+" "+s.name+" "+s.id);
            }
    
        }
    
    

    结果

    8 Mary 1234
    
    Process finished with exit code 0
    
    
    展开全文
  • java 关键字super详解一、super关键字在JAVA类中使用super来引用父类的成分,用this来引用当前对象,如果一个类从另外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个父类对象。怎么去引用...

    java 关键字super详解

    一、super关键字

    在JAVA类中使用super来引用父类的成分,用this来引用当前对象,如果一个类从另外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢?使用super来引用,this指的是当前对象的引用,super是当前对象里面的父对象的引用。

    1.1.super关键字测试

    package cn.galc.test;

    /**

    * 父类

    * @author gacl

    *

    */

    class FatherClass {

    public int value;

    public void f() {

    value=100;

    System.out.println("父类的value属性值="+value);

    }

    }

    /**

    * 子类ChildClass从父类FatherClass继承

    * @author gacl

    *

    */

    class ChildClass extends FatherClass {

    /**

    * 子类除了继承父类所具有的valu属性外,自己又另外声明了一个value属性,

    * 也就是说,此时的子类拥有两个value属性。

    */

    public int value;

    /**

    * 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现,即重写了f()方法的方法体。

    */

    public void f() {

    super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法

    value=200;//这个value是子类自己定义的那个valu,不是从父类继承下来的那个value

    System.out.println("子类的value属性值="+value);

    System.out.println(value);//打印出来的是子类自定义的那个value的值,这个值是200

    /**

    * 打印出来的是父类里面的value值,由于子类在重写从父类继承下来的f()方法时,

    * 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法,

    * 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值,由0变了100。

    * 所以这里打印出来的value值是100。

    */

    System.out.println(super.value);

    }

    }

    /**

    * 测试类

    * @author gacl

    *

    */

    public class TestInherit {

    public static void main(String[] args) {

    ChildClass cc = new ChildClass();

    cc.f();

    }

    }

    运行结果:

    1.2. 画内存分析图了解程序执行的整个过程

    分析任何程序都是从main方法的第一句开始分析的,所以首先分析main方法里面的第一句话:

    ChlidClass cc = new ChlidClass();

    程序执行到这里时,首先在栈空间里面会产生一个变量cc,cc里面的值是什么这不好说,总而言之,通过这个值我们可以找到new出来的ChlidClass对象。由于子类ChlidClass是从父类FatherClass继承下来的,所以当我们new一个子类对象的时候,这个子类对象里面会包含有一个父类对象,而这个父类对象拥有他自身的属性value。这个value成员变量在FatherClass类里面声明的时候并没有对他进行初始化,所以系统默认给它初始化为0,成员变量(在类里面声明)在声明时可以不给它初始化,编译器会自动给这个成员变量初始化,但局部变量(在方法里面声明)在声明时一定要给它初始化,因为编译器不会自动给局部变量初始化,任何变量在使用之前必须对它进行初始化。

    子类在继承父类value属性的同时,自己也单独定义了一个value属性,所以当我们new出一个子类对象的时候,这个对象会有两个value属性,一个是从父类继承下来的value,另一个是自己的value。在子类里定义的成员变量value在声明时也没有给它初始化,所以编译器默认给它初始化为0。因此,执行完第一句话以后,

    接下来执行第二句话:

    1 cc.f();

    当new一个对象出来的时候,这个对象会产生一个this的引用,这个this引用指向对象自身。如果new出来的对象是一个子类对象的话,那么这个子类对象里面还会有一个super引用,这个super指向当前对象里面的父对象。所以相当于程序里面有一个this,this指向对象自己,还有一个super,super指向当前对象里面的父对象。

    这里调用重写之后的f()方法,方法体内的第一句话:“super.f();”是让这个子类对象里面的父对象自己调用自己的f()方法去改变自己value属性的值,父对象通过指向他的引用super来调用自己的f()方法,所以执行完这一句以后,父对象里面的value的值变成了100。接着执行“value=200;”这里的vaule是子类对象自己声明的value,不是从父类继承下来的那个value。所以这句话执行完毕后,子类对象自己本身的value值变成了200。

    方法体内的最后三句话都是执行打印value值的命令,前两句打印出来的是子类对象自己的那个value值,因此打印出来的结果为200,最后一句话打印的是这个子类对象里面的父类对象自己的value值,打印出来的结果为100。

    到此,整个内存分析就结束了

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • 主要介绍了java 关键字super详解及用法的相关资料,需要的朋友可以参考下
  • Java关键字(五)——this中我们说 this 关键字是表示当前对象的引用。而 Java 中的 super 关键字则是表示 父类对象的引用。我们分析这句话“父类对象的引用”,那说明我们使用的时候只能在子类中使用,既然是对象的...

    在 Java关键字(五)——this 中我们说 this 关键字是表示当前对象的引用。而 Java 中的 super 关键字则是表示 父类对象的引用。

    我们分析这句话“父类对象的引用”,那说明我们使用的时候只能在子类中使用,既然是对象的引用,那么我们也可以用来调用成员属性以及成员方法,当然了,这里的 super 关键字还能够调用父类的构造方法。具体有如下几种用法:

    1、调用父类的构造方法

    Java中的继承大家都应该了解,子类继承父类,我们是能够用子类的对象调用父类的属性和方法的,我们知道属性和方法只能够通过对象调用,那么我们可以大胆假设一下:

    在创建子类对象的同时,也创建了父类的对象,而创建对象是通过调用构造函数实现的,那么我们在创建子类对象的时候,应该会调用父类的构造方法。

    下面我们看这段代码:

    1 public classParent {2

    3 publicParent(){4 System.out.println("父类默认无参构造方法");5 }6 }7

    8

    9 public class Son extendsParent {10

    11 publicSon(){12 System.out.println("子类默认无参构造方法");13 }14 }

    下面我们创建子类的对象:

    1 public static voidmain(String[] args) {2 Son son = newSon();3 }

    打印结果:

    80feddbeb9dc35409d0ab64675db15e0.png

    通过打印结果看到我们在创建子类对象的时候,首先调用了父类的构造方法,接着调用子类的构造方法,也就是说在创建子类对象的时候,首先创建了父类对象,与前面我们猜想的一致。

    那么问题又来了:是在什么时候调用的父类构造方法呢?

    e2219e9eb37bc857e055283290c22e15.png

    红色框内的英文翻译为:如果声明的类是原始类Object,那么默认的构造函数有一个空的主体。否则,默认构造函数只是简单地调用没有参数的超类构造函数。

    也就是说除了顶级类 Object.class 构造函数没有调用父类的构造方法,其余的所有类都默认在构造函数中调用了父类的构造函数(没有显式声明父类的子类其父类是 Object)。

    那么是通过什么来调用的呢?我们接着看官方文档:

    a8e601daa112b73b8dbd115f5431455b.png

    上面的意思大概就是超类构造函数通过 super 关键字调用,并且是以 super 关键字开头。

    所以上面的 Son 类的构造方法实际上应该是这样的:

    f828f1ff48f994b974a352252374e880.png

    ①、子类默认是通过 super() 调用父类的无参构造方法,如果父类显示声明了一个有参构造方法,而没有声明无参构造方法,实例化子类是会报错的。

    1 public classParent {2

    3 publicParent(String name){4 System.out.println("父类有参构造方法");5 }6 }7

    8 public class Son extendsParent {9

    10 publicSon(){11 System.out.println("子类默认无参构造方法");12 }13

    14 public static voidmain(String[] args) {15 Son son = newSon();16 }17

    18 }

    上面代码是会报错的:

    b2e4b5c889f4085db3aecc03f3458bce.png

    解决办法就是通过 super 关键字调用父类的有参构造方法:

    1 public class Son extendsParent {2

    3 publicSon(){4 super("Tom");5 System.out.println("子类默认无参构造方法");6 }7

    8 public static voidmain(String[] args) {9 Son son = newSon();10 }11

    12 }

    注意看第 4 行代码,同理,多个参数也是这种调法。

    2、调用父类的成员属性

    1 public classParent {2 publicString name;3

    4 publicParent(){5 System.out.println("父类默认无参构造方法");6 }7 }8

    9 public class Son extendsParent {10

    11 publicSon(){12 System.out.println("子类默认无参构造方法");13 }14

    15 public voidprintName(){16 System.out.println(super.name);17 }18

    19 }

    第 16 行代码 super.父类属性  通过这种形式来调用父类的属性。

    3、调用父类的方法

    1 public classParent {2 publicString name;3

    4 publicParent(){5 System.out.println("父类默认无参构造方法");6 }7

    8 public voidsetName(String name){9 this.name =name;10 }11 }12

    13 public class Son extendsParent {14

    15 publicSon(){16 super();//1、调用父类构造函数

    17 System.out.println("子类默认无参构造方法");18 }19

    20 public voidprintName(){21 super.setName("Tom");//2、调用父类方法

    22 System.out.println(super.name);//3、调用父类属性

    23 }24

    25 public static voidmain(String[] args) {26 Son son = newSon();27 son.printName();//Tom

    28 }29

    30 }

    这个例子我们在子类中分别调用了父类的构造方法、普通方法以及成员属性。

    4、this 和 super 出现在同一个构造方法中?

    不能!!!

    在上一篇博客对 this 关键字 的介绍中,我们知道能够通过 this 关键字调用自己的构造方法。而本篇博客介绍 super 关键字,我们知道了能够通过 super 调用父类的构造方法,那么这两个关键字能同时出现在子类的构造方法中吗?

    ①、假设 super() 在 this() 关键字的前面

    首先通过 super() 调用父类构造方法,对父类进行一次实例化。接着调用 this() ,this() 方法会调用子类的构造方法,在子类的构造方法中又会对父类进行一次实例化。也就是说我们对子类进行一次实例化,对造成对父类进行两次实例化,所以显然编译器是不允许的。

    1 public classParent {2 publicString name;3

    4 publicParent(){5 System.out.println("父类默认无参构造方法");6 }7

    8 publicParent(String name){9 System.out.println("父类有参构造方法");10 }11

    12 }13

    14 public class Son extendsParent {15

    16 publicSon(){17 super();//1、调用父类构造函数

    18 this("Tom");//2、调用子类构造方法

    19 System.out.println("子类默认无参构造方法");20 }21

    22 publicSon(String name){23 System.out.println("子类有参构造方法");24 }25

    26 }

    反过来 this() 在 super() 之前也是一样。

    而且编译器有限定 this() 和 super() 这两个关键字都只能出现在构造方法的第一行,将这两个关键字放在一起,总有一个关键字在第二行,编译是不能通过的。

    展开全文
  • Java 关键字super用法介绍内容待完成
  • 详细内容本篇文章给大家带来的内容是介绍java关键字super和this是什么?有什么区别?,让大家了解关键字super和this的作用,关键字super和this的区别,以及简单介绍一下superL()和this()。有一定的参考价值,有需要...
  • javasuper关键字与this关键字的区别是什么发布时间:2020-09-01 14:58:57来源:亿速云阅读:97作者:小新这篇文章给大家分享的是有关javasuper关键字与this关键字的区别是什么的内容。小编觉得挺实用的,因此...
  • 1.super关键字可以在子类的构造方法中显示地调用父类的构造方法,super()必须为子类构造函数中的第一行。2.super可以用来访问父类的成员方法或变量,当子类成员变量或方法与父类有相同的名字时也会覆盖父类的成员...
  • 使用super关键字访问超类成员如果你的方法覆盖了它的一个超类的方法,你可以通过使用关键字super来调用被重写的方法,你也可以使用super来引用隐藏字段(尽管不鼓励隐藏字段),虑这个类,Superclass:public class ...
  • java关键字super总结

    2018-08-01 11:10:00
    子类继承父类,若父类的成员变量被隐藏或者方法被重写,此时如果想调用被隐藏的成员变量或方法就要用到关键字super. (1)调用父类的构造方法:super语句必须在子类构造方法的第一句中,系统默认调用无参数的父类构造...
  • java关键字 super final

    2020-03-15 09:08:17
    super 1. 用super 来访问父类中被子类覆盖的成员变量或者属性
  • java 关键字super和this

    2019-09-28 12:59:45
    super关键字  作用:调用父类的构造器  只能出现在子类的构造其中,并且必须是第一行  super()中的参数,决定了调用父类的那个构造器  注:如果子类构造器中没有出现super,则默认加上super(),调用父类...
  • Java关键字super细节

    2018-12-29 16:53:42
    从一道笔试题说起, 下面一段代码的执行结果是?...从本质上讲,this是一个指向本对象的指针, 然而super是一个Java关键字。                          
  • Java关键字 super和this

    2017-03-19 13:13:38
    总结关键字this与super用法。 author: ZJ 07-3-12 Blog: [url]http://zhangjunhd.blog.51cto.com/[/url] 1.什么是super?什么是this? super关键字表示超(父)类的意思。this变量代表对象本身。 2.使用...
  • Java关键字super与this

    2018-01-05 16:20:21
    但是,下列场景中,如果想在子类中访问父类方法或变量,就可以使用super关键字。 1)如果子类隐藏了父类的变量(静态变量或者实例变量【成员变量】)。 2)子类的静态方法隐藏了父类静态方法,当子类未转换成父...
  • java关键字 super 和 this

    2016-05-19 20:10:00
    super: 是指父类,想要在子类方法中调用父类的实例变量或方法可以通过super 来访问 this:是指当前类,想要访问当前类的实例变量和方法可以使用this,同时可以省略 转载于:...
  • java关键字super和this

    2014-09-24 21:25:03
    super关键字表示超(父)类的意思。this变量代表对象本身。 2.使用super&this调用成员变量和方法 可以使用super访问父类被子类隐藏的变量或覆盖的方法。当前类如果是从超类继承而来的,当调用super.XX()就是...
  • super和this之间的区别: this:当前对象(new的对象|调用成员方法的对象) 1.调用本类中的其他构造器 this(参数列表) 2.区分局部和成员之间的问题 super:指代父类对象 1.调用父类的构造器 super() 如果没有显示定义,...
  • super关键字
  • java关键字this的总结 this是对象内部指代自身的引用,同时也是解决成员变量和局部变量同名问题; this可以调用成员变量,不能调用局部变量; this也可以调用成员方法,但是在普通方法中可以省略this,在构造方法中不...
  • 一、super关键字JAVA类中使用super来引用父类的成分,用this来引用当前对象,如果一个类从另外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢?...
  • Java关键字super创建测试文件调试注解(执行步骤)执行结果 创建测试文件 ThisAndSuper.class package test; public class ThisAndSuper { public static void main(String[] args) { City c = new City(); c....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,256
精华内容 2,502
关键字:

java关键字super

java 订阅