class Fu
{
     int num=4;
}
class Zi extends Fu
{
     void show()
{
        System.out.println(this.num);
        //System.out.println(super.num);
}
}
在这里面this 与super 的区别？
没怎么理解。。

变量是不存在继承关系，就是说你这个打印出来 都一样

1. class Fu
   
2. {
   
3. int num=4;
   
4. }
   
5. class Zi extends Fu
   
6. {
   
7. void show()
   
8. {
   
9. System.out.println(this.num);
   
10. <FONT color=red>//这里的this代表的本类对象的引用，相当于System.out.println(new Zi().num);
    
11. </FONT>//System.out.println(super.num);
    
12. <FONT color=red>//这里的super代表的是父类的引用，相当于Sysem.out.println(new Fu().num);
    
13. </FONT>}
    
14. }
    
15. <FONT color=red>在这里面this 与super 的区别?
    
16. </FONT>

复制代码

class Demo
{
        public static void main(String[] args) throws IOException
        {
              
               new Zi().show();

        }
}
class Fu
{
     int num=4;
}
class Zi extends Fu
{
int num=5;    
         void show()
{
        System.out.println(this.num);//new Zi（）对象的引用。所以num=5。在子类自己没有自定义 num的时候会继承父类的num所以楼主的情况num=4        
        System.out.println(super.num);//父类的引用。num=4,在子类没有num的时候
}
}

class Fu
{
     int num=4;
}
class Zi extends Fu
{
     void show()
{
        System.out.println(this.num); //this表示本类对象的引用，this.num就是继承自父类的num
        //System.out.println(super.num);// super表示父类对象的应用，super.num就是父类的num
}
}

super关键字表示超（父）类的意思。this变量代表对象本身,可以使用super访问父类被子类隐藏的变量或覆盖的方法。当前类如果是从超类继承而来的，当调用super.XX()就是调用基类版本的XX（）方法。

1. <FONT size=1>class Person {
   
2. protected void print() {
   
3. System.out.println("The print() in class Person.");
   
4. }
   
5. }
   
6. 
   
7. public class DemoSuper extends Person {
   
8. public void print() {
   
9. System.out.println("The print() in class DemoSuper.");
   
10. super.print();// 调用父类的方法
    
11. }
    
12. 
    
13. public static void main(String[] args) {
    
14. DemoSuper ds = new DemoSuper();
    
15. ds.print();
    
16. }
    
17. </FONT><STRONG>}</STRONG>

复制代码

当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。见示例2。

1. <FONT size=1>public class DemoThis {
   
2. private String name;
   
3. 
   
4. public void setName(String name) {
   
5. this.name = name;// 前一个name是private name；后一个name是setName中的参数。
   
6. }
   
7. }</FONT>

复制代码

class Fu
{
      int num=4;
}
class Zi extends Fu
{
      void show()
{
         System.out.println(this.num);
//用this表示此时指向的是当前对象的一个变量num，相当于new Zi().num         //System.out.println(super.num);//而这里super.num是当前对象的直接父类对象的引用，既是new Fu().num
}
}

我的笔记：

在构造函数里面this()和super()二者只能有其一。

this和super用法几乎一样，this.代表的是本类引用，this()调用的是本类的构造方法，而super.代表的是父类引用，sper()调用的是父类的构造方法。

在子类对象进行初始化时父类的构造方法也会运行，因为在子类构造方法的第一行默认都有一条隐式的语句super()。子类所有构造函数的第一行默认都是super()，不论是带参或者不带参。如果要调用父类的有参构造方法，就必须得自己写一个带参的super方法
Super语句一定定义在子类构造函数的第一行。

子类中至少会有一个构造函数会去访问父类的构造函数

class Fu
{
     int num=4;
}
class Zi extends Fu
{
     void show()
{
        System.out.println(this.num);------，首先告诉楼主：变量没有继承关系，你这里的this的意思是---当前对象的num，也就是zi类对象的mun
        System.out.println(super.num);      你这里的意思是调用父类的num变量
}
}

this与super用法基本一致，当一个类继承另一个类时，super代表的是父类的引用，this代表的是本类引用。
在你的例子中，没有创建对象，this与super指的是同一个值

this和super用法几乎一样，this.代表的是本类引用，this()调用的是本类的构造方法，而super.代表的是父类引用，sper()调用的是父类的构造方法。都能创建对象；子类中至少会有一个构造函数会去访问父类的构造函数

class Fu
{
     int num=4;
}
class Zi extends Fu
{
     void show()
{
        System.out.println(this.num);
        //System.out.println(super.num);
}
}
你的这个this.num是指本类的对象；当前num对象；
你的这个super.num是指父类的对象；由于class Zi extends Fu那么这个super指的num；就是指的fu类num中的值；
如果你还是不太清楚的话：我觉得你还是好好在看看继承视频；

class Fu
{
     int num=4;
}
class Zi extends Fu
{
     void show()
{
        System.out.println(this.num);// 这里表示引用 Zi这个对象的num，由于Zi没有定义num，而Zi却继承了Fu，所以就可以直接用Fu的num
                                                     //再告诉你，如果Zi有个同名的num，就优先找this的num。也就是Zi里面定义的sum。
        
        //System.out.println(super.num)；//这里表示直接引用Fu的num,而Fu正好定义了num，所以直接引用Fu的num
}
}

super和this关键字都可以用来覆盖java语言的默认作用域，使被屏蔽的方法或变量变为可见。在以后场合会出现方法或变量的被屏蔽的现象
1、在一个方法内，当局部变量和类的成员变量同名，或者局部变量和父类的成员变量同名时，按照变量的作用域规则，只有局部变量在方法内可见。
2、当子类的某些方法覆盖了父类的一个方法，在子类的范围内，父类的方法不可见
3、当子类中定义了和父类同名的成员变量时，在子类的范围内，父类的成员变量不可见
另，只能在构造方法或者实例方法内使用super关键字，在静态方法和静态代码块内不能使用super关键字

this为当前对象的引用，super为当前类的基类的引用，楼主代码中子类中没有定义成员变量，所以会打印和父类中相同的num的值。

1. package demo;
   
2. 
   
3. public class Differ {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         public static void main(String[] args) {
   
9.                 // TODO Auto-generated method stub
   
10.                 Son son = new Son();
    
11.                 son.show();
    
12.         }
    
13. }
    
14. class Father{
    
15.         int num = 4;
    
16. }
    
17. class Son extends Father{
    
18.         int num =5;
    
19.         void show(){
    
20.                 System.out.println(this.num);//this为当前对象的引用，会打印子类对象的成员变量num = 5
    
21.                 System.out.println(super.num);//Son类中定义了和Father类中相同的成员变量，在子类的范围内，父类的成员变量不可见
    
22.                                                                           //如果想取到Father类中的成员变量，这时可以使用super关键字，引用父类中同名的成员变量num=4
    
23.         }
    
24. }

复制代码

this（）：当前类的对象，super父类对象
super（）：在子类访问父类的成员和行为，必须受类继承规则的约束，而this它代表当前对象，当前所有资源都可以访问。

this用于代表当前的对象，super用于引用父类的对象

this表示从当前类查找，如果没有找到，则回去父类查找，而用super则会直接去父类查找，不会在当前类查找。