精华内容
下载资源
问答
  • 一.super关键字的用法有三种: 1.在子类的成员方法种,访问父类的成员变量(重名或不重名)。 public class Fu3 { int num = 10; } public class Zi3 extends Fu3{ int num = 20; public void method(){...

    一.super关键字的用法有三种:

    1.在子类的成员方法种,访问父类的成员变量(重名或不重名)。

    public class Fu3 {
        int num = 10;
    }
    public class Zi3 extends Fu3{
        int num = 20;
    
        public void method(){
            System.out.println(num); // 20 就近原则
            System.out.println(super.num); // 10 父类的成员变量
        }
    }

    2.在子类的成员方法种,访问父类的成员方法(重名或不重名)。

    public class Fu3 {
        int num = 10;
        public void method(){
            System.out.println("父类的成员方法");
        }
    }
    public void method2(){
        method(); // 就近
        super.method(); // 父类
    }

    3.在子类的构造方法中,访问父类的构造方法。

    总结:super关键字是用来在子类访问父类的内容的,this关键字是在本类的内容的。

     

    二.this关键字的用法有三种:

    1.在本类的成员方法中,访问本类的成员变量(重名或不重名)。

    int num = 10;
    
    public void method(){
        int num = 20;
        System.out.println(num); // 20 局部变量
        System.out.println(this.num); // 10 本类的成员变量
    }

    2.在本类的成员方法中,访问本类的另一个成员方法。

    public void methodA(){
        System.out.println("AAA");
    }
    public void methodB(){
        methodA(); // 可以直接调用
        this.methodA(); 
        System.out.println("BBB");
    }

    3.在本类的构造方法中,访问本类的另一个构造方法。

    public Demo04Constructor() {
        // super(); // 这一行不再赠送
        this(123); // 这是本类的无参构造方法,调用本类的有参构造
        System.out.println("无参构造方法");
    }
    public Demo04Constructor(int n) {
        System.out.println("有参构造方法");
    }

    注意:

    A.在第三种英法当中要注意,this(...)调用必须是构造方法的第一个且唯一的语句。

    B.super和this两种构造调用,不能同时使用,因为它们都要求是唯一的第一个。

     

    展开全文
  • ①类进行初始化,初始化的简便方法(适用于eclipse) Source→Generate Constructor using Fields…→Generate 具体的构造方法中的内容在这我就不解释了,相信大家应该都知道 ②在Salary类使用super关键字调用父类的...

    话不多说,先看题

    小明工作的公司最近要升级系统了,原先的员工管理系统有一个Employee类用于管理员工的姓名、出生年月、职位等个人信息,现在老板希望新增加一个Salary类用于管理员工的工资。小明公司的老板非常抠门,他要求Salary类要继承Employee类,以减小后期对系统的维护成本。小明感觉无从下手,便请你来帮忙。

    在这里插入图片描述

    初始的代码如下:

    package step2;
    
    import java.util.Scanner;
    
    public class SystemUpdate {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            String name = scanner.next();
            String birth = scanner.next();
            String position = scanner.next();
            double salary = scanner.nextDouble();
            Salary employee = new Salary(name, birth, position, salary);
            employee.introduction();
        }
    }
    
    /********** Begin *********/
    class Employee {
        private String name;
        private String birth;
        private String position;
    
    }
    
    class Salary extends Employee {
        private double salary;
    }
    /********** End *********/
    
    

    根据要求

    类进行初始化,初始化的简便方法(适用于eclipse)

    Source→Generate Constructor using Fields…→Generate
    在这里插入图片描述
    具体的构造方法中的内容在这我就不解释了,相信大家应该都知道

    在Salary类使用super关键字调用父类的方法。
    首先题目中测试类里面使用的是

    Salary employee = new Salary(name, birth, position, salary);
    

    明显是有四个参数的传递,而在Employee类中构造方法只有三个参数,明显不足以接收,这也就是需要我们使用Salary类了,我们对Employee进行继承,然后再增加一个salary参数,这样参数就正好四个,足以接收所有数据了

    所以接下来就是在salary类中创建构造方法使用继承,将name,position,birth值录入,再单独将salary的值录入

    public Salary(String name, String birth, String position,double salary) {
    		super(name,birth,position);
    		this.salary = salary;
    	}
    

    当所需的值都录入好以后,就按要求创建introduction方法即可
    相似我也是用到继承

    最后的代码如下:

    package step2;
    
    import java.util.Scanner;
    
    public class SystemUpdate {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            String name = scanner.next();
            String birth = scanner.next();
            String position = scanner.next();
            double salary = scanner.nextDouble();
            Salary employee = new Salary(name, birth, position, salary);
            employee.introduction();
        }
    }
    
    /********** Begin *********/
    class Employee {
        private String name;
        private String birth;
        private String position;
        public Employee(String name, String birth, String position) {
    		super();
    		this.name = name;
    		this.birth = birth;
    		this.position = position;
    	}
    
        public Employee() {
    		super();
    	}
    
        public void introduction() {
    		System.out.print("员工姓名:"+name+" 出生年月:"+birth+" 职位:"+position);
    	}
    }
    
    class Salary extends Employee {
        private double salary;
    
        public Salary(String name, String birth, String position,double salary) {
    		super(name,birth,position);
    		this.salary = salary;
    	}
    	public void introduction() {
    		super.introduction();
    		System.out.print(" 薪水:"+salary);
    	}
    }
    /********** End *********/
    
    

    我对本题的思路以及代码,都在这了,本文主要是记录自己写题时的一些思路,也方便以后对知识的回顾,仅供大家参考参考,如果文章内容有什么不对的地方,还请看见的大佬指正指正。

    展开全文
  • super关键字使用

    2021-01-13 19:19:29
    super关键字使用 1.super理解为:父类的 2.super可以来调用:属性、方法、构造器 3.super的使用:调用属性和方法 3.1我们可以在子类的方法或构造器中。通过使用“super.属性”或"super.方法"的方式,显式的调用...

    super关键字的使用

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

    展开全文
  • 关于this和super this的用法: 把当前对象的引用作为参数传递给另一个方法。如obj.f(this); this.属性名 如果方法里的局部变量(包括形参)和成员变量同名,而我们的程序的目的是要访问被覆盖后的成员变量,则...

    关于this和super

    this的用法:

    把当前对象的引用作为参数传递给另一个方法。如obj.f(this);

    this.属性名

    如果方法里的局部变量(包括形参)和成员变量同名,而我们的程序的目的是要访问被覆盖后的成员变量,则必须使用this.变量名。

    比如说定义一个人类;

    class person{

    String name;

    person(String name){

    this.name=name;

    }

    }

    class Test{

    public static void main(String[] args){

    person a=new person("李明璐");

    System.out.println(a.name);

    }

    }

    在这里的构造参数是person(String name),这里的形参数name与我们的成员属性name同名,因此在·构造函数里我们要this.name=name;否则这里的成员变量会变成 默认值null如果形参不是name而是其他的名字比如说n,那我们这里就不需要这样做。

    this.方法名

     这个状态才能让this起到最大的作用

     this关键字的最大的作用就是让类中的一个方法来访问类里的另一个方法或实例变量

    this.方法名

    this 关键字最大的作用就是让类中一个方法,访问该类里的另一个方法或实例变量。

    例 2

    假设定义了一个 Dog 类,这个 Dog 对象的 run( ) 方法需要调用它的 jump( ) 方法,Dog 类的代码如下所示:

    /**

     * 第一种定义Dog类方法

     **/

    Public class Dog{

    // 定义一个jump()方法

    publicvoidjump(){

    System.out.println("正在执行jump方法");

    }

    // 定义一个run()方法,run()方法需要借助jump()方法

    publicvoidrun(){

    Dog d =newDog();

    d.jump();

    System.out.println("正在执行 run 方法");

    }

    }

    使用这种方式来定义这个 Dog 类,确实可以实现在 run( ) 方法中调用 jump( ) 方法。下面再提供一个程序来创建 Dog 对象,并调用该对象的 run( ) 方法。

    Public class DogTest{

    Public stati cvoid main(String[]args){

    // 创建Dog对象

    Dog dog =newDog();

    // 调用Dog对象的run()方法

    dog.run();

    }

    }

    在上面的程序中,一共产生了两个 Dog 对象,在 Dog 类的 run( ) 方法中,程序创建了一个 Dog 对象,并使用名为 d 的引用变量来指向该 Dog 对象。在 DogTest 的 main() 方法中,程序再次创建了一个 Dog 对象,并使用名为 dog 的引用变量来指向该 Dog 对象。

    下面我们思考两个问题。

    1)在 run( ) 方法中调用 jump( ) 方法时是否一定需要一个 Dog 对象?

    答案是肯定的,因为没有使用 static 修饰的成员变量和方法都必须使用对象来调用。

    2)是否一定需要重新创建一个 Dog 对象?

    不一定,因为当程序调用 run( ) 方法时,一定会提供一个 Dog 对象,这样就可以直接使用这个已经存在的 Dog 对象,而无须重新创建新的 Dog 对象了。因此需要在 run() 方法中获得调用该方法的对象,通过 this 关键字就可以满足这个要求。

    this 可以代表任何对象,当 this 出现在某个方法体中时,它所代表的对象是不确定的,但它的类型是确定的,它所代表的只能是当前类的实例。只有当这个方法被调用时,它所代表的对象才被确定下来,谁在调用这个方法,this 就代表谁。

    将前面的 Dog 类的 run( ) 方法改为如下形式会更加合适,run( ) 方法代码修改如下,其它代码不变。

    /**

     * 第二种定义Dog类方法

     **/

    // 定义一个run()方法,run()方法需要借助jump()方法

    publicvoidrun(){

    // 使用this引用调用run()方法的对象

    this.jump();

    System.out.println("正在执行run方法");

    }

    从第一种 Dog 类定义来看,在 Dog 对象的 run( ) 方法内重新创建了一个新的 Dog 对象,并调用它的 jump( ) 方法,这意味着一个 Dog 对象的 run( ) 方法需要依赖于另一个 Dog 对象的 jump( ) 方法,这不符合逻辑。

    第二种 Dog 类定义是当一个 Dog 对象调用 run( ) 方法时,run( ) 方法需要依赖它自己的 jump( ) 方法,与第一种定义类的方法相比,更符合实际情形。

    在现实世界里,对象的一个方法依赖于另一个方法的情形很常见,例如,吃饭方法依赖于拿筷子方法,写程序方法依赖于敲键盘方法。这种依赖都是同一个对象两个方法之间的依赖。因此,Java 允许对象的一个成员直接调用另一个成员,可以省略 this 前缀。也就是说,将上面的 run( ) 方法改为如下形式也完全正确。

    publicvoidrun(){

    jump();

    System.out.println("正在执行run方法");

    }

    大部分时候,一个方法访问该类中定义的其他方法、成员变量时加不加 this 前缀的效果是完全一样的。

    注意:对于 static 修饰的方法而言,可以使用类来直接调用该方法,如果在 static 修饰的方法中使用 this 关键字,则这个关键字就无法指向合适的对象。所以,static 修饰的方法中不能使用 this 引用。并且 Java 语法规定,静态成员不能直接访问非静态成员

    省略 this 前缀只是一种假象,虽然程序员省略了调用 jump() 方法之前的 this,但实际上这个 this 依然是存在的。

     this()访问构造方法

     this()作为方法用于一个构造函数里是调用另一个构造函数,不能用于其他成员函数

     this(x,y);x对第一个成员变量赋值,y对第二个成员变量赋值

     super访问父类成员

    super表示当前对象的直接父类对象引用,使用super可以访问被子类重新声明而隐藏的父类的变量和方法(意思就是子类里有与父类相同名字的变量或者方法‘重载了’)

    class person{

    String name;

    int age;

    person(String name,int age){

    this.name=name;

    this.age=age;

    }

    }

    class student extends person{

    int grade;

    student(String name,int age,int grade){

    super(name,age);//调用父类的构造函数

    this.grade=grade;

    }

    public String toString(){//注意这里的toString()要使用public访问控制否则无法覆盖Object类的toString()方法

    String s="Name: "+name+"\n";//这里想要输出\n就只需要在"\\n"即可

    s+="Ages: "+age+"\n";

    s+="Grade: "+grade+"\n";

    return s;

    }

    }

    class Test{

    public static void main(String[] args){

    student s=new student("李明璐",19,2);

    System.out.print(s.toString());

    }

    }

    C:\Users\86183\java>java Test

    Name: 小李

    Ages: 19

    Grade: 2

    super调用父类的构造方法和this一样必须放在第一句

    展开全文
  • super关键字使用
  • 通过用static来定义方法或成员,为我们编程提供了某种便利,从某种程度上可以说它类似于C语言中的全局函数和全局变量。...super这两个关键字的意义和用法。在Java中,this通常指当前对象,super则指父类的。当你想要...
  • 一、this关键字的用法 this关键字代表当前对象的引用,用在当前类中。主要有三个用法 this(),代表在当前类中调用其他的构造方法,并且只能在构造方法中写,只能调用一次,只能写在第一...二、super关键字的用法 super
  • this关键字 一、概念 this: 存储的“当前对象”的引用 this可以访问:本类的成员属性,成员方法,构造方法 二、this关键字的用法 1、this访问本类的成员变量 class Student{ //成员属性 String name; ...
  • 导读正文构造方法中的super关键字在Java子类的构造方法中可以通过super关键字来调用父类的构造方法。其用法为:1) super(); 访问父类中的无参构造函数2) super (paras…); 访问父类中的成员函数yyysuper()来调用父类...
  • super:super关键字和this的作用类似,将被隐藏的父类的成员变量和成员方法变为可见,或者说用来引用被隐藏的父类的成员成员变量和成员方法。 使用场景: 1.使用super和this调用成员变量和方法 有时会遇到子类中的...
  • java中super关键字的作用

    千次阅读 2021-03-13 18:51:05
    1.super关键字可以在子类的构造方法中显示地调用父类的构造方法,super()必须为子类构造函数中的第一行。2.super可以用来访问父类的成员方法或变量,当子类成员变量或方法与父类有相同的名字时也会覆盖父类的成员...
  • 首先我们先来介绍以下super关键字与this关键字:一、this关键字this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针。this的用法在java中大体可以分为3种:1、普通的直接引用this相当于是指向...
  • java之super关键字

    2021-03-14 20:53:56
    一、super 关键字的特点: 1.super 和 this 关键字的特点类似 super 代表的是父类对象的引用 2.当子父类的成员出现同名时 可以通过 super 来区别 3.子类的构造方法中 通过super 关键字调用父类的构造方法 强调: 当...
  • 因为子类不可以继承父类的构造方法,所以,想要调用父类的构造方法的话,那么就可以使用得到super关键字下面的话就来对这个方面做一下详细的讲解。super关键字能够用来访问父类的构造方法、普通方法和属性。super...
  • 对于编码项目,我有一个包含嵌套类的类.嵌套类在同一个外部类中进行子类化....我也注意到,似乎可以使用标记为受保护而不是私有的数据,而不使用超级关键字.我最感兴趣的是提供超级关键字的这种能力的任何文档.提前致谢.
  • java中super关键字与this关键字的区别是什么发布时间:2020-09-01 14:58:57来源:亿速云阅读:97作者:小新这篇文章给大家分享的是有关java中super关键字与this关键字的区别是什么的内容。小编觉得挺实用的,因此...
  • 属性私有化:通过private关键字来修饰属性,且被private修饰的属性,方法等只能在本类的内部使用。 读写接口公有化:在类中提供通过public关键字修饰的getter和setter方法,来实现获取和修改属性的值,在方法内部...
  • 详解 继承(下)—— super关键字 与 多态,关键字this和super接上篇博文——《详解 继承(上)—— 工具的抽象与分层》废话不多说,进入正题:本人在上篇“故弄玄虚”,用super();解决了问题,这是为什么呢?答曰:子类...
  • super关键字的三种用法:在子类的成员方法中,访问父类的成员变量在子类的成员方法中,访问父类的成员方法在子类的构造方法中,访问父类的构造方法实例如下:创建一个父类:package JiCheng.Super.Super;public ...
  • super关键字

    2021-04-22 09:11:28
    从上一个例子中的运行结果可以看出,当子类重写父类的方法后,子类对象将无法访问父类被重写的方法...使用super关键字调用父类的成员变量和成员方法。具体格式如下:super.成员变量super.成员方法([参数1,参数2…])...
  • 下列选项Perhaps language should be ________ as a road map and valuable possession.在确定薪酬水平时,中关a中企业通常可以采用( )策略。键字在线大学能够帮您做什么呢?法错在线大学几个关键概念有哪些?...
  • 39.类的继承java描述类的时候,咱们若是发现有几个类有重复的属性和方法,咱们就能够采用继承的方法来设计ide使用extends关键字来继承this语法:设计class 子类 extends 父类{对象子类属性继承子类方法内存}资源特色...
  • java中this和super关键字

    2021-10-03 21:30:03
    1、this关键字 this() 代表本类中的构造方法中调用另一个构造方法 必须放在构造方法的第一句,不能出现两个 ...2、super关键字 super() 代表本类中父类的构造方法,也只能写在第一句 父类的构
  • 1.1 使用super关键字调用父类的成员变量和成员方法 dog类继承与Animal,在dog类中重写shout方法,通过super.shout()访问父类Animal类中的shout方法,通过super.name访问Animal类中的name属性 package com.blog; //...
  • Student(String name,int age,String school){ super(name,age); this.school = school; } /********* end *********/ } 测试结果: 姓名:张三,年龄:18,学校:哈佛大学 世界之大无奇不有,我算是见识到了。小编...
  • super 关键字与this类似,this 用来表示当前类的实例,super 用来表示父类。super 可以用在子类中,通过点号(.)来获取父类的成员变量和方法。super 也可以用在子类的子类中,Java 能自动向上层类追溯。父类行为被...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 198,873
精华内容 79,549
关键字:

super关键字的使用