this就是本类的 super是父类的

//父类
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作用在父类中，但它们的用法类似

ly631960324 发表于 2015-11-7 23:56
//父类
class Fu                               
{

this如果在本类中没有找到成员变量的值，就会到父类中找是吧！

来来来，我给你解决

this:代表当前对象的引用，谁来调用我，我就代表谁                 super:代表当前对象父类的引用                 使用场景和作用：                  ①调用成员变量                          this.成员变量 调用本类的成员变量,也可以调用父类的成员变量                          super.成员变量 调用父类的成员变量                  ②调用构造方法                          this(...)        调用本类的构造方法                          super(...)        调用父类的构造方法                  ③调用成员方法                          this.成员方法 调用本类的成员方法,也可以调用父类的方法                          super.成员方法 调用父类的成员方法

1．什么是super？什么是this？ super关键字表示超（父）类的意思。this变量代表对象本身。 2．使用super&this调用成员变量和方法 可以使用super访问父类被子类隐藏的变量或覆盖的方法。当前类如果是从超类继承而来的，当调用super.XX()就是调用基类版本的XX（）方法。见示例1。 当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。见示例2。

实例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中的参数。
    }
}

this是一个关键字。代表当前类对象的引用。
在方法中，哪个对象调用方法，this就代表谁。
除了静态方法外，所有的方法中有隐含的有一个this引用。

super是调用父类的构造函数
使用super调用有一些限制条件,不能在super调用中使用实例变量作为参数.
而且在构造函数中,调用必须写在继承类的构造函数定义的第一行,不能在构造函数的后面使用.
this调用的同类的构造函数.
super的限制条件同样适用于this函数
一个构造函数定义中不能同时包括this调用和super调用,如果想同时包括的话,可以在this中首先进行super调用.

this:    概述：代表当前对象的引用。
                          专业的说法： 代表其所在函数，所属对象的引用。
                          大白话：谁调用，this就代表谁。
           作用：用于解决 局部变量隐藏成员变量值的问题。
super:当前对象父类的引用。（理解为：父类的内存空间标识）
使用：
                                成员变量：
                                        this.变量名： 调用的是本类的成员变量
                                        super.变量名：调用的是父类的成员变量

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

                                成员方法：
                                        this.方法名()： 调用的是本类的成员方法
                                        super.方法名()：调用的是父类的成员方法

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关键字。

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成员，别无它法。

this是指本类，谁引用就是谁。super才涉及到继承或者实现，引用父类

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);
}
}
哥们看懂这个就差不多了

个人认为应该是super表示对象才能这么调用，可父类对象没被new 而如果是表示父类的话，那fun（）应该是static方法啊？迷茫~~ 有些东西可以称为定义，不要钻牛角尖 super();表示调用父类的构造方法，只是调用方法，不构造对象。 super.fun();表示调用父类的某方法 在继承的时候这个方法是肯定被继承下来的。如果fun()这个方法在子类没有重写，那么super.fun();实际上跟直接调用fun();是一样的。 如果被重写了，那么super.fun();就是重写前的，fun();就是重写后的。

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()");
  }
}