精华内容
下载资源
问答
  • javathis和super用法 this和 super 关键字的区别
  • this和Super关键字this和Super关键字的对比Super关键字的用法如下:1. super关键字代表了父类空间的引用;2. super关键字的作用:3. super关键字调用父类构造方法要注意的事项:this关键字的用法如下:1.了解没有 ...

    this和Super关键字的对比

    - this super()
    概念 访问本类实列属性和方法 有子类访问父类中的实列属性和方法
    查找范围 先找本类,找不到再找父类 找父类
    各异功能 单独使用时,表示当前对象 在子类重写父类方法时,访问父类同名方法
    相同点 1.都是关键字,起指代作用2.在构造方法中必须出现在第一行

    Super关键字的用法如下:

    1. super关键字代表了父类空间的引用;

    2. super关键字的作用:

    (1) 子父类存在着同名的成员(包括变量和方法)时,在子类中默认是访问子类的成员,可以通过super关键字指定访问父类的成员;
    (2) 创建子类对象时,默认会先调用父类无参的构造方法,可以通过super关键字指定调用父类的构造方法。
    (1) 如果在子类的构造方法上没有指定调用父类的构造方法,那么java编译器会在子类的构造方法内加上super()语句。
    (2) super关键字调用父类的构造函数时,该语句必须要是子类构造函数中的第一个语句。
    (3) super与this关键字不能同时出现在同一个构造函数中调用其他的构造函数。因为两个语句都需要第一个语句。
    (1) 代表的事物不一致。
    ① super关键字代表的是父类空间的引用。(并不能代表对象,只是代表一个对象中的一块内存而已)
    ② this关键字代表的是所属函数的调用者对象。
    (2) 使用前提不一致。
    ① super关键字必须要有继承关系才能使用。
    ② this关键字不需要存在继承关系也可使用。
    (3) 调用构造函数的区别:
    ① super关键字是调用父类的构造函数。
    ② this关键字是调用本类的构造函数。

    3. super关键字调用父类构造方法要注意的事项:

    注意:是两个关键字不能同时出现在同一个构造函数中去调用其他的构造函数,里面还是可以写this.num = num。并不是说不能出现this。

    this关键字的用法如下:

    1. this关键字可用来引用当前类的实例变量。
    2. this关键字可用于调用当前类方法(隐式)。
    3. this()可以用来调用当前类的构造函数。
    4. this关键字可作为调用方法中的参数传递。
    5. this关键字可作为参数在构造函数调用中传递。
    6. this关键字可用于从方法返回当前类的实例。
      建议:如果你是java初学者,只学习 this 关键字的前三个用法就可以了。
    1. this:引用当前类的实例变量 this关键字可以用来引用当前类的实例变量。如果实例变量和参数之间存在歧义,则 this 关键字可用于明确地指定类变量以解决歧义问题。

    1.了解没有 this 关键字的问题

    下面先来理解一个不使用 this 关键字的示例:

    class Student {
        int rollno;
        String name;
        float fee;
        Student(int rollno, String name, float fee) {
        rollno = rollno;
        name = name;
        fee = fee;
    	}
        void display() {
            System.out.println(rollno + " " + name + " " + fee);
        }
    }
    class TestThis1 {
    	public static void main(String args[]) {
    		Student s1 = new Student(111, "ankit", 5000f);
            Student s2 = new Student(112, "sumit", 6000f);
            s1.display();
            s2.display();
        }
    }
    

    执行上面代码输出结果如下 -

    0 null 0.0
    0 null 0.0
    

    在上面的例子中,参数(形式参数)和实例变量(rollno和name)是相同的。 所以要使用this关键字来区分局部变量和实例变量。

    使用 this 关键字解决了上面的问题

    class Student {
        int rollno;
        String name;
        float fee;
        Student(int rollno, String name, float fee) {
    	    this.rollno = rollno;
    	   	this.name = name;
            this.fee = fee;
        }
    	void display() {
            System.out.println(rollno + " " + name + " " + fee);
        }
    }
    class TestThis2 {
        public static void main(String args[]) {
            Student s1 = new Student(111, "ankit", 5000f);
            Student s2 = new Student(112, "sumit", 6000f);
            s1.display();
            s2.display();
        }
    }
    

    执行上面代码输出结果如下 -

    111 ankit 5000
    112 sumit 6000
    

    如果局部变量(形式参数)和实例变量不同,则不需要像下面的程序一样使用this关键字:

    2. 不需要 this 关键字的程序示例

    class Student {
       	int rollno;
        String name;
     	float fee;
    	Student(int r, String n, float f) {
       		rollno = r;
            name = n;
            fee = f;
        }
     void display() {
            System.out.println(rollno + " " + name + " " + fee);
     }  
    }
    
    class TestThis3 {
        public static void main(String args[]) {
            Student s1 = new Student(111, "ankit", 5000f);
            Student s2 = new Student(112, "sumit", 6000f);
            s1.display();
            s2.display();
        }
    }
    

    执行上面代码输出结果如下 -

    111 ankit 5000
    112 sumit 6000
    

    对变量使用有意义的名称是一种好的编程习惯。所以使用相同名称的实例变量和参数,并且总是使用this关键字。

    3. this:调用当前类方法

    可以使用this关键字调用当前类的方法。如果不使用this关键字,编译器会在调用方法时自动添加此 this 关键字。我们来看看这个例子。

    执行上面代码输出结果如下 -

    hello n
    hello m

    3. this():调用当前类的构造函数

    this()构造函数调用可以用来调用当前类的构造函数。 它用于重用构造函数。 换句话说,它用于构造函数链接。

    从参数化构造函数调用默认构造函数:

    class A {
        A() {
            System.out.println("hello a");
        }
    	A(int x) {
            this();
            System.out.println(x);
        }
    }
    
    class TestThis5 {
        public static void main(String args[]) {
            A a = new A(10);
        }
    }
    

    执行上面代码输出结果如下 -

    hello a
    10
    

    从默认构造函数调用参数化构造函数:

    class A {
        A() {
            this(5);
            System.out.println("hello a");
        }
    	A(int x) {
            System.out.println(x);
        }
    }
    
    class TestThis6 {
        public static void main(String args[]) {
            A a = new A();
        }
    }
    

    执行上面代码输出结果如下 -

    5
    hello a
    

    4. 使用this()构造函数调用

    this()构造函数调用用于从构造函数重用构造函数。 它维护构造函数之间的链,即它用于构造函数链接。看看下面给出的示例,显示this关键字的实际使用。

    class Student {
        int rollno;
        String name, course;
        float fee;
     	Student(int rollno, String name, String course) {
            this.rollno = rollno;
            this.name = name;
            this.course = course;
        }
    	Student(int rollno, String name, String course, float fee) {
            this(rollno, name, course);// reusing constructor
            this.fee = fee;
    	}
    	void display() {
            System.out.println(rollno + " " + name + " " + course + " " + fee);
    	}
    }
    
    class TestThis7 {
        public static void main(String args[]) {
            Student s1 = new Student(111, "ankit", "java");
            Student s2 = new Student(112, "sumit", "java", 6000f);
            s1.display();
            s2.display();
        }
    }
    

    执行上面代码输出结果如下 -

    111 ankit java null
    112 sumit java 6000
    

    注意:调用this()必须是构造函数中的第一个语句。

    下面示例为不把 this() 语句放在第一行,因此编译不通过。

    class Student {
        int rollno;
        String name, course;
        float fee;
    	Student(int rollno, String name, String course) {
    	        this.rollno = rollno;
    	        this.name = name;
    	        this.course = course;
    	}
    	Student(int rollno, String name, String course, float fee) {
    	        this.fee = fee;
    	        this(rollno, name, course);// C.T.Error
    	}
    	void display() {
            System.out.println(rollno + " " + name + " " + course + " " + fee);
        }
    }
    
    class TestThis8 {
        public static void main(String args[]) {
            Student s1 = new Student(111, "ankit", "java");
            Student s2 = new Student(112, "sumit", "java", 6000f);
            s1.display();
            s2.display();
        }
    }
    

    执行上面代码输出结果如下 -

    Compile Time Error: Call to this must be first statement in constructor
    

    4. this:作为参数传递给方法

    this关键字也可以作为方法中的参数传递。 它主要用于事件处理。 看看下面的一个例子:

    class S2 {
        void m(S2 obj) {
            System.out.println("method is invoked");
        }
    	void p() {
            m(this);
        }
    	public static void main(String args[]) {
    	        S2 s1 = new S2();
    	        s1.p();
    	    }
    	}
    

    执行上面代码输出结果如下 -

    method is invoked
    

    这个应用程序可以作为参数传递:

    在事件处理(或)的情况下,必须提供一个类的引用到另一个。 它用于在多个方法中重用一个对象。

    5. this:在构造函数调用中作为参数传递

    也可以在构造函数中传递this关键字。 如果必须在多个类中使用一个对象,可以使用这种方式。 看看下面的一个例子:

    class B {
        A4 obj;
    	 B(A4 obj) {
            this.obj = obj;
        }
        void display() {
            System.out.println(obj.data);// using data member of A4 class
    	}
    }
    class A4 {
        int data = 10;
     	A4() {
            B b = new B(this);
            b.display();
        }
    	public static void main(String args[]) {
    	        A4 a = new A4();
    	}
    }
    

    执行上面代码输出结果如下 -

    10
    

    6. this关键字用来返回当前类的实例

    可以从方法中 this 关键字作为语句返回。 在这种情况下,方法的返回类型必须是类类型(非原始)。 看看下面的一个例子:

    作为语句返回的语法

    return_type method_name(){  
        return this;  
    }
    

    从方法中返回为语句的 this 关键字的示例

    class A {
        A getA() {
            return this;
        }
    	void msg() {
    	        System.out.println("Hello java");
    	}
    }
    
    class Test1 {
        public static void main(String args[]) {
            new A().getA().msg();
        }
    }
    

    执行上面代码输出结果如下 -

    Hello java
    

    7. 验证 this 关键字

    现在来验证 this 关键字引用当前类的实例变量。 在这个程序中将打印参考变量,这两个变量的输出是相同的。

    class A5 {
        void m() {
            System.out.println(this);// prints same reference ID
        }
    	public static void main(String args[]) {
            A5 obj = new A5();
            System.out.println(obj);// prints the reference ID
            obj.m();
    	}
    }
    

    执行上面代码输出结果如下 -

    A5@22b3ea59
    A5@22b3ea59
    
    展开全文
  • 首先来了解下static 关键字 ...当静态方法加载进内存进栈,如果静态方法中有this super 关键字时this和super也被加载到了内存,但是这个时候并没有对象的引用,this和super没有初始化...

    首先来了解下static 关键字

    当一个方法和属性被static属性修饰时,这些方法和属性是优先于对象加载进入内存的,是随着类的加载而加载的

    this关键字的理解this是当前对象的引用,super是指父类的引用

    当静态方法加载进内存进栈时,如果在静态方法中有this 和 super 关键字时,this和super也被加载到了内存,但是这个时候并没有对象的引用,this和super没有初始化,所有编译会报错。

     

    展开全文
  • this和super关键字

    2020-04-18 18:39:10
    this和 super关键字 this:存储的“当前对象”的引用; 可以访问:本类的成员属性、成员方法、构造方法; super:存储的“父类对象”的引用; 可以访问:父类的成员属性、成员方法、构造方法; this关键字的三种...

    this和 super关键字

    • this:存储的“当前对象”的引用;
      可以访问:本类的成员属性、成员方法、构造方法;
    • super:存储的“父类对象”的引用;
      可以访问:父类的成员属性、成员方法、构造方法;

    this关键字的三种用法

    this访问本类成员变量

    创建Student类进行测试

    this.成员变量
    
    public class Test {
       public static void main(String[] args) {
           Student stu = new Student();
           stu.show();
       }
    }
    class Student {
       String name = "root";
       public void show(){
           String name = "cys";
           System.out.println(name);
           System.out.println(this.name);
       }
    }
    
    运行结果:
    cys
    root
    
    this关键字访问本类成员方法

    格式:

    this.方法名(参数列表);
    
    public class Test {
       public static void main(String[] args) {
           Student stu = new Student();
           stu.show();
       }
    }
    class Student {
       public void show(){
           System.out.println("show方法被调用");
           this.eat();
       }
    
       private void eat() {
           System.out.println("eat方法被调用");
       }
    }
    
    运行结果:
    show方法被调用
    eat方法被调用
    

    注意:在访问本类成员方法的时候可以省略this关键字,一般推荐省略this关键字

    this关键字访问本类的构造方法

    this关键字只能在本类的一个构造方法中调用另一个构造方法
    格式:

    public 类名(){
    	this(参数列表);//在无参构造方法中调用有参构造函数
    }
    
    public class Test {
        public static void main(String[] args) {
            Student stu = new Student();
            System.out.println(stu.name);
        }
    }
    class Student {
        String name;
        public Student() {
            this("cys");
            System.out.println("无参构造函数...");
        }
        public Student(String name){
            this.name = name;
            System.out.println("有参构造函数...");
        }
    }
    
    运行结果
    有参构造函数...
    无参构造函数...
    cys
    

    注意:当使用this()调用另一个构造方法时,此代码必须是此构造方法的第一句有效代码。

    super关键字的三种用法

    super关键字访问父类成员变量

    格式:

    super.父类成员变量名;
    
    public class Test {
        public static void main(String[] args) {
            Son son = new Son();
            son.show();
        }
    }
    class Father{
        int num = 10;
    }
    class Son extends Father{
        int num = 20;
        public void show(){
            System.out.println(num);
            System.out.println(this.num);
            System.out.println(super.num);
        }
    }
    
    运行结果
    20
    20
    10
    
    super关键字访问父类成员方法

    格式:

    super.方法名();
    
    public class Test {
        public static void main(String[] args) {
            Son son = new Son();
            son.show();
        }
    }
    class Father{
        public void method(){
            System.out.println("父类method方法");
        }
    }
    class Son extends Father{
        public void method(){
            System.out.println("子类method方法");
        }
        public void show(){
            method();
            super.method();
        }
    }
    
    运行结果
    子类method方法
    父类method方法
    

    注意:super访问成员变量和成员方法: 优先去父类中找,如果有就直接使用;如果没有,就去父类的父类中找,如果有,就用,依次类推…

    super关键字访问父类构造方法

    子类构造函数中可以使用super关键字调用父类构造函数
    格式

    public class 子类名 extends 父类名{
    	public 子类名(){
    		super();//调用父类构造函数
    	}
    }
    
    public class Test {
        public static void main(String[] args) {
            Son son1 = new Son();
            System.out.println("======");
            Son son2 = new Son("root");
        }
    }
    class Father{
        public String name;
        public Father() {
            System.out.println("父类无参构造函数");
        }
        public Father(String name){
            this.name = name;
            System.out.println("父类有参构造函数");
        }
    }
    class Son extends Father{
        public Son(){
            super();
            System.out.println("子类无参构造函数");
        }
        public Son(String name){
            super(name);
            System.out.println("子类有参构造函数");
        }
    }
    
    运行结果
    父类无参构造函数
    子类无参构造函数
    ======
    父类有参构造函数
    子类有参构造函数
    

    注意

    • super调用父类构造函数的时候也要放在构造函数的第一行,所以this和super在构造函数中是不能共存的
    • 子类的构造方法默认会调用父类的空参构造方法,如果父类中的没有空参构造方法,只定义了有参构造方法,会编译报错
    展开全文
  • - this和super使用分别 成员变量: this.成员变量 - 访问本类成员变量 super.成员变量 - 访问父类成员变量 成员方法: this.成员方法 - 访问本类成员方法 super.成员方法 - 访问父类成员方法 构造方法: ...

    - this&super关键字:

    • this:代表本类对象的引用
    • super:代表父类存储空间的标识(可以理解为父类对象引用)

    - this和super的使用分别

    • 成员变量:
      • this.成员变量 - 访问本类成员变量
      • super.成员变量 - 访问父类成员变量
    • 成员方法:
      • this.成员方法 - 访问本类成员方法
      • super.成员方法 - 访问父类成员方法
    • 构造方法:
      • this(…) - 访问本类构造方法
      • super(…) - 访问父类构造方法
    展开全文
  • Java中的this和super关键字 (1) this关键字 this关键字指代的是当前对象。即:哪个对象调用就表示那个对象。 this关键字只能用类中方法里面,用于访问成员变量,方法中的成员变量前面都默认有一个this。注意:...
  • 1.this和super的使用区分 2.为什么this()super()必须构造...3.为什么静态方法中不能使用this和super关键字 4.为什么要构造方法内调用构造方法 5.如何调用两个父类的构造方法 6.为什么成员方法内不能调用构造方法
  • this和super 由于最近看源码的时候发现this关键字的出现频率颇高,可能是自己没有注意到的一个知识点,现在来补充记录一下。this和super一般是放在一起学习。 this this是用于访问本类中的成员变量,成员方法,...
  • this 和super关键字

    2018-12-08 17:12:00
    如果存在同名的成员变量与局部变量,方法内部默认的访问的局部变量,可以通过this关键字调用成员变量 2.一个构造方法中调用另一个构造方法来初始化对象this关键字要注意的事项 1.存在同名的成员变量与局部...
  • This和Super关键字

    2017-03-10 14:11:55
    this关键字代表自身,程序中主要的使用用途有以下几个方面: ? 使用this关键字引用成员变量 ? 使用this关键字在自身构造方法内部引用其它构造方法 ? 使用this关键字代表自身类的对象 ? 使用this关键字引用成员...
  • java中super和this的异同 super一个类中用来引用其父类的成员。...super关键字的作用在于当前子类中覆盖了父类中的某个成员变量,或者重写了父类的某个成员方法还能够访问到父类的成员变量成员方法。如...
  • 主要介绍了java中thissuper关键字使用方法的相关资料,希望通过本文能帮助到大家,让大家彻底理解应用java中this与super,需要的朋友可以参考下
  • Java中this关键字和super关键字* 一个对象对应一个thisthis是一个变量,是一个引用。this保存当前对象的内存地址指向自身。 super关键字代表的就是“当前对象”的那部分父类型特征。 this和super出现实例方法...
  • super:super关键字和this的作用类似,将被隐藏的父类的成员变量成员方法变为可见,或者说用来引用被隐藏的父类的成员成员变量成员方法。 使用场景: 1.使用super和this调用成员变量方法 有时会遇到子类中的...
  • this super 关键字的作用   this 是对象内部指代自身的引用,同时也是解决成员变量局部变量同 名问题;this 可以调用成员变量,不能调用局部变量;this 也可以调用成员 方法,但是普通方法中可以省略 this...
  • java中,父类子类中都写了同名的属性名,此时,子类中使用this和super关键字的效果有什么不同 直接po图代码 如果看不出运行效果的话,我就把2张运行效果图放一起,大家对比着瞧吧,这样比较清晰...
  • this super关键字

    2011-12-29 13:54:51
    this和super关键字,其用法非常的相似。super用来代表父类,而this用来代表本类。 this()用于调用本类的构造。 super()用来调用父类的构造,必须出现构造当中的第一行。 this. 用来调用本类的属性方法,可以...
  • this和super关键字的区别用法 this关键字的三种用法: this可以访问本类的成员变量: this.成员变量 一般用来区分同名的成员变量局部变量 this可以访问本类的成员访问: this.成员方法名(实参); this可以访问本类的...
  • Java中每一个对象的内存模型都有一个this和super关键字this指代当前对象内存中的引用地址。super指代父类对象内存中的引用地址。 如果我子类的构建器中调用了父类的有参构建器,则不会调用父类的无参构建器...
  • this和super关键字的作用区别 this:是对象对自身的引用,没有继承也可以使用,调用本类的构造 super:对父类对象的引用,只能继承条件下使用,调用父类的构造 super注意点: super调用父类的构造方法,必须...
  • this和super关键字 this是自身的一个对象,代表对象本身可以理解为指代当前的对象,它可以调用当前对象的属性、方法构造方法,一般情况下可以省略,必须使用this的地方是区分出现名字重复的参数属性 与this...
  • 静态方法当中不允许出现 this 关键字 super: 代表对当前对象的直接父类对象的引用 可以调用父类的非 private 成员变量方法 super(); 可以调用父类的构造方法,只限构造方法中使用,且必须是第一条...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 127,964
精华内容 51,185
关键字:

在使用this和super关键字时