黑马程序员技术交流社区

标题: this关键字和super关键字分别代表什么?以及他们各自的使用... [打印本页]
作者: 1137981939    时间: 2015-11-3 23:46
标题: this关键字和super关键字分别代表什么?以及他们各自的使用...
有点混，特别是在继承中的时候，求详细解答！谢谢小伙伴们！
作者: Pinfan    时间: 2015-11-4 01:04
this表示的是当前对象的引用，哪个对象调用了this所在的函数，this就代表哪个对象；super表示的是当前类的父类。this 有两种用法：1.成员变量和局部变量重名时，可以用this来区分。 2.this可以用在构造函数中，调用其它构造函数（只能定义在构造函数的第一行，因为初始化时必须被先执行）。super可以直接调用父类的属性、方法、构造方法。但在调用构造方法时，两者不能同时使用，因为只要是调用构造方法，就必须放在构造方法的首行。
作者: 478883662    时间: 2015-11-4 09:11
package com.itheima;

public class Test8 {
       
        /**
         * 第8题：在打印语句中如何打印这3个x变量？
         * @author Administrator
         * */
        /**
         * class A {
                        int x = 1;
                        class B {
                                int x = 2;
                                void func() {
                                        int x = 3;
                                        System.out.println( ? );
                            }
                    }
                }
         * */
        public static void main(String[] args){
                //创建外部类A的对象a
                A a=new A();
               
                //创建对象a中内部类B的对象b
                A.B b= a.new B();
               
                //调用b的func（）方法
                b.func();
        }
}

class A {
        int x = 1;
        class B {
                int x = 2;
                void func() {
                        int x = 3;
                        //第一个x为A的成员变量，即A.this。x
                        //第二个x为B的成员变量，即A.B.this。x 或者  this.x
                        //第三个x为当前x变量值，即x
                        System.out.println("A.x="+A.this.x+"-----"+"A.B.x="+A.B.this.x+"-----"+"this.x="+this.x+"-----"+"x="+x);
            }
    }
}
一道面试题，希望能帮住到你。
作者: 吃饭工作睡觉    时间: 2015-11-4 10:07
this关键字代表当前对象。在类文件方法中可以使用分区是成员变量还是局部变量。还可以使用在构造方法中调用其它的构造方法（例子：this(arguments)其中arguments根据参数个数添加）。super代表当前对象的父对象，可以用来在构造函数用引用父类构造器（例子：super(arguments)其中arguments根据参数个数添加）。也可以在普通方法区分父类变量、子类变量、局部变量。
作者: rookiefly    时间: 2015-11-4 16:14
this代表本身，super代表父类，，super(..)：执行父类构造函数  
作者: 黑马，你的骄傲    时间: 2015-11-4 18:46
this主要是在本类中寻找成员（成员变量、方法），{在构造方法中，先看本类中有无对应参数类型相同的方法，没有就去父类中寻找}。super特指是在父类中寻找方法。
作者: 菊花爆满山    时间: 2015-11-4 21:24
this代表本类对象的引用 super代表父类对象的引用
作者: nulixuec    时间: 2015-11-4 21:39
this是一个关键字。代表当前类对象的引用。
                简单记：在方法中，哪个对象调用方法，this就代表谁。
                除了静态方法外，所有的方法中有隐含的有一个this引用
        应用场景：
                解决局部变量隐藏成员变量问题。
his:局部变量把成员变量隐藏/需要用到当前类对象的时候
        super:子类想要调用父类中与自己重名的成员时
作者: 3872982    时间: 2015-11-4 21:40
this是指当前方法所在的对象引用，一般用于在类的成员方法中调用自身的成员变量或者成员方法；
super则与this类似，super指的是该父对象的引用，多用于在子类中调用父类中的成员变量或者方法；
作者: 特立独行    时间: 2015-11-4 22:54
在继承中,我是这么理解的,打个比方说,有一对父和子,子继承(extends)父的一切东西,但不包括父亲私有(private)的东西,如果this在子中修饰一辆车,儿子想开车载女友兜风,那么先看看自己有没有车,有车就用自己的车,没车就用父的车.super是子直接引用的父的东西,比如说父的司机,直接拿过来用.(如有雷同,纯属巧合)希望对你有帮助
作者: 253186803    时间: 2015-11-4 23:02
this是指当前方法所在的对象引用，一般用于在类的成员方法中调用自身的成员变量或者成员方法；
super则与this类似，super指的是该父对象的引用，多用于在子类中调用父类中的成员变量或者方法；
作者: 1137981939    时间: 2015-11-5 20:08
253186803 发表于 2015-11-4 23:02
this是指当前方法所在的对象引用，一般用于在类的成员方法中调用自身的成员变量或者成员方法；
super则与th ...

super也可以用来调用父类中的构造函数吧！父类中私有的成员变量子类访问不了、
作者: 1137981939    时间: 2015-11-5 20:09
Pinfan 发表于 2015-11-4 01:04
this表示的是当前对象的引用，哪个对象调用了this所在的函数，this就代表哪个对象；super表示的是当前类的 ...

恩恩，很详细，感谢啊！
作者: 1137981939    时间: 2015-11-5 21:01
特立独行 发表于 2015-11-4 22:54
在继承中,我是这么理解的,打个比方说,有一对父和子,子继承(extends)父的一切东西,但不包括父亲私有(private ...

恩恩，现在理解很多了，感谢热心帮忙的小伙伴们！
作者: 1137981939    时间: 2015-11-5 21:02
478883662 发表于 2015-11-4 09:11
package com.itheima;

public class Test8 {

恩恩，我研究研究、
作者: 哥德曼的    时间: 2015-11-5 22:04
this关键字是指调用这个方法的对象的引用，而super是指父类的引用，
public void show(int a ){
        this.a=a;//就是谁调用这个对象，this就代表谁，
        super.a=a;//就是将这个a变量的值赋给父类的变量a
}
作者: 哥德曼的    时间: 2015-11-5 22:06
this关键字是指调用这个方法的对象的引用，而super是指父类的引用，
public void show(int a ){
         this.a=a;//就是谁调用这个对象，this就代表谁，
        super.a=a;//就是将这个a变量的值赋给父类的变量a
}
作者: 744919632    时间: 2015-11-6 09:22
this是一个关键字。代表当前类对象的引用。
在方法中，哪个对象调用方法，this就代表谁。
除了静态方法外，所有的方法中有隐含的有一个this引用。

super是调用父类的构造函数
使用super调用有一些限制条件,不能在super调用中使用实例变量作为参数.
而且在构造函数中,调用必须写在继承类的构造函数定义的第一行,不能在构造函数的后面使用.
this调用的同类的构造函数.
super的限制条件同样适用于this函数
一个构造函数定义中不能同时包括this调用和super调用,如果想同时包括的话,可以在this中首先进行super调用.
作者: 一脸的护胸毛丶    时间: 2015-11-6 21:38
this是调用方法的对象的引用,谁调用本方法,this就带表谁,而super是父类引用
作者: 刘佳禹    时间: 2015-11-7 13:08
this调用本类成员变量
super使用父类的构造方法
作者: didixyy    时间: 2015-11-7 23:03
this就是本类的 super是父类的
作者: ly631960324    时间: 2015-11-7 23:56
//父类
class Fu                               
{
        public int num = 10;

        //父类无参构造
        public Fu()
        {
                System.out.println("fu");
        }
}

//子类
class Zi extends Fu
{
        public int num = 20;

        //之类无参构造
        public Zi()
        {
                super();  //一般会隐藏默认
                System.out.println("zi");
        }
        public void show()
        {
                int num = 30;
                System.out.println(num);        //结果为30，如果变量前没有修饰，根据就近原则，变量值就是                       
                                                              方法内变量的值
                System.out.println(this.num);  //结果为20，因为this,输出的是本类中成员变量的值
                System.out.println(super.num);//结果为10，因为有super，输出的是父类中的成员变量num的值
        }
}//this的作用范围仅在本类中，而super作用在父类中，但它们的用法类似
作者: 1137981939    时间: 2015-11-8 22:19
ly631960324 发表于 2015-11-7 23:56
//父类
class Fu                               
{

this如果在本类中没有找到成员变量的值，就会到父类中找是吧！
作者: chenxianzai    时间: 2015-11-10 20:10
来来来，我给你解决
作者: chenxianzai    时间: 2015-11-10 20:11
this:代表当前对象的引用，谁来调用我，我就代表谁                 super:代表当前对象父类的引用                 使用场景和作用：                  ①调用成员变量                          this.成员变量 调用本类的成员变量,也可以调用父类的成员变量                          super.成员变量 调用父类的成员变量                  ②调用构造方法                          this(...)        调用本类的构造方法                          super(...)        调用父类的构造方法                  ③调用成员方法                          this.成员方法 调用本类的成员方法,也可以调用父类的方法                          super.成员方法 调用父类的成员方法
作者: sabrina妖儿    时间: 2015-11-10 21:53
1．什么是super？什么是this？ super关键字表示超（父）类的意思。this变量代表对象本身。 2．使用super&this调用成员变量和方法 可以使用super访问父类被子类隐藏的变量或覆盖的方法。当前类如果是从超类继承而来的，当调用super.XX()就是调用基类版本的XX（）方法。见示例1。 当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。见示例2。
作者: sabrina妖儿    时间: 2015-11-10 21:54
实例1：
lass Person {
    protected void print() {
       System.out.println("The print() in class Person.");
    }
}

public class DemoSuper extends Person {
    public void print() {
       System.out.println("The print() in class DemoSuper.");
       super.print();// 调用父类的方法
    }

    public static void main(String[] args) {
       DemoSuper ds = new DemoSuper();
       ds.print();
    }
}

结果：
The print() in class DemoSuper.
The print() in class Person.

示例2：
public class DemoThis {
    private String name;

    public void setName(String name) {
       this.name = name;// 前一个name是private name；后一个name是setName中的参数。
    }
}
作者: a6151006    时间: 2015-11-11 14:54
this是一个关键字。代表当前类对象的引用。
在方法中，哪个对象调用方法，this就代表谁。
除了静态方法外，所有的方法中有隐含的有一个this引用。

super是调用父类的构造函数
使用super调用有一些限制条件,不能在super调用中使用实例变量作为参数.
而且在构造函数中,调用必须写在继承类的构造函数定义的第一行,不能在构造函数的后面使用.
this调用的同类的构造函数.
super的限制条件同样适用于this函数
一个构造函数定义中不能同时包括this调用和super调用,如果想同时包括的话,可以在this中首先进行super调用.
作者: 邸永明    时间: 2015-11-13 22:09
this:    概述：代表当前对象的引用。
                          专业的说法： 代表其所在函数，所属对象的引用。
                          大白话：谁调用，this就代表谁。
           作用：用于解决 局部变量隐藏成员变量值的问题。
super:当前对象父类的引用。（理解为：父类的内存空间标识）
使用：
                                成员变量：
                                        this.变量名： 调用的是本类的成员变量
                                        super.变量名：调用的是父类的成员变量

                                构造方法：
                                        this();
                                        super();

                                成员方法：
                                        this.方法名()： 调用的是本类的成员方法
                                        super.方法名()：调用的是父类的成员方法
作者: sabrina妖儿    时间: 2015-11-14 21:02
1. 子类的构造函数如果要引用super的话，必须把super放在函数的首位


复制代码 代码如下:


class Base {

Base() {

System.out.println("Base");

}

}


public class Checket extends Base {

Checket() {

super();//调用父类的构造方法，一定要放在方法的首个语句

System.out.println("Checket");

}



public static void main(String argv[]) {

Checket c = new Checket();

}

}


如果想用super继承父类构造的方法，但是没有放在第一行的话，那么在super之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法。那么以前所做的修改就都回到以前了，就是说又成了父类的构造方法了。



2．在Java中，有时还会遇到子类中的成员变量或方法与超类（有时也称父类）中的成员变量或方法同名。因为子类中的成员变量或方法名优先级高，所以子类中的同名成员变量或方法就隐藏了超类的成员变量或方法，但是我们如果想要使用超类中的这个成员变量或方法，就需要用到super.


复制代码 代码如下:


class Country {

String name;



void value() {

name = "China";

}

}



class City extends Country {

String name;



void value() {

name = "Hefei";

super.value();//不调用此方法时，super.name返回的是父类的成员变量的值null

System.out.println(name);

System.out.println(super.name);

}



public static void main(String[] args) {

City c=new City();

c.value();

}

}


为了在子类中引用父类中的成员变量name和方法value()，在代码中使用了super、super.name和super.value(),若不调用super.value()时，super.name返回父类成员变量默认值null,调用此方法时，super.value()方法把成员变量name赋值为China,再利用super.name调用父类的成员变量的值。

另外，要注意的是super.name调用的是成员变量的值，


复制代码 代码如下:


class Country {

String name="xianfan";



String value(String name) {

name = "China";

return name;

}

}



class City extends Country {

String name;



String value(String name) {

name = "Hefei";

super.value("失败");//不调用此方法时，super.name返回的是父类的成员变量的值null

System.out.println(name);

System.out.println(super.name);

return name;

}



public static void main(String[] args) {

City c=new City();

c.value("成功");

}

}


结果为：Hefei

xianfan

此时，super.name返回的值是父类成员变量的值xianfan,而此时的super.value()方法是不起作用的。



3．用super直接传递参数：


复制代码 代码如下:


class Person {

public static void prt(String s) {

System.out.println(s);

}



Person() {

prt("A Person.");

}



Person(String name) {

prt("A person name is:" + name);

}

}



public class Chinese extends Person {

Chinese() {

super(); // 调用父类构造函数（1）

prt("A chinese.");// (4)

}



Chinese(String name) {

super(name);// 调用父类具有相同形参的构造函数（2）

prt("his name is:" + name);

}



Chinese(String name, int age) {

this(name);// 调用当前具有相同形参的构造函数（3）

prt("his age is:" + age);

}



public static void main(String[] args) {

Chinese cn = new Chinese();

cn = new Chinese("kevin");

cn = new Chinese("kevin", 22);

}

}


结果为：A Person.

A chinese.

A person name is:kevin

his name is:kevin

A person name is:kevin

his name is:kevin

his age is:22

在这段程序中，this和super不再是像以前那样用“.”连接一个方法或成员，而是直接在其后跟上适当的参数，因此它的意义也就有了变化。super后加参数的是用来调用父类中具有相同形式的构造函数，如1和2处。this后加参数则调用的是当前具有相同参数的构造函数，如3处。当然，在Chinese的各个重载构造函数中，this和super在一般方法中的各种用法也仍可使用，比如4处，你可以将它替换为“this.prt”(因为它继承了父类中的那个方法）或者是“super.prt”（因为它是父类中的方法且可被子类访问），它照样可以正确运行。但这样似乎就有点画蛇添足的味道了。

4．super和this的异同：

1)super（参数）：调用基类中的某一个构造函数（应该为构造函数中的第一条语句）  

2)this（参数）：调用本类中另一种形成的构造函数（应该为构造函数中的第一条语句）
3)super:　它引用当前对象的直接父类中的成员（用来访问直接父类中被隐藏的父类中成员数据或函数，基类与派生类中有相同成员定义时如：super.变量名    super.成员函数据名（实参）

4)this：它代表当前对象名（在程序中易产生二义性之处，应使用this来指明当前对象；如果函数的形参与类中的成员数据同名，这时需用this来指明成员变量名）

5）调用super()必须写在子类构造方法的第一行，否则编译不通过。每个子类构造方法的第一条语句，都是隐含地调用super()，如果父类没有这种形式的构造函数，那么在编译的时候就会报错。

6）super()和this()类似,区别是，super()从子类中调用父类的构造方法，this()在同一类内调用其它方法。

7）super()和this()均需放在构造方法内第一行。

8）尽管可以用this调用一个构造器，但却不能调用两个。

9）this和super不能同时出现在一个构造函数里面，因为this必然会调用其它的构造函数，其它的构造函数必然也会有super语句的存在，所以在同一个构造函数里面有相同的语句，就失去了语句的意义，编译器也不会通过。

10）this()和super()都指的是对象，所以，均不可以在static环境中使用。包括：static变量,static方法，static语句块。

11）从本质上讲，this是一个指向本对象的指针, 然而super是一个Java关键字。
作者: 小龙2015    时间: 2015-11-16 18:24
1. super代表父类？代表父类的对象？还是代表父类的引用？为什么super()在构造方法，super.fun()在方法能用？个人认为应该是super表示对象才能这么调用，可父类对象没被new 而如果是表示父类的话，那fun（）应该是static方法啊？迷茫~~ 有些东西可以称为定义，不要钻牛角尖 super();表示调用父类的构造方法，只是调用方法，不构造对象。 super.fun();表示调用父类的某方法 在继承的时候这个方法是肯定被继承下来的。如果fun()这个方法在子类没有重写，那么super.fun();实际上跟直接调用fun();是一样的。 如果被重写了，那么super.fun();就是重写前的，fun();就是重写后的。 不知道这么说理解了没

2,java里在了类中用super调用父类构造函数时，为什么调用语句必须是子类的第一条语句啊？ 我来解释： 如果你想用super继承父类构造的方法 但是没有放在第一行的话 那么在super之前的语句 肯定是为了满足你自己想要完成某些行为的语句 但是你又用了super继承父类的构造方法 那么以前所做的修改就都回到以前了 也就是说又成了父类的构造方法了 比如 class Father { public Father() {String int age=0;} } class Son extends Father { public Son() {String ; super();} } //这样子的话就会把Son里面的name又变成了null 没有达到你想要的效果 不知道明白没有 累死我了 3,java中的super()是什么? 要说super就先要说this。 "this"，作为一个特殊的关键字，它的规则如下：

1。可以表示构造函数传递。this(a,b)表示调用另外一个构造函数。这里面的this就是一个特殊语法，不是变量，没有什么类型。

2。可以在一个类的非static成员内部使用，表示当前这个对象。此时，this就是一个final的普通变量，它有静态类型，就是这个类C本身；它有动态类型，就是当前这个对象的类型。你可以对它调用成员函数，把它传递给别的函数，等等等等。只要一个C类型的final变量可以出现的地方，它就可以出现。 "super"。它和"this"类似，但是也有不同的地方。

1。表示调用父类的构造函数。也是一个特殊语法，不是变量，没有什么类型。

2。可以在一个类的非static成员内部使用。比如super.method()。 但是，注意，这个super.method()只是长得跟some_var.method()一样，一个语法糖而已。实质上，"super"根本不是一个变量。 为什么不是？因为如果是就坏了。java里面有一个金科玉律：任何public非static函数的调用都是多态的。 所以，如果super是个变量，也指向当前对象，那么，不管super的静态类型是什么super.method()必然调用的是子类的那个版本，而不会是我们期望的，静态地选择父类的那个版本。 所以，你只要把super.xxx看成一个特殊的语法，比如理解为“super::xxx”就好了。 既然super不是一个变量，那么不能把它象一个普通变量那样"=="，或者传递给某个函数就看起来很正常了，是么？何况，你其实也用不着它，有this你这些要求就都可以办到了。

3。super的另外一个作用是调用父类的protected函数。只有通过"super"这个魔咒，我们才能操作父类的protected成员，别无它法。
作者: liuqiang11164    时间: 2015-11-20 13:52
this是指本类，谁引用就是谁。super才涉及到继承或者实现，引用父类
作者: 一个人走天下    时间: 2015-11-20 16:59
package com.heima.array;

public class Test6 {
public static void main(String[] args) {
Student s = new Student("张三",30,"男");
s.print();
}
}

class Person {
private String name;
private int age;
int num = 20;
public Person() {
}

public Person(String name, int age) {
super();
this.name = name;
this.age = age;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
public String show() {
return "abc";
}
}
class Student extends Person {
private String gender;
int num = 10;
public Student() {
// TODO Auto-generated constructor stub
}
public Student(String name, int age,String gender) {
super(name, age);//这里用了super()调用父类的构造方法,只能写在第一样,但是不能在用this()
this.gender = gender;//这里的this是用于区分成员变量和局部变量同名的情况       
}
public String show() {
return "def";
}
public void print(){

System.out.println("Person 中的show:"+super.show()+",  Student中的show:"+this.show()+",  Person中的num:"+super.num+",  Student中的num:"+this.num);
}
}
哥们看懂这个就差不多了
作者: IT—WGP    时间: 2015-11-26 08:36
个人认为应该是super表示对象才能这么调用，可父类对象没被new 而如果是表示父类的话，那fun（）应该是static方法啊？迷茫~~ 有些东西可以称为定义，不要钻牛角尖 super();表示调用父类的构造方法，只是调用方法，不构造对象。 super.fun();表示调用父类的某方法 在继承的时候这个方法是肯定被继承下来的。如果fun()这个方法在子类没有重写，那么super.fun();实际上跟直接调用fun();是一样的。 如果被重写了，那么super.fun();就是重写前的，fun();就是重写后的。
作者: xiaotvsit    时间: 2016-3-2 23:49
this表示当前对象，也就是当前类对象，super表示当前类的父类。

例如
你定义一个新的类：A,这个A继承了类B,也就是说B是A的父类。那么如果A中 有个方法：eat();B中也有个方法： eat();

那么在A 中用this.eat()调用的就是A中定义的方法，而super.eat()调用的就是A的父类B中定义的方法eat();
class B{
  void eat(){
     System.out.println("父类----eat()");
  }
}
class A extends B{
   void eat(){
   System.out.println("子类----eat()");
  }
}



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2