精华内容
下载资源
问答
  • 关键字this和super的区别

    万次阅读 2018-08-29 23:39:48
     (1.)每个类每个非静态方法(没有被static修饰)都会隐含一个this关键字,它指向调用这个方法对象;当在方法中使用本类属性时,都会隐含地使用this关键字,当然也可以明确使用。  this可以看成是一个变量,它...

    1.this关键字

             (1.)每个类的每个非静态方法(没有被static修饰)都会隐含一个this关键字,它指向调用这个方法的对象;当在方法中使用本类属性时,都会隐含地使用this关键字,当然也可以明确使用。

              this可以看成是一个变量,它的值就是当前对象的引用

              this关键字只能在方法内部使用,表示对“调用方法的那个对象”的引用如果是在同一类中调用另外一个方法,则可以不用写this,直接调用

             (2.)为了区分属性和局部变量,可以通过this关键字来调用

             (3.)this关键字的用法

                 *当类中非静态方法的参数名与类的某个成员变量名相同时,为了避免参数作用范围覆盖了成员变量的作用范围,必须明确使用this关键字来指定

                 *如果某个构造方法的第一条语句具有形式this(...),那么这个构造方法将调用本类中的其他构造方法

                 *如果某个方法需要传入当前对象,则可以将当前的对象作为参数传递给它
                  

        public class pra {
    
                             private String  name;
    
                         private String  sex;
    
                             private Integer age;
    
                   public pra(String name, String sex, Integer age) {
    
                             super();
    
                             this.name = name;
    
                             this.sex = sex;
    
                             this.age = age;
    
                  }
    
                  public pra() {
    
                   this("by", "女", 15);  //调到了有参的构造方法
    
                }
    
    } 

     

     2.super关键字

             super代表了父类空间的引用

            (1.)super的作用:

                *子父类存在着同名的成员时,在子类中默认时访问子类的成员,可以通过super关键字指定访问父类的成员

                *创建子类对象时,默认会先调用父类无参的构造方法,可以通过super关键字指定调用父类的构造方法

         (2.)super的用法

                  super可以用来引用直接父类的实例变量。

                  super可以用来调用直接父类方法。

                  super()可以用于调用直接父类构造函数

    class C {
    	String name = "A";
    
    	public void work() {
    		System.out.println("A工作!");
    	}
    }
    
    class B extends C {
    	String name = "B";
    
    	public B() {
    		super(); // 调用父类构造方法
    	}
    
    	public void work() {
    		System.out.println("B工作!");
    	}
    
    	public void pint() {
    		System.out.println(name);
    		System.out.println(super.name); // 调用父类的实例变量
    		super.work(); // 调用父类的方法
    	}
    }
    
    public class A {
    	public static void main(String[] args) {
    		B b = new B();
    		b.pint();
    	}
    }

            (3.)注意事项:

                 *如果在子类的构造方法上没有指定调用父类的构造方法,java编译器会在子类的构造器里面加上super()语句

                * super关键字调用父类的构造函数时,该语句必须要是子类构造函数的第一个语句

                *super和this不能同时出现在同一个构造函数中调用其他的构造函数,因为两个语句都要是第一个语句

           3.this和super的区别

              (1.)代表的事物不同

                  super代表的是父类空间的引用

                  this代表的是所属函数的调用者对象

              (2.)使用前提不同

                  super必须要有继承关系才能使用

                  this不需要继承关系也能使用

              (3.)调用的构造函数不同

                   super:调用父类的构造函数

                   this:调用所属类的构造函数

    展开全文
  • 关键字this和super的区别: 编号 区别点 this super 1 访问属性 访问本类中的属性,如果本类中没有此属性则从父类中继续查找 访问父类中的属性 2 调用方法 访问本类中的方法 直接...

    关键字this和super的区别:

    编号 区别点 this super
    1 访问属性 访问本类中的属性,如果本类中没有此属性则从父类中继续查找 访问父类中的属性
    2 调用方法 访问本类中的方法 直接访问父类中的方法
    3 调用构造器 调用本类构造器,但必须放在构造器的首行 调用父类的构造器,但必须放在子类构造器的首行
    4 特殊含义 表示当前对象 表示父类对象

     

    展开全文
  • java中关键字this和super的区别与理解:

    热门讨论 2021-01-29 21:56:05
    文章目录this:this调用属性、方法:this调用构造器:super:super调用属性、方法:super调用构造器:thissuper的区别总结: this: this理解为:当前对象 或 当前正在创建的对象 可以调用的结构:属性、方法;构造器 ...

    this:

    this理解为:当前对象 或 当前正在创建的对象

    可以调用的结构:属性、方法;构造器

    this调用属性、方法:

    先了解一下形参:

    形参的意义就是给属性赋值,我们是要给同名的属性赋值,这时候我们就把形参名和属性的名字写成一样,这样我们就知道我们传入的形参就是要给我们同名的属性去赋值的.

    在类的方法中,我们可以使用"this.属性"或"this.方法"的方式,调用当前对象属性或方法。但是,

    通常情况下,我们都择省略"this."。特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。

    举例:我们声明一个类叫鞋类,给它提供私有的属性和get/set方法和构造器:

    //声明一个鞋类
    public class shoes {
        //鞋的属性
        private String name;//鞋名
        private int id;//编号
    
        
        //无参构造器
        public shoes() {
        }
    
        //有参构造器:
        public shoes(String name, int id) {
    //        name = name;没加this
            this.name = name;
    //        id = id; 没加this
            this.id = id;
        }
        
        
        //声明两个方法
        public void show(){
            System.out.println("展示~~");
            sale();//show方法中调sale方法
    //        this.sale();//this可省略
        }
        public void sale(){
            System.out.println("售卖~~");
        }
    
        
        //get/set方法:
        public String getName() {
            return name;
        }
        public void setName(String name) {
            //name = name;没加this
            this.name = name;
        }
        public void setId(int id) {
            //id = id;没加this
            this.id = id;
        }
        public int getId() {
            return id;
        }
    }
    
    //测试
    class test {
        public static void main(String[] args) {
            //我们先实例化鞋类的对象来调它的属性
            shoes s = new shoes();
            s.setName("nike");//这里的"nike"就是传入的形参
            System.out.println(s.getName());
            //我们获取鞋名的时候,获取不到,意思就是形参的值又赋给了形参,代表没有给鞋的属性赋上值
            //这个时候控制台会输出传入的形参数据类型的默认值,明显不是我们想看到的结果
            s.setId(1);
            System.out.println(s.getId());//鞋的id类似的也会出现同样的情况
            
            
            //"this.方法"举例:
            s.show();
            /*我们先调的是show自己的方法体,然后在show方法中调了sale方法
            意思是s这个对象调了show方法,我们就用调show方法的这个对象s来调sale方法,
            其实在sale();前面也省略了this关键字,表示当前对象(就是调show方法的对象)调的sale方法*/
            
            
    System.out.println("------------------------分割线--------------------");
            
            
            shoes s1 = new shoes("李宁",2);//我们new的有参数的对象给它赋初值之后
            System.out.println(s1.getName());
            System.out.println(s1.getId());//如果没有加this,结果还是和没有获取到鞋名和编号
        }
    }
    

    先来看没有加this关键字的情况:

    在这里插入图片描述

    结果:

    在这里插入图片描述

    然后我们给鞋属性加上this关键字:

    在这里插入图片描述

    控制台输出的就是我们给鞋设置的名字和编号:

    在这里插入图片描述

    在类的构造器中,我们可以使用"this.属性"或"this.方法"的方式,调用当前正在创建的对象属性或方法。但是,通常情况下,我们都择省略"this."。特殊情况下,如果构造器的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。

    同样的我们的构造器也是一样:如果有参构造器没有加给属性加this关键字:控制台输出结果也和上面一样

    在这里插入图片描述

    加上之后:

    在这里插入图片描述

    "this.方法"举例:我们声明两个方法show和sale方法来举例体会一下this的作用:代码参照上面:

    s.show();的结果:
    在这里插入图片描述

    this调用构造器:

    ① 我们在类的构造器中,可以显式的使用"this(形参列表)"方式,调用本类中指定的其他构造器
    ② 构造器中不能通过"this(形参列表)“方式调用自己
    ③ 如果一个类中有n个构造器,则最多有 n - 1构造器中使用了"this(形参列表)”
    ④ 规定:"this(形参列表)“必须声明在当前构造器的首行
    ⑤ 构造器内部,最多只能声明一个"this(形参列表)”,用来调用其他的构造器

    举例:我们还是写一个Shoes类 提供私有属性和get/set方法并提供三个构造器:

    public class Shoes {
    
        //属性
        private  String name;//鞋名
        private int id;//编号
    
        //get/set方法:
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        //构造器1
        public Shoes() {
            System.out.println("构造器1");
        }
        
        //构造器2
        public Shoes(int id){
            this();//调构造器1
            System.out.println("构造器2");
            this.id = id;
        }
    
        //构造器3
        public Shoes(String name, int id) {
            //通过调用构造器来执行其他构造器中的代码
            this(id);//调构造器2
    //        this.id = id;//交给构造器2来执行
            this.name = name;
    
            //我们如果需要使用到其他构造器中的代码就可以使用"this.构造器"的方式
            //这里只是为了举例我们只写了一行输出语句,真正实际中我们写的代码多了,调用构造器的方法的优势就体现出来了
            //这样我们可以减少代码的冗余,提高程序执行效率
        }
    }
    class test{
        public static void main(String[] args) {
    
            //用构造器3来实例化对象,我们在构造器3中没有把参数id赋给当前对象
            //但是通过调构造器2,构造器2中执行了 this.id = id;把id赋给了当前对象的属性
            //所以我们才可以得到当前对象s3的id
            Shoes  s3 = new Shoes("adidas",2021);
            System.out.println(s3.getId());
        }
    }
    

    运行结果:

    在这里插入图片描述

    super:

    super 关键字可以理解为:父类的

    可以用来调用的结构:
    属性、方法、构造器

    super调用属性、方法:

    我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式,显式的调用父类中声明的属性或方法。但是,通常情况下,我们习惯省略"super."

    ①特殊情况:当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性,则必须显式的使用"super.属性"的方式,表明调用的是父类中声明的属性。

    ② 特殊情况:当子类重写了父类中的方法以后,我们想在子类的方法中调用父类中被重写的方法时,则必须显式的使用"super.方法"的方式,表明调用的是父类中被重写的方法(也就是父类中原本的方法)。

    举例两种特殊情况:在子类的方法中调用父类中同名的属性和方法:

    创建一个人类,一个学生类,学生类继承人类,和一个测试类

    //人类
    public class Person {
    
        //属性
        String name = "普通人";//姓名
        int id = 1234;//身份证号
    
        //方法
        public void learn(){
            System.out.println("人要学习");
        }
    }
    
    //学生类
    public class Student extends Person {
    
        //声明了与父类的同名属性
        String name = "哈利波特";//姓名
        int id = 9527;//学号
    
    
        @Override//子类重写父类的方法
        public void learn() {
    
            System.out.println("学生要努力学习");
            super.learn();//调父类中原本的方法
            System.out.println("姓名:"+name);//子类自己的属性
            System.out.println("学号:"+id);
            System.out.println("姓名:"+super.name);//父类中声明的属性
            System.out.println("身份证号:"+super.id);
        }
    }
    
    //测试类
    public class Test {
        public static void main(String[] args) {
            //实例化子类对象
            Student student = new Student();
            //调子类中重写父类的方法
            student.learn();
        }
    }
    

    输出结果:

    在这里插入图片描述

    super调用构造器:

    我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器

    注意:

    • "super(形参列表)"的使用,必须声明在子类构造器的首行!
    • 我们在类的构造器中,针对于"this(形参列表)"或"super(形参列表)"只能二者取其一,不能同时出现
    • 在构造器的首行,没显式的声明"this(形参列表)“或"super(形参列表)”,则默认调用的是父类中空参的构造器:super()
    • 在类的多个构造器中,至少一个类的构造器中使用了"super(形参列表)",调用父类中的构造器

    举例:还是用上面的例子,我们在人类和学生类中添加构造器:

    public class Person {
    
        //属性
        String name = "普通人";//姓名
        int id = 1234;//身份证号
    
    
        //构造器
        public Person() {
    
        }
    	
        public Person(String name, int id) {
            this.name = name;
            this.id = id;
        }
    
        //方法
        public void learn(){
            System.out.println("人要学习");
        }
    }
    
    public class Student extends Person {
    
        //声明了与父类的同名属性
        String name = "哈利波特";//姓名
        int id = 9527;//学号
    
    
        //构造器1
        public Student(String name, int id) {
            this.name = name;
            this.id = id;
        }
    	//构造器2
        public Student(String name, int id, String name1, int id1) {
            super(name, id);//调用父类已有的构造器
            this.name = name1;
            this.id = id1;
        }
    
        @Override//子类重写父类的方法
        public void learn() {
    
            System.out.println("学生要努力学习");
            super.learn();//调父类中原本的方法
            System.out.println("姓名:"+name);//子类自己的属性
            System.out.println("学号:"+id);
            System.out.println("姓名:"+super.name);//父类中声明的属性
            System.out.println("身份证号:"+super.id);
        }
    }
    

    在子类构造器2中调用父类已有的有参构造器:

    然后测试:实例化学生类的对象并给属性赋值,调learn方法:

    public class Test {
        public static void main(String[] args) {
            Student student = new Student("人",8888,"学生",2021);
            student.learn();
        }
    }
    

    输出结果:

    在这里插入图片描述

    this与super的区别总结:

    ①代表事物不同

    ​ this表示当前所属函数的调用者对象

    ​ super表示调用父类的结构(属性,方法,构造器)

    ②使用前提不同

    ​ super必须要有继承关系才能使用

    ​ this不需要继承关系也能使用

    ③调用的构造器不同

    ​ super:调用父类的构造器

    ​ this:调用当前类(本类)的构造器

    说明:

    在栈空间中存放的是对象的引用也就是对象名指向堆空间中new的对象,在堆空间中子类和父类的属性都会有,this和super都可以通过栈空间的引用指向堆空间来调用具体的属性.

    在这里插入图片描述

    继续加油~~冲冲冲! ! !

    展开全文
  • 形参意义就是给属性赋值,我们是要给同名属性赋值,这时候我们就把形参名属性名字写成一样,这样我们就知道我们传入形参就是要给我们同名属性去赋值. 在类方法中,我们可以使用"this.属性"或"this....

    this:
    this理解为:当前对象 或 当前正在创建的对象

    可以调用的结构:属性、方法;构造器

    this调用属性、方法:

    先了解一下形参:

    形参的意义就是给属性赋值,我们是要给同名的属性赋值,这时候我们就把形参名和属性的名字写成一样,这样我们就知道我们传入的形参就是要给我们同名的属性去赋值的.

    在类的方法中,我们可以使用"this.属性"或"this.方法"的方式,调用当前对象属性或方法。但是,

    通常情况下,我们都择省略"this."。特殊情况下,如果方法的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。

    举例:我们声明一个类叫鞋类,给它提供私有的属性和get/set方法和构造器:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    //声明一个鞋类
    public class shoes {
     //鞋的属性
     private String name;//鞋名
     private int id;//编号
     
      
     //无参构造器
     public shoes() {
     }
     
     //有参构造器:
     public shoes(String name, int id) {
    //  name = name;没加this
      this.name = name;
    //  id = id; 没加this
      this.id = id;
     }
      
      
     //声明两个方法
     public void show(){
      System.out.println("展示~~");
      sale();//show方法中调sale方法
    //  this.sale();//this可省略
     }
     public void sale(){
      System.out.println("售卖~~");
     }
     
      
     //get/set方法:
     public String getName() {
      return name;
     }
     public void setName(String name) {
      //name = name;没加this
      this.name = name;
     }
     public void setId(int id) {
      //id = id;没加this
      this.id = id;
     }
     public int getId() {
      return id;
     }
    }
     
    //测试
    class test {
     public static void main(String[] args) {
      //我们先实例化鞋类的对象来调它的属性
      shoes s = new shoes();
      s.setName("nike");//这里的"nike"就是传入的形参
      System.out.println(s.getName());
      //我们获取鞋名的时候,获取不到,意思就是形参的值又赋给了形参,代表没有给鞋的属性赋上值
      //这个时候控制台会输出传入的形参数据类型的默认值,明显不是我们想看到的结果
      s.setId(1);
      System.out.println(s.getId());//鞋的id类似的也会出现同样的情况
       
       
      //"this.方法"举例:
      s.show();
      /*我们先调的是show自己的方法体,然后在show方法中调了sale方法
      意思是s这个对象调了show方法,我们就用调show方法的这个对象s来调sale方法,
      其实在sale();前面也省略了this关键字,表示当前对象(就是调show方法的对象)调的sale方法*/
       
       
    System.out.println("------------------------分割线--------------------");
       
       
      shoes s1 = new shoes("李宁",2);//我们new的有参数的对象给它赋初值之后
      System.out.println(s1.getName());
      System.out.println(s1.getId());//如果没有加this,结果还是和没有获取到鞋名和编号
     }
    }
    先来看没有加this关键字的情况:

    在这里插入图片描述

    结果:

    在这里插入图片描述

    然后我们给鞋属性加上this关键字:

    在这里插入图片描述

    控制台输出的就是我们给鞋设置的名字和编号:

    在这里插入图片描述

    在类的构造器中,我们可以使用"this.属性"或"this.方法"的方式,调用当前正在创建的对象属性或方法。但是,通常情况下,我们都择省略"this."。特殊情况下,如果构造器的形参和类的属性同名时,我们必须显式的使用"this.变量"的方式,表明此变量是属性,而非形参。

    同样的我们的构造器也是一样:如果有参构造器没有加给属性加this关键字:控制台输出结果也和上面一样

    在这里插入图片描述

    加上之后:

    在这里插入图片描述

    "this.方法"举例:我们声明两个方法show和sale方法来举例体会一下this的作用:代码参照上面:

    s.show();的结果:

    在这里插入图片描述

    this调用构造器:

    ① 我们在类的构造器中,可以显式的使用"this(形参列表)"方式,调用本类中指定的其他构造器

    ② 构造器中不能通过"this(形参列表)“方式调用自己

    ③ 如果一个类中有n个构造器,则最多有 n - 1构造器中使用了"this(形参列表)”

    ④ 规定:"this(形参列表)“必须声明在当前构造器的首行

    ⑤ 构造器内部,最多只能声明一个"this(形参列表)”,用来调用其他的构造器

    举例:我们还是写一个Shoes类 提供私有属性和get/set方法并提供三个构造器:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    public class Shoes {
     
     //属性
     private String name;//鞋名
     private int id;//编号
     
     //get/set方法:
     public String getName() {
      return name;
     }
     
     public void setName(String name) {
      this.name = name;
     }
     
     public int getId() {
      return id;
     }
     
     public void setId(int id) {
      this.id = id;
     }
     
     //构造器1
     public Shoes() {
      System.out.println("构造器1");
     }
      
     //构造器2
     public Shoes(int id){
      this();//调构造器1
      System.out.println("构造器2");
      this.id = id;
     }
     
     //构造器3
     public Shoes(String name, int id) {
      //通过调用构造器来执行其他构造器中的代码
      this(id);//调构造器2
    //  this.id = id;//交给构造器2来执行
      this.name = name;
     
      //我们如果需要使用到其他构造器中的代码就可以使用"this.构造器"的方式
      //这里只是为了举例我们只写了一行输出语句,真正实际中我们写的代码多了,调用构造器的方法的优势就体现出来了
      //这样我们可以减少代码的冗余,提高程序执行效率
     }
    }
    class test{
     public static void main(String[] args) {
     
      //用构造器3来实例化对象,我们在构造器3中没有把参数id赋给当前对象
      //但是通过调构造器2,构造器2中执行了 this.id = id;把id赋给了当前对象的属性
      //所以我们才可以得到当前对象s3的id
      Shoes s3 = new Shoes("adidas",2021);
      System.out.println(s3.getId());
     }
    }
    运行结果:

    在这里插入图片描述

    super:
    super 关键字可以理解为:父类的

    可以用来调用的结构:
    属性、方法、构造器

    super调用属性、方法:

    我们可以在子类的方法或构造器中。通过使用"super.属性"或"super.方法"的方式,显式的调用父类中声明的属性或方法。但是,通常情况下,我们习惯省略"super."

    ①特殊情况:当子类和父类中定义了同名的属性时,我们要想在子类中调用父类中声明的属性,则必须显式的使用"super.属性"的方式,表明调用的是父类中声明的属性。

    ② 特殊情况:当子类重写了父类中的方法以后,我们想在子类的方法中调用父类中被重写的方法时,则必须显式的使用"super.方法"的方式,表明调用的是父类中被重写的方法(也就是父类中原本的方法)。

    举例两种特殊情况:在子类的方法中调用父类中同名的属性和方法:

    创建一个人类,一个学生类,学生类继承人类,和一个测试类

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    //人类
    public class Person {
     
     //属性
     String name = "普通人";//姓名
     int id = 1234;//身份证号
     
     //方法
     public void learn(){
      System.out.println("人要学习");
     }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    //学生类
    public class Student extends Person {
     
     //声明了与父类的同名属性
     String name = "哈利波特";//姓名
     int id = 9527;//学号
     
     
     @Override//子类重写父类的方法
     public void learn() {
     
      System.out.println("学生要努力学习");
      super.learn();//调父类中原本的方法
      System.out.println("姓名:"+name);//子类自己的属性
      System.out.println("学号:"+id);
      System.out.println("姓名:"+super.name);//父类中声明的属性
      System.out.println("身份证号:"+super.id);
     }
    }
    1
    2
    3
    4
    5
    6
    7
    8
    9
    //测试类
    public class Test {
     public static void main(String[] args) {
      //实例化子类对象
      Student student = new Student();
      //调子类中重写父类的方法
      student.learn();
     }
    }
    输出结果:

    在这里插入图片描述

    super调用构造器:

    我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器

    注意:

    "super(形参列表)"的使用,必须声明在子类构造器的首行!我们在类的构造器中,针对于"this(形参列表)"或"super(形参列表)"只能二者取其一,不能同时出现在构造器的首行,没显式的声明"this(形参列表)“或"super(形参列表)”,则默认调用的是父类中空参的构造器:super()在类的多个构造器中,至少一个类的构造器中使用了"super(形参列表)",调用父类中的构造器

    展开全文
  • 1) 不仅输出局部变量num, 还要输出本类成员变量的num:2) 除满足1)的要求外,还要输出父类成员变量的num:================================================================this super 的区别: 分别是...
  • 先简单介绍一下this 和super 一、this  this是自身一个对象,代表对象本身,可以理解为:指向对象本身一个指针。  this的用法在java中大体可以分为3种: 1、普通直接引用 this相当于是指向当前对象本身。 2...
  • Java 关键字super和this的使用及区别 1年前 419 "this",作为一个特殊的关键字,它规则如下: 1.可以表示构造函数传递。this(a,b)表示调用另外一个构造函数。这里面的this就是一个特殊语法,不是变量,没有...
  • 当实例变量局部变量命名冲突时候,用this.表示实例变量 2.用在构造方法中,this(...)调用本类中其他构造方法。必须是构造方法中第一句。 super: 1.引用 指父类对象。访问父类被遮盖属性或调用父类被...
  • this关键字 this是自身一个对象,代表对象本身,可以理解为:指向对象本身一个指针。 this的用法在java中大体可以分为3种: 1.普通直接引用,this相当于是指向当前对象本身。 2.形参与成员名字重名,用...
  • 1.this&super 什么是thisthis是自身一个对象,代表...要注意this只能在类中非静态方法中使用,静态方法静态代码块中绝对不能出现thisthis也可作为构造函数来使用。 什么是super? 可以理解为是
  • 关键字this和super

    2020-11-01 11:11:38
    this和super的区别 区别点 this super 访问属性 访问本类中的属性,如果本类没有此属性则从父类中继续查找 直接查找父类中的属性 调用方法 访问本类中的方法...
  • java中关键字this和super的用法和区别

    千次阅读 2019-03-18 20:37:38
    this和super的用法以及它们的区别在这里做了一些整理,大家可以参考使用 1. this:this是自身的一个对象,以下是几种用法: 1.1.当形参与成员变量重名时,用this来区分,this.name 代表类的成员变量 1.2.引用构造...
  • 面向对象this关键字和super关键字的区别 最近学习了面向对象的this关键字和super关键字,首先我们来看看它们的基本概念: this关键字概念:当前对象的引用 。 super关键字概念:上级对象的引用。用来访问上级对象的...
  • 注意:使用super关键字和this关键字,均不能用在静态方法中,只能用在普通方法(实例方法)中。 访问属性: 示例: 父类 public class FatherClass{ public int age=18; } 子类 public c
  • 初学java,经常会被两个关键字this和super混淆,今天我们就在这里简单区别一下:  this表示当前对象,也就是当前类对象,  super表示当前类父类。 比如你定义一个新类:A,这个A继承了类B,也就是说B是A父类...
  • this表示当前对象:  this.属性 区分成员变量局部变量  this.() 调用本类某个方法 ... this关键字只能出现在非static修饰代码中  super表示父类对象:  super.属性 表示父类对象中成员变量...
  • this:表示当前对象引用 1,this():调用本类其他构造方法 2,this.data : 访问当前类当中属性 3,this.function():调用本类其他成员方法。 super:代表父类对象引用 1,super():调用父类构造...
  • 1.super关键字和this关键字的区别super关键字: 表示父类对象的引用,只能在子类中使用 可以使用 super() 调用父类的构造方法,必须位于第一行 可以使用 super. 访问父类的属性方法,解决父类子类中成员同名...
  • 一、关键字this的使用。 this调用是本类中属性,也就是类中成员变量。通过this引用变量形式如下:this.成员变量名。 实例:void setName(int name)  {   this.name=name;  } 2.
  • super关键字this和super的区别

    千次阅读 2014-12-16 15:39:55
    在Java中,this关键字可以调用当前类中属性、方法和构造方法。使用super关键字可以在子类中引用父类属性、方法和构造方法。主要使用形式有以下几种: ...比较this和super 比较 this super
  • 不能调用类变量类方法(即static修饰方法变量),也不能调用局部变量。 this指向当前对象 public class Apple { int a; Apple eatApple(){ a++; return this; } public static void main(String[] ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 496
精华内容 198
关键字:

关键字this和super的区别