精华内容
下载资源
问答
  • Java中super关键字与final关键字

    千次阅读 2020-04-19 19:50:39
    文章目录Java中super关键字Java中final关键字 Java中super关键字 super 可以理解为是指向自己父(超)类对象的一个指针,而这个超类指的是离自己最近的一个父类。 super关键字的作用: 调用父类的构造方法 调用父类...

    Java中super关键字

    super 可以理解为是指向自己父(超)类对象的一个指针,而这个超类指的是离自己最近的一个父类。

    super关键字的作用:

    • 调用父类的构造方法
    • 调用父类的成员方法

    注意:

    1super只能应用在成员方法和构造方法中,不能应用在静态方法中(和this是一样的),如果在构造方法中使用super,必须放在方法的第一行。
    
    2、构造方法不存在覆盖的概念,构造方法可以重载。
    
    3、关于构造方法的执行顺序:先执行父类的再执行子类的,必须完成父类的所有初始化,才能创建子类。
    
    4、程序运行时机优先级是:类加载-->静态代码块运行-->静态变量初始化-->对应的构造函数运行
    

    为什么会有super关键字

    • 因为子类必须要调用父类的构造方法,先把父类构造完成,因为子类依赖于父类,没有父,也就没有子
    • 有时候需要在子类中,显示的调用父类的成员方法和父类的构造方法。
    • 子类中即使我们没有显示的调用父类的无参构造方法,那么它也会默认使用super()调用父类的无参构造方法,此种情况下子类如果显示的设置了有参构造器,必须显示设置无参构造器,否则编译时将会失败。

    super和this在构造方法中的使用:

    • super(参数):调用父类中的某一个构造函数(必须为构造函数中的第一行)。
    • this(参数):调用本类中的构造函数(必须为构造函数中的第一行)。

    Java中final关键字

    final表示不可改变的含义

    final关键字使用总结:

    • 使用final关键字修饰的类不能被继承

    • 使用final关键字修饰的方法不能被覆盖(重写)

    • 使用final关键字修饰的变量,在使用前必须显示初始化。对于final修饰的成员变量,我们有且只有两个地方可以给它赋值,一个是声明该成员时赋值,另一个是在构造方法中赋值,在这两个地方我们必须给它们赋初始值。

    • 使用final关键字修饰的变量(基本类型)一旦赋值,不能被改变。如果使用final关键字修饰的引用类型,那么这个引用只能指向一个对象,也就是说这个引用不能通过 ** new对象** 方式再次赋值,但被指向的对象中属性值是可以修改的

      private static final Integer number = 6666;
      public void addNumber(){
      	//number不能进行修改,因为number使用final修饰了,变量(基本类型)一旦被赋值,就不能被改变
      	number = 8888;
      }
      
      final Person person = new Person();
      person.name = "张三";
      System.out.println(person.name);
      
      //再次new创建新对象引用时,不能编译通过
      //person引用使用final修饰,限制了person指向堆区中的内存地址不能被修改(也就是person只能指向堆中唯一一个对象),但是,person指向的对象的属性值是可以修改的
      person = new Person();
      
    • 构造方法不能被final修饰

    • 会影响Java类的初始化,final定义的静态变量调用时不会执行java的类初始化方法,也就是说不会执行static代码块等相关语句,这是由java虚拟机规定的。

    写博客是为了记住自己容易忘记的东西,另外也是对自己工作的总结,希望尽自己的努力,做到更好,大家一起努力进步!

    如果有什么问题,欢迎大家一起探讨,代码如有问题,欢迎各位大神指正!

    给自己的梦想添加一双翅膀,让它可以在天空中自由自在的飞翔!

    展开全文
  • Java中super关键字super关键字与this关键字的区别

    千次阅读 多人点赞 2018-10-21 16:31:33
    文章目录1 super关键字1.1 super用于方法1.1.1 用于构造方法1.1.2 用于普通方法1.1.2 用于属性2 super与this关键字的区别2.1 概念上2.2 查找范围2.3 特殊之处 1 super关键字 1.1 super用于方法 1.1.1 用于构造...

    1 super关键字

    1.1 super用于方法

    1.1.1 用于构造方法

    在这里插入图片描述
    子类的构造函数里,其实默认调用的是父类的无参构造,此时super()可写可不写。
    在这里插入图片描述
    当子类向调用父类的有参构造时,super(参数列表)必须要写,要告诉编辑器调用的是哪个有参构造!
    在这里插入图片描述
    在子类构造方法中调用父类构造方法必须是第一行语句!

    1.1.2 用于普通方法

    在这里插入图片描述
      用于在子类中明确调用父类被覆写的方法!

    1.1.2 用于属性

    在这里插入图片描述
      表示调用父类中的属性!

    2 super与this关键字的区别

    Java中this关键字详解

    2.1 概念上

    this:访问本类中的属性及方法。
    super: 由子类访问父类中的属性、方法。

    2.2 查找范围

    this:先找本类,如果本类没有就调用父类。
    super:不查找本类直接调用父类。
    在这里插入图片描述
    在这里插入图片描述

    2.3 特殊之处

    this:可以表示当前对象!
    super:不可以 !

    展开全文
  • Java中super关键字

    2020-12-22 19:41:07
    在Java中,有时还会遇到子类的成员变量或方法与父类的成员变量或方法同名。因为子类的成员变量或方法名优先级高,所以子类的同名成员变量或方法隐藏了父类的成员变量或方法,但是我们如果想要使用父类的...
  • 在Java中this关键字和super关键字* 一个对象对应一个this,this是一个变量,是一个引用。this保存当前对象的内存地址指向自身。 super关键字代表的就是“当前对象”的那部分父类型特征。 this和super出现实例方法...

    在Java中this关键字和super关键字*

    一个对象对应一个this,this是一个变量,是一个引用。this保存当前对象的内存地址指向自身。
    super关键字代表的就是“当前对象”的那部分父类型特征。

    this和super出现在实例方法和构造方法中。this的语法是:“this.”、“this()”、super的语法是:“super.”、“super()”。this和super不能使用在静态方法中。this.在区分局部变量和实例变量时不能省略;super.在“父类中有,子类中又有,如果在子类中访问‘父类的特征’时”,super.不能省略。

    this()和super()都只会出现在构造方法的第一行,前者是通过当前的构造方法去调用”本类“中的其它构造方法,目的是实现代码复用。后者是通过当前的构造方法去调用”父类“中的构造方法,目的是创建子类对象时先初始化父类型特征。

    当一个构造方法第一行既没有this()又没有super()的话,系统默认会有一个super()

    public class Super {
        public static void main(String[] args) {
            C c = new C();
        }
    }
    class A {
        //这个无参构造方法是B类的父类--A类的无参构造器,所以最后执行这个方法的语句
        //这个类似于栈,最后调用的最先出栈,即最先执行,故最先输出 “1”
        public A() {
            System.out.println("A类的无参构造方法执行");
        }
    }
    class B extends A {
        public B() {
            System.out.println("B类的无参构造方法执行");
        }
        public B(String name) {
            //super(name); 在B类中找带String参数的构造方法,所以第四个执行这条语句
            //super()  其实这块也有super,只不过是系统默认分配,看不到而已这块的super找它父类的无参构造方法
            System.out.println("B类的String类参数构造方法执行");
        }
    }
    class C extends B {
        public C () {
            this("zhangsan");
            // new C 时先执行这条语句
            System.out.println("C类的无参构造方法执行");
        }
        public C (String name) {
            // this("zhangsan");会在C类中找带String参数的构造方法,所以第二个执行这条语句
            this(name,20);
            System.out.println("C类的String类参数构造方法执行");
        }
        public C (String name, int age) {
            // this(name,20);会在C类中找带String,int参数的构造方法,所以第三个执行这条语句
            super(name);
            // 找它父类的方法 在B类中
            System.out.println("C类的String类和int类参数构造方法执行");
        }
    }
    

    代码执行结果
    super(实际参数) 【调用父类的构造方法】
    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关键字及其作用

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

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

    2020-09-18 23:09:08
    由于子类不能继承父类的构造方法,因此,如果要调用父类的构造...子类的构造方法显式的调用父类构造方法 访问父类的成员方法和变量。 1、使用super调用父类的构造方法 super必须是子类构造方法头一条语句 ...
  • Java中super关键字的三种用法: 子类的成员方法,访问父类的成员变量。 子类的成员方法,访问父类的成员方法。 子类的构造方法,访问父类的构造方法。
  • JAVA中Super关键字和this关键字的使用 父类 package demo03; public class Fu { int num=10; } 子类 package demo03; public class Zi extends Fu { int num=20; public void method(){ int num=30; S...
  • Java中 super关键字

    2017-04-14 09:58:08
    super关键字对象的内部使用,可以代表父类对象。 1.访问父类的属性 super.age; 2.访问父类的方法 super.eat(); 新建java项目演示: Init.java 是项目入口文件:package com.mydev; public class Init { /...
  • Java中super关键字浅谈

    2018-10-26 10:10:48
    1. super关键字表示父类的引用,可以通过super调用父类的方法和变量,静态方法不能使用this或super关键字 2. super.toString()此方法的值是子类,super.getClass().getName()的值指向子类的名称,想获取父类名称...
  • Java中super关键字详解

    千次阅读 2018-12-30 14:48:36
    在Java的基础学习,慢慢接触到许多陌生的关键字,今天来讲一下我所认识的super关键字 它的使用场景为:有继承⭐(必须继承下才能使用super) 一.super调用(父类)构造方法 看下面这段代码 class Person{...
  • 主要介绍了javasuper关键字用法实例解析,较为详细的分析了super关键字的用法及内存分布,需要的朋友可以参考下
  • java中super关键字是一个引用变量,用于引用父类对象。关键字“super”以继承的概念出现。 1.使用super与变量: 当派生类和基类具有相同的数据成员时,会发生此情况。这种情况下,JVM可能会模糊不清。...
  • java中super关键字是一个引用变量,用于引用父类对象。关键字“super”以继承的概念出现。主要用于以下情况:1.使用super与变量:当派生类和基类具有相同的数据成员时,会发生此情况。这种情况下,JVM可能...
  • super关键字构造方法 语法:super(实参); 作用:通过子类的构造方法去调用父类的构造方法 语法规则:一个构造方法第一行如果没有this(…) 也没有显示的去调用super(…) 系统会默认的调用super(); 注意:super(…...
  • super关键字用于访问和调用一个对象的父对象上的函数。即可以子类构造方法显示调用super(),完成对特定父类构造方法的调用。 super.prop和super[expr]表达式类和对象字面量任何方法定义中都是有效的。   ...
  • 一、super关键字 super理解为:父类的 super可以用来调用:属性、方法、构造器 二、super调用属性和方法 我们可以子类的方法或构造器。通过使用"super.属性"或"super.方法"的方式,显式的调用父类声明的...
  • super关键字 super关键字的用法有三种: 1.子类的成员方法,访问父类的成员变量。 2.子类的成员方法,访问父类的成员方法。 3.子类的构造方法,访问父类的构造方法。 public class Zi extends Fu { ...
  • 深入认识Java中super关键字

    千次阅读 2016-08-28 08:52:41
     网络上去查super关键字好多观点都讲,super关键字是指向父类的一个对象的引用,代表一个父类对象,但经过如下代码测试会发现如果父类是抽象类,子类依旧可以使用super关键字来调用父类中非private属性或方法。...
  • Java中super关键字的用法

    千次阅读 2021-01-05 11:02:28
    1.子类的成员方法,访问父类的成员变量 2.子类的成员方法,访问父类的成员方法 3.子类的构造方法,访问父类的构造方法 下面有一些代码关于this和super继承... System.out.println("super关键字的用法");
  • 1.super关键字可以子类的构造方法显示地调用父类的构造方法,super()必须为子类构造函数的第一行。 2.super可以用来访问父类的成员方法或变量,当子类成员变量或方法与父类有相同的名字时也会覆盖父类的成员...
  • Javasuper关键字详解

    2021-01-03 23:46:23
    这里分享下一java中super关键字的相关知识。 super关键字: super关键字代表了父类空间的引用。 super关键字的作用: 1. 子父类存在同名的成员时,子类默认是访问子类的成员,可以通过super关键字指定访问父类的...
  • 深入理解Java中super关键字

    千次阅读 2017-07-19 09:55:12
    Java中关键字 super表示的真正对象  java中super,大家都知道是表示一个父类的引用。上次群里见到一个网友询问 super.getClass().getName()的输出问题,大部分都知道输出的是当前这个类的类名。而不是父类的名称...
  • java中super关键字小结

    千次阅读 2015-08-16 21:07:33
    学习Java继承的相关的知识的时候,我们会遇到子类父类之间的继承关系,遇得到麻烦的向上塑形和向下塑形,自此总结一下,子父类继承关系super关键字的用法:
  • JAVA中SUPER关键字的三种用法 1.子类成员方法,访问父类的成员变量 2.子类的成员方法,访问父类的成员方法 3.子类的构造方法,访问父类的构造方法 子类 package demo08; /* * 1.子类成员方法,访问...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 136,675
精华内容 54,670
关键字:

在java中super关键字

java 订阅