精华内容
下载资源
问答
  • 文章目录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关键字

    2020-11-08 01:15:32
    super关键字的讲解 文章目录super关键字的讲解1. super 关键字可以理解为:父类的2. 可以用来调用的结构:3. super调用属性、方法:4....3.1 我们可以子类的方法或构造器。通过使用"super.属性"或

    super关键字的讲解

    b站学习视频以及笔记-尚硅谷_Java零基础教程

    java入门必备-适合初学者的全套完整版教程(宋红康主讲)

    1. super 关键字可以理解为:父类的

    2. 可以用来调用的结构:

    属性、方法、构造器

    3. super调用属性、方法:

    3.1 我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式,显式的调用父类中声明的属性或方法。但是,通常情况下,我们习惯省略"super."
    3.2 特殊情况:当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性,则必须显式的使用"super.属性"的方式,表明调用的是父类中声明的属性。
    3.3 特殊情况:当子类重写了父类中的方法以后,我们想在子类的方法中调用父类中被重写的方法时,则必须显式的使用"super.方法"的方式,表明调用的是父类中被重写的方法。

    4. super调用构造器:

    4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器
    4.2 "super(形参列表)"的使用,必须声明在子类构造器的首行!
    4.3 我们在类的构造器中,针对于"this(形参列表)"或"super(形参列表)“只能二一,不能同时出现
    4.4 在构造器的首行,没显式的声明"this(形参列表)“或"super(形参列表)”,则默认调用的是父类中空参的构造器:super()
    4.5 在类的多个构造器中,至少一个类的构造器中使用了"super(形参列表)”,调用父类中的构造器

    5. 代码实现:

    父类
    public class Person {
    	String name;
    	int age;
    	int id = 1001;//身份证号
    	
    	public Person(){
    		System.out.println("我无处不在!");
    	}
    	
    	public Person(String name){
    		this.name = name;
    	}
    	
    	public Person(String name,int age){
    		this(name);
    		this.age = age;
    	}
    	
    	public void eat(){
    		System.out.println("人:吃饭");
    	}
    	public void walk(){
    		System.out.println("人:走路");
    	}
    }
    
    子类
    public class Student extends Person{
    	
    	String major;
    	int id = 1002;//学号
    	
    	public Student(){
    		super();//调用父类无参构造方法
    	}
    	public Student(String major){
    		super();//调用父类无参构造器
    		this.major = major;
    	}
    	
    	public Student(String name,int age,String major){
    //		this.name = name;
    //		this.age = age;
    		super(name,age);//调用父类有参构造器
    		this.major = major;
    	}
    	
    	//重写
    	@Override
    	public void eat() {
    		System.out.println("学生:多吃有营养的食物");
    	}
    	
    	public void study(){
    		System.out.println("学生:学习知识");
    		this.eat();
    		super.eat();//父类eat方法
    		walk();//调用父类方法
    	}
    	
    	public void show(){
    		System.out.println("name = " + name + ", age = " + age);
    		System.out.println("id = " + this.id);
    		System.out.println("id = " + super.id);
    	}
    }
    
    
    测试类
    public class SuperTest {
    	public static void main(String[] args) {
    		
    		Student s = new Student();//调用父类构造器
    		s.show();//Student类的重写show方法
    		
    		System.out.println();
    		
    		s.study();//Student类的重写study方法
    		
    		Student s1 = new Student("Tom", 21, "IT");
    		s1.show();
    		
    		System.out.println("************");
    		Student s2 = new Student();//调用父类构造器
    		
    	}
    }
    

    image-20201108011039784

    展开全文
  • Java中super关键字

    2020-12-22 19:41:07
    在Java中,有时还会遇到子类中的成员变量或方法与父类中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高,所以子类中的同名成员变量或方法隐藏了父类的成员变量或方法,但是我们如果想要使用父类中的...
  • Java中super关键字的使用(实例方法中)super和this都可以使用实例方法中,并且都不能使用静态方法当中,“this”大部分情况下都是可以省略的,只有方法中区分局部变量和实例变量的时候不能省略。那“super”...

    Java中super关键字的使用(在实例方法中)

    super和this都可以使用在实例方法中,并且都不能使用在静态方法当中,“this”大部分情况下都是可以省略的,只有在方法中区分局部变量和实例变量的时候不能省略。那“super”什么时候可以省略,什么时候不能省略呢?

    //书

    public class Book {

    //书名

    String name;

    //构造方法

    public Book(){

    super();

    }

    public Book(String name){

    super();

    this.name = name;

    }

    }

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    //纸质书

    public class PaperBook extends Book {

    //构造方法

    public PaperBook(){

    super();

    }

    public PaperBook(String name){

    super();

    this.name = name;

    }

    //打印书名

    public void printName(){

    System.out.println("this.name->书名 : " + this.name);

    System.out.println("super.name->书名 : " + super.name);

    }

    }

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    public class BookTest {

    public static void main(String[] args) {

    PaperBook book1 = new PaperBook("零基础学Java卷I");

    book1.printName();

    }

    }

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    运行结果如下图所示:

    2349b0e5addcfbe36f078f572d1b4e5f.png

    图14-11:super和this

    我们发现printName()方法中的super.name和this.name最终输出结果是一样的,这是为什么呢?请看以上程序执行的内存图:

    25d7ae4b55a6cf2c34319aa927a01191.png

    图14-12:父类的构造方法执行结束之后的内存图

    7e0c4a47b356f97fe08592a46a7aa585.png

    图14-13:子类的构造方法执行结束之后的内存图

    通过以上内存结构图发现this.name和super.name实际上是同一块内存空间,所以它们的输出结果是完全一样的。接下来,我们再把以上的PaperBook类修改一下:

    //纸质书

    public class PaperBook extends Book {

    String name; //在子类中也定义了一个name属性

    //构造方法

    public PaperBook(){

    super();

    }

    public PaperBook(String name){

    super();

    this.name = name;//这里的this.name代表子类的name

    }

    //打印书名

    public void printName(){

    System.out.println("this.name->书名 : " + this.name);

    System.out.println("super.name->书名 : " + super.name);

    }

    }

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    运行结果如下图所示:

    c547e4fd673f3147a43921e3400ce063.png

    图14-14:super和this的区别

    为什么super.name是null呢,我们一起来看看以上程序的内存图:

    0f141631b2c13d2d8102187c59c74ae9.png

    图14-15:父类Book的构造方法执行之后的内存图

    6749c85f3056097763dafba13ae704a9.png

    图14-16:子类PaperBook的构造方法执行结束之后的内存图

    通过以上内存图可以清楚的看到,父类Book的构造方法在执行的时候给super.name赋值null,子类PaperBook的构造方法在执行的时候给this.name赋值“零基础学Java卷I”,由于在子类PaperBook中定义了重名的变量name导致在当前对象中有两个name,一个是从父类中继承过来的,一个是自己的,如果此时想访问父类中继承过来的name则必须使用super.name,当直接访问name或者this.name都表示访问当前对象自己的name。

    通过以上的学习,大家知道super在什么情况下不能省略了吗?当父类中有该实例变量,子类中又重新定义了同名的实例变量,如果想在子类中访问父类的实例变量,super不能省略。实例方法是这样吗?我们可以来测试一下,请看代码:

    public class Vip {

    //Vip默认继承Object

    //重写从Object类中继承过来的toString()方法

    public String toString(){

    return "我是金牌会员";

    }

    public void test(){

    System.out.println(super.toString());

    System.out.println(this.toString());

    System.out.println(toString());

    }

    }

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    public class VipTest {

    public static void main(String[] args) {

    Vip vip = new Vip();

    vip.test();

    }

    }

    wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==wAAACH5BAEKAAAALAAAAAABAAEAAAICRAEAOw==

    运行结果如下图所示:

    78d8c11e484c972f5e8b18516b9401b7.png

    图14-17:运行结果

    通过以上测试得出最终结论:父类和子类中有同名实例变量或者有同名的实例方法,想在子类中访问父类中的实例变量或实例方法,则super是不能省略的,其它情况都可以省略。

    展开全文
  • 一、super关键字在JAVA使用super来引用父类的成分,用this来引用当前对象,如果一个类从另外一个类继承,我们new这个子类的实例对象的时候,这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢?...

    一、super关键字

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

    class Student {

    public int age;

    public void std(){ //声明Student类的方法std()

    age = 15;

    System.out.println("学生平均年龄为:"+age);

    }

    }

    class ThisStudent extends Student{

    public int age;

    public void std(){

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

    age = 18;

    System.out.println("这个学生的年龄为:"+age);

    System.out.println(super.age); //使用super作为父类对象的引用对象来调用父类对象中的age值

    System.out.println(age);

    }

    }

    public class TestDif {

    public static void main(String[] args) {

    ThisStudent a = new ThisStudent();

    a.std();

    }

    }

    执行结果:

    学生平均年龄为:15

    这个学生的年龄为:18

    15

    18

    二、上述程序的内存分析

    ThisStudent a = new ThisStudent();

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

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

    4aeeb7d3022c81228d310db3eaa99863.png

    a.std();

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

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

    b5782faedbd4d3b86735b60870dc8c5c.png

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

    到此,整个内存分析就结束了,最终内存显示的结果如上面所示。

    (参考自孤傲苍狼)

    展开全文
  • Java中super关键字及其作用 super关键字及其作用 A:super关键字指代父类对象引用(super代表父类存储空间的标识) B:作用: a:访问被子类隐藏的父类同名成员变量和成员方法 ; b:调用父类构造方法,且必须子类构造...
  • Java中super关键字介绍

    2020-09-18 23:09:08
    由于子类不能继承父类的构造方法,因此,如果要调用父类的构造...子类的构造方法显式的调用父类构造方法 访问父类的成员方法和变量。 1、使用super调用父类的构造方法 super必须是子类构造方法头一条语句 ...
  • 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关键字的三种用法: 子类的成员方法中,访问父类的成员变量。 子类的成员方法中,访问父类的成员方法。 子类的构造方法中,访问父类的构造方法。
  • Java中super关键字详解

    千次阅读 2018-12-30 14:48:36
    在Java的基础学习,慢慢接触到许多陌生的关键字,今天来讲一下我所认识的super关键字 它的使用场景为:有继承在⭐(必须在继承下才能使用super) 一.super调用(父类)构造方法 看下面这段代码 class Person{...
  • java中super关键字是一个引用变量,用于引用父类对象。关键字“super”以继承的概念出现类中。 1.使用super与变量: 当派生类和基类具有相同的数据成员时,会发生此情况。这种情况下,JVM可能会模糊不清。...
  • super关键字 super关键字的用法有三种: 1.子类的成员方法,访问父类的成员变量。 2.子类的成员方法,访问父类的成员方法。 3.子类的构造方法,访问父类的构造方法。 public class Zi extends Fu { ...
  • 1.super关键字可以子类的构造方法显示地调用父类的构造方法,super()必须为子类构造函数的第一行。2.super可以用来访问父类的成员方法或变量,当子类成员变量或方法与父类有相同的名字时也会覆盖父类的成员...
  • 在java中,子类继承父类,一般会用到super关键字,下面我们介绍super的使用。本文的内容也是配套B站上一位老师的教学视频进行的笔记记录。内容如下: 目录 一、子类构造方法中super的使用 1.调用子类的构造方法...
  • Java中super关键字用法

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

    千次阅读 2016-08-28 08:52:41
     网络上去查super关键字好多观点都讲,super关键字是指向父类的一个对象的引用,代表一个父类对象,但经过如下代码测试会发现如果父类是抽象类,子类依旧可以使用super关键字来调用父类中非private属性或方法。...
  • super关键字构造方法 语法:super(实参); 作用:通过子类的构造方法去调用父类的构造方法 语法规则:一个构造方法第一行如果没有this(…) 也没有显示的去调用super(…) 系统会默认的调用super(); 注意:super(…...
  • 1.super关键字可以子类的构造方法显示地调用父类的构造方法,super()必须为子类构造函数的第一行。 2.super可以用来访问父类的成员方法或变量,当子类成员变量或方法与父类有相同的名字时也会覆盖父类的成员...
  • Java中super关键字浅谈

    2018-10-26 10:10:48
    1. super关键字表示父类的引用,可以通过super调用父类的方法和变量,静态方法不能使用this或super关键字 2. super.toString()此方法的值是子类,super.getClass().getName()的值指向子类的名称,想获取父类名称...
  • 1.子类的成员方法,访问父类的成员变量 2.子类的成员方法,访问父类的成员方法 3.子类的构造方法,访问父类的构造方法 下面有一些代码关于this和super继承... System.out.println("super关键字的用法");
  • JAVA中SUPER关键字的三种用法 1.子类成员方法中,访问父类的成员变量 2.子类的成员方法中,访问父类的成员方法 3.子类的构造方法中,访问父类的构造方法 子类 package demo08; /* * 1.子类成员方法中,访问...

空空如也

空空如也

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

在java中super关键字

java 订阅