精华内容
下载资源
问答
  • this关键字与super关键字详解

    万次阅读 多人点赞 2018-02-02 12:17:03
    一.this关键字 1.实例一: (1)需求:使用Java类描述一个动物; (2)实例: class Animal{ String name; //成员变量 String color; public Animal(String n,String c){ name = n; color = c; } ...

    一.this关键字

    1.实例一:

    (1)需求:使用Java类描述一个动物;

    (2)实例:

    class Animal{
    	String name;	//成员变量
    	String color;
    	public Animal(String n,String c){
    		name = n;
    		color = c;
    	}
    	public void eat(){
    		String name = "老鼠";	//局部变量
    		System.out.println(name+"在吃……");
    	}
    }
    
    class Demo1{
    	public static void main(String[] args){
    		Animal dog = new Animal("狗","白色");//此时在内存中存在两份name数据
    		Animal cat = new Animal("猫","黑色");
    		cat.eat();
    	}
    }
    
    

    (3)运行结果:


    (4)存在的问题:

    当我们new一个动物cat时,让cat去调用eat方法,结果显示的却是老鼠在吃;

    也就是说当存在同名的成员变量与局部变量时,在方法的内部访问的是局部变量,那是因为Java采取的是就近原则访问的,要解决这个问题就需要使用this关键字;

    2.存在同名成员变量与局部变量的内存分


    (1)栈内存也叫方法栈,把它称为方法栈的原因是因为:一个方法要运行的时候,JVM会在栈内存中开辟一片属于这个方法的空间,让这个方法在这片空间内执行;

    (2)首先在这片代码中主方法会先执行,主方法一执行,JVM会在栈内存中开辟一片空间属于main方法,在这片空间中先声明了一个变量a,接着new一个Animal,这时候在堆内存中就创建了一个Animal对象,这个Animal有name和color两个属性,都分配了默认的初始值,name=“狗”,color=null;这时候假设它的内存地址是0X98,此时a这个变量就指向了0X98,也就是a指向了这个对象;
    (3)接着在main方法的这片空间执行a.eat();eat方法执行的时候,JVM在栈内存中为这个方法开辟了一片属于eat方法的空间,在这个eat方法里首先声明了一个变量name=“老鼠”,紧接着输出语句,因为Java采取的是就近原则来访问的,因为输出语句中的name变量在eat方法这片空间也存在,如果存在它就只会在eat方法这片空间去找,如果这片空间没有它才会去到堆内存中去找

    3.定义:

    (1)this关键字代表了所属函数的调用者对象,this代表了对象的内存地址(在构造函数中打印this会发现结果是一个内存地址),也就是说哪个对象调用了this所在的函数,那么this就指代哪个对象;

    (2)this是指向本类中某一个对象的一个变量,this相当于文章中第一人称的“我”,所有人描述自己的时候都会说“我”,只要读“我”的这个人发生变化,这个“我”指向的人就变了;而this关键字与之类似,this是抽象的,刚开始并不知道是指代谁,this是每一个对象携带的变量,这个变量所指向的都是自己,this只是起到了一个描述的作用:只要有一个具体的对象来执行的时候,this就用这个对象的this,换一个对象,this就变成另一个对象的this,所以只有在执行的时候才知道指向谁。就像文章中的“我”,只有确定了谁是读这篇文章的,才能确定这个“我”指代谁;

    (3)this关键字代表的是对象的引用,也就是this在指向一个对象,所指向的对象就是调用该函数的对象引用;

    4.this关键字的作用:

    (1)如果存在同名的成员变量与局部变量时,在方法内部默认是访问局部变量的数据,可以通过this关键字指定访问成员变量的数据;

    (2)在一个构造函数中可以调用另外一个构造函数初始化对象;

    5.this关键字要注意的事项:

    (1)存在同名的成员变量与局部变量时,在方法的内部访问的是局部变量(Java采取的是“就近原则”的机制访问的);

    (2)如果在一个方法中访问了一个变量,该变量只存在成员变量的情况下,那么Java编译器会在该变量的前面添加this关键字;

    6.this关键字调用其他的构造函数要注意的事项:

    (1)this关键字调用其他的构造函数时,this关键字必须要位于构造函数中的第一个语句;

    (2)this关键字在构造函数中不能出现相互调用的情况,因为是一个死循环;

    7.实例二

    class Student{
    	int id;	//身份证
    	String name;	//名字
    	public Student(int id,String name){//一个函数的形式参数也是属于局部变量
    		this(name);	//调用了本类的一个参数的构造方法,根据传入的参数确定调用的是本类的哪一个构造方法
    		this.id = id;	//局部变量的id给成员变量的id赋值
    		System.out.println("两个参数的构造方法被调用了……");
    	}
    	public Student(){
    		System.out.println("无参的构造方法被调用了……");
    	}
    	public Student(String name){
    		this.name = name;
    		System.out.println("一个参数的构造方法被调用了……");
    	}
    }
    
    class Demo6{
    	public static void main(String[] args){
    		Student s = new Student(110,"铁蛋");
    		System.out.println("编号:"+s.id+"  姓名:"+s.name);
    	}
    }
    
    
    运行结果如下图所示:



    注意:如果是this(); 代表调用了本类无参的构造方法。

    8.实例三:

    (1)需求:

    使用Java定义一个人类,人具备id,name,age三个属性,还具备一个比较年龄的方法;必须要写上一个构造函数,构造函数也必须要使用this关键字。

    class Person{	
    	int id; //编号
    	String name; //姓名
    	int age;  //年龄
    	//构造函数
    	public Person(int id,String name ,int age){
    		this.id  = id;
    		this.name = name;
    		this.age = age;
    	}
    	//比较年龄的方法,这是本身就具备的,还有一个和谁比较是未知数
    	public void compareAge(Person p2){
    		if(this.age>p2.age){
    			System.out.println(this.name+"大!");
    		}else if(this.age<p2.age){
    			System.out.println(p2.name+"大!");
    		}else{
    			System.out.println("同龄");
    		}
    	}
    }
    
    class Demo7{
    	public static void main(String[] args) {
    		Person p1 = new Person(110,"狗娃",17);
    		Person p2 = new Person(119,"铁蛋",9);
    		p1.compareAge(p2);
    	}
    }
    
    

    (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。

    4. super关键字与this关键字的区别:

    5.实例

    class Father {
    	int x = 1;
    
    	Father() {
    		System.out.println("这是父类无参的构造方法");
    	}
    
    	Father(int x) {
    		this.x = x;
    		System.out.println("这是父类有参的构造方法");
    	}
    
    	void speak() {
    		System.out.println("我是父类");
    	}
    }
    
    class Son extends Father {
    	int y = 1;
    	Son() {
    		System.out.println("这是子类无参的构造方法");
    	}
    
    	Son(int y) {
    		this.y = y+x;
    		System.out.println("这是子类带参的构造方法");
    	}
    
    	void run() {
    		super.speak();	//访问父类的函数
    		System.out.println("我是子类");
    	}
    }
    
    class Demo1{
    	public static void main(String[] args) {
    		Son s = new Son(3);
    		System.out.println(s.y);	//4
    	}
    }
    
    

    运行结果如下图所示:


    6.super关键字主要存在于子类方法中,用于指向子类对象中的父类对象;可以访问父类的属性、函数以及构造函数



    展开全文
  • #this关键字使用方法代码分析 package basic.Filea; /** * this的介绍 * this是一个引用,this变量保存了内存地址指向自己 * 每一个对象都有一个this * this不能出现在static静态方法中 * 1.this的使用方法有...

    #this关键字使用方法代码分析

    package basic.Filea;
    
    /**
     *  this的介绍
     *      this是一个引用,this变量保存了内存地址指向自己
     *      每一个对象都有一个this
     *      this不能出现在static静态方法中
     * 1.this的使用方法有三种
     *      a、在本类成员方法中,访问父类成员变量
     *      b、在本类成员方法中,访问本类的另一个成员方法
     *      c、在本类构造方法中,访问本类的另一个构造方法
     *     在c中,this()必须是构造方法第一行,唯一一个
     *     super()和this()调用不能同时使用,因为他们都是唯一的
        */
    
    public class Zi extends Fu{
        int a=9;//成员变量
    
        public Zi() {
    //        this();  自己调用自己,错误写法
            this(11);//本类的无参构造,调用本类的有参构造
        /** this(...) 必须是第一个调用唯一一个,同super()
            super和this不能同时使用
            构造方法第一行没有this()也没有super(),系统默认有一个super();
         */
        }
    
        public Zi(int a) {
            System.out.println(a);
        }
        public void Aone() {
            int a=1;  //局部变量
            System.out.println(a);  //1
            System.out.println(this.a);   //9 访问本类的成员变量
        }
    
        public void Bone(){
            System.out.println("Aone!!!");
        }
    
        public void Btwo() {
            this.Aone();  //访问本类的成员方法
            //this可省阅,有着强调字面作用
            System.out.println("Btwo!!");
        }
    }
    
    

    #super关键字的使用方法解析

    package basic.FileElse;
    
    /**
     *      super关键字介绍
     *          super不能使用在static静态方法中
     *          super()只能出现在构造方法第一行,通过当前构造方法调用父类构造方法
     *      super关键字使用方法
     *          a、在子类的成员方法中,访问父类的成员变量
     *          b、在子类的成员方法中,访问父类的成员方法
     *          c、在子类的构造方法中,访问父类的构造方法
     */
    
    public class Zi extends Fu{
        int num=10;
    
        public void setNum(){
            System.out.println(num);//本类中的num
            System.out.println(super.num);//父类中的num
        }
    
        public void moth(){
            super.moth();     //访问父类中的moth()方法
            System.out.println("子类方法!!");
        }
    
        public Zi(){
            /**构造方法第一行没有this()也没有super(),系统默认有一个super();
             * 自己看不见
             */
    
        }
    
    }
    
    
    package basic.FileElse;
    
    public class Fu {
        int num=111;
    
        public Fu() {
            System.out.println("父类构造方法1启用");
        }
    
        public Fu(int num) {
            this.num = num;
            System.out.println("父类构造方法2启用");
        }
    
        public void moth(){
             System.out.println("父类方法!");
         }
    }
    
    
    展开全文
  • Java基础——this关键字与super关键字

    Java基础——this关键字与super关键字

      有关this关键字与super关键字的介绍及区别,可以参考:this与super关键字详解,这里只重点强调this关键字与super关键字中一些关键的知识点。

      首先,this关键字与super关键字的定义:

      this:代表了所属函数的调用者对象,代表了对象的内存地址
      this是指向本类中某一个对象的一个变量,this相当于文章中第一人称的“我”,所有人描述自己的时候都会说“我”,只要读“我”的这个人发生变化,这个“我”指向的人就变了;而this关键字与之类似,this是抽象的,刚开始并不知道是指代谁,this是每一个对象携带的变量,这个变量所指向的都是自己,this只是起到了一个描述的作用:只要有一个具体的对象来执行的时候,this就用这个对象的this,换一个对象,this就变成另一个对象的this,所以只有在执行的时候才知道指向谁。就像文章中的“我”,只有确定了谁是读这篇文章的,才能确定这个“我”指代谁;
      super:代表了父类空间的引用

      说到this,首先先说一下命名遮挡

      命名遮挡(name shadow):局部变量、形参或者其他,与属性、方法或者其他重名导致直接通过名字访问出现歧义。

      因此可以通过this调用本类方法及属性:

       通过this<关键字>调用本类属性:只要在类中访问类的属性,一定要加上this关键字
       类的某个构造方法通过this()<方法>调用其他的构造方法,this调用构造方法必须出现在构造方法的第一行(编译期错误),也不允许成环(编译期错误)
    	class Person{
    	    public Person() {
    	        this(15);
    	    }
    	    public Person(int value) {
    	    }
    	}
    
       通过this<关键字>调用本类中普通方法(this.方法名(参数)):当有类的继承关系时,表示本类方法一定要加上this关键字区别于super本类中没有找子类中的同名方法

      this就如上面描述的一样,代表这个类对象本身。实际上就是那个"我",但具体这个"我"指的是谁,和该类的对象密切相关。下面说一下super关键字,super关键字大多作用于方法之上。

       当super()<方法>用于子类构造方法时:
        当子类调用父类无参构造时(系统默认会调用),super()可写可不写,表示调用父类的无参构造方法。
        当子类调用父类有参构造时,super(参数列表)必须要写,要告诉编译器调用的到底是父类的哪个有参构造方法。
       特别要注意的是:
        当父类中没有无参构造器(无论是默认生成还是自己手写),子类构造器中必须使用super(参数列表)调用父类的有参构造方法。且必须是出现在子类构造方法的第一行语句
        如果是父类存在自定义的无参构造(无论有无有参构造,只要存在无参构造系统就会默认调用),子类可以不直接使用super(),系统默认会调用父类无参构造的。
    	class Person{
    	    public Person() {
    	    }
    	    public Person(int value) {
    	    }
    	}
    	
    	class Student extends Person{
    	    public Student() {
    	    }
    	}
    
        若父类没有无参构造,就必须得使用super()调用父类有参构造。
    	class Person{
    	    public Person(String value) {
    	    }
    	}
    	
    	class Student extends Person{
    	    public Student() {
    	        super("hello");
    	    }
    	}
    
        this()和super()不能同时出现在构造方法中(都要出现在第一行),注意:此处指的是this()这个函数(调用本类其他构造方法),而不是this(值当前类的实例对象)
       当super<关键字>用于子类普通方法时:用于在子类中明确调用父类被覆写的方法。如果不使用super进行调用,子类调用的是子类重写父类的方法。
    	class Person{
    	    public void fun(){
    	        System.out.println("我是学生");
    	    }
    	    public void show(){
    	        System.out.println("你好人类");
    	    }
    	}
    	
    	class Student extends Person{
    	
    	    public void fun(){
    	        System.out.println("我是学生");
    	        // 此处调用的show()是子类覆写父类的方法
    	        show();
    	
    	    }
    	    public void show(){
    	        System.out.println("你好学生");
    	    }
    	}
    
    	class Person{
    	    public void fun(){
    	        System.out.println("我是学生");
    	    }
    	    public void show(){
    	        System.out.println("你好人类");
    	    }
    	}
    	
    	class Student extends Person{
    	
    	    public void fun(){
    	        System.out.println("我是学生");
    	        // 此处调用的show()是子类明确调用父类被覆写的方法
    	        super.show();
    	
    	    }
    	    public void show(){
    	        System.out.println("你好学生");
    	    }
    	}
    
    展开全文
  • Java中super关键字super关键字与this关键字的区别

    千次阅读 多人点赞 2018-10-21 16:31:33
    文章目录1 super关键字1.1 super用于方法1.1.1 用于构造方法1.1.2 用于普通方法1.1.2 用于属性2 super与this关键字的区别2.1 概念上2.2 查找范围2.3 特殊之处 1 super关键字 1.1 super用于方法 1.1.1 用于构造...

    1 super关键字

    1.1 super用于方法

    1.1.1 用于构造方法

    在这里插入图片描述
    子类的构造函数里,其实默认调用的是父类的无参构造,此时super()可写可不写。
    在这里插入图片描述
    当子类向调用父类的有参构造时,super(参数列表)必须要写,要告诉编辑器调用的是哪个有参构造!
    在这里插入图片描述
    在子类构造方法中调用父类构造方法必须是第一行语句!

    1.1.2 用于普通方法

    在这里插入图片描述
      用于在子类中明确调用父类被覆写的方法!

    1.1.2 用于属性

    在这里插入图片描述
      表示调用父类中的属性!

    2 super与this关键字的区别

    Java中this关键字详解

    2.1 概念上

    this:访问本类中的属性及方法。
    super: 由子类访问父类中的属性、方法。

    2.2 查找范围

    this:先找本类,如果本类没有就调用父类。
    super:不查找本类直接调用父类。
    在这里插入图片描述
    在这里插入图片描述

    2.3 特殊之处

    this:可以表示当前对象!
    super:不可以 !

    展开全文
  • this关键字 this关键字,this指向对象本身,一个类可以通过this来获得一个代表它自身的对象变 量。this使用在如下三种情况中: 调用实例变量。 调用实例方法。 调用其他构造方法。 使用this变量的示例代码: ...
  • 构造方法中的this关键字 构造方法是一个类的对象在通过new关键字创建时自动调用的,在程序中不能向调用其他方法一样通过方法名(也就是类名)来调用。但如果一个类有多个构造方法,可以在一个构造方法中通过this...
  • this关键字: this的三大作用:this调用属性,调用方法,表示当前的对象 this是对当前对象的引用,是运行期间当前对象本身。 (1).可以使用this明确的访问当前对象的属性或者方法,类似于“我”。 (2).this()...
  • this语句 super语句 第1章构造方法 我们对封装已经有了基本的了解,接下来我们来看一个新的问题,依然以Person为例,由于Person中的属性都被private了,外界无法直接访问属性,必须对外提供相应的set和get方法。...
  • 整理自:Java中this关键字详解 【用法一:this.属性名称】 指的是访问类中的成员变量 用来区分成员变量和局部变量 *成员变量局部变量区分: 【用法二:this.方法名称】 用来访问本类的成员方法 【用法三:this...
  • 主要介绍了java中this与super关键字的使用方法的相关资料,希望通过本文能帮助到大家,让大家彻底理解应用java中this与super,需要的朋友可以参考下
  • superthis关键字详解

    千次阅读 2020-10-12 17:12:09
    super关键字: ① java中提供了访问父类的成员变量,成员方法的关键字super super.成员变量 super.成员方法(【参数1,参数2***】) ② super关键字调用父类的构造方法 super(【参数1,参数2***】) 调用...
  • Java super关键字详解

    万次阅读 多人点赞 2016-07-15 17:14:48
    一.super关键字作用 1:主要存在于子类方法中,用于指向子类对象中父类对象。 2:访问父类的属性 3:访问父类的函数 4:访问父类的构造函数 二.super注意的地方 this和super很像,this指向的是当前对象的调用,...
  • java中thissuper关键字 初学java的同学都知道,this代表当前对象自身,可以看作是当前对象的虚拟地址(尽管不是,当前可以这么理解).后面再做详细讲解. 很多初学java的同学都习惯性的直译super关键字,认为super关键字...
  • 一、构造方法 我们考虑这样的一个场景: 首先,我们考虑以下代码: public class Person { private String name; private int age; public String getName() { return name;... this.name = name; } ...
  • Java中super关键字详解

    千次阅读 2018-12-30 14:48:36
    在Java的基础学习中,慢慢接触到许多陌生的关键字,今天来讲一下我所认识的super关键字 它的使用场景为:有继承在⭐(必须在继承下才能使用super) 一.super调用(父类)构造方法 看下面这段代码 class Person{...
  • 文章目录1.this1.1. this是什么?1.2 this调用对象中的属性、构造器和方法2.super2.1 super是什么?2.2 super调用父类的属性、构造器、方法3. this与super 比较 ...什么时候使用this关键字呢? 当在方法内需要用到调
  • Java之super关键字详解

    2021-01-03 23:46:23
    super关键字详解 这里分享下一java中super关键字的相关知识。 super关键字: super关键字代表了父类空间的引用。 super关键字的作用: 1. 子父类存在同名的成员时,在子类中默认是访问子类的成员,可以通过super关键字...
  • 在Java中,类继承时会经常用到thissuper关键字,在这里做一下简单的总结,如果有错误希望大家指正。 this this是自身的一个对象,代表对象本身,可以看作:指向对象本身的一个指针。 一般来讲,this有三种用法。 1...
  • java中super关键字详解

    2021-09-16 10:28:53
    super是用于子类对象访问父类内容时的关键字 示例代码: //先创建两个类,父类和子类。 //父类中有有参构造方法和无参构造方法。 class Father { String name; String age; int id = 1001; public Father...
  • super关键字
  • super关键字详解

    千次阅读 多人点赞 2021-01-26 22:58:59
    super关键字详解 由于子类不能继承父类的构造方法,因此,如果要调用父类的构造方法,可以使用super关键字。 super可以用来访问父类的构造方法,普通方法和属性。 super关键字的功能: 在子类的构造方法中显式的...
  • this关键字: 在项目中创建一个类文件夹,该类中定义了firstBlood()并将方法参数值赋予类中的成员变量。 private void firstBlood(String Sup) { //定义一个setName()方法 this.Sup=Sup; //将参数值赋予类中的...
  • Java中this关键字详解

    千次阅读 多人点赞 2019-01-08 22:15:36
    Java中的几个关键字this,final,super,static) 最近几天学习了一下Java的spring框架,课程中遇到了几个关于Java的基础知识拿捏不到位,经过查阅了各类Java,对几个问题有了大致的理解。干脆写下来和大家分享一下...
  • Java中this关键字的作用和用法

    万次阅读 多人点赞 2018-09-03 19:22:39
    简单总结一下Java中this关键字的作用用法。 参考文献: Java中this关键字详解 Java this 关键字用法 java中this关键字的用法 Java this关键字 java中this关键字的作用 功能概述 this关键字主要有三个应用...
  • 简介:1、this表示当前类对象的默认引用,在每个实例...继承关系下子类的this关键字:1) this(paras…); 访问其他的构造方法 2) this.xxx; 访问类中的成员变量xxx 3) this.yyy(paras…); 访问类中的成员方法yyy...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 11,358
精华内容 4,543
关键字:

this关键字与super关键字详解