Java this super代码实例及使用方法总结

这几天看到类在继承时会用到this和super,这里就做了一点总结,与各位共同交流,有错误请各位指正~

一、this

this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针。

this的用法在java中大体可以分为3种:

1.普通的直接引用

这种就不用讲了,this相当于是指向当前对象本身。

2.形参与成员名字重名,用this来区分:

package com.demo;
public class Person {
  private int age = 10;

  public Person(){
    System.out.println("初始化年龄:"+age);
  }
  public int GetAge(int age){
    this.age = age;
    return this.age;
  }
}
package com.demo;

public class Test1 {

  public static void main(String[] args) {
    Person Harry = new Person();
    System.out.println("Harry's age is "+Harry.GetAge(12));
  }
}

运行结果:

初始化年龄:10
Harry's age is 12

3.引用构造函数

这个和super放在一起讲,见下面。

二、super

super可以理解为是指向自己超(父)类对象的一个指针,而这个超类指的是离自己最近的一个父类。

super也有三种用法:

1.普通的直接引用

与this类似,super相当于是指向当前对象的父类,这样就可以用super.xxx来引用父类的成员。

2.子类中的成员变量或方法与父类中的成员变量或方法同名

package com.demo;

public class Country {

  String name;
  void value() {
    name = "China";
  }
}
package com.demo;

public class City extends Country{

  String name;

  void value() {
    name = "Shanghai";
    super.value(); // 调用父类的方法
    System.out.println(name);
    System.out.println(super.name);
  }

  public static void main(String[] args) {
    City c = new City();
    c.value();
  }
}

运行结果:

Shanghai
China

可以看到,这里既调用了父类的方法,也调用了父类的变量。若不调用父类方法value(),只调用父类变量name的话,则父类name值为默认值null。

3.引用构造函数

super(参数):调用父类中的某一个构造函数(应该为构造函数中的第一条语句)。

this(参数):调用本类中另一种形式的构造函数(应该为构造函数中的第一条语句)。

package com.demo.test;

public class Person {

  public static void prt(String s) {
    System.out.println(s);
  }

  Person() {
    prt("父类·无参数构造方法: " + "A Person.");
  }// 构造方法(1)

  Person(String name) {
    prt("父类·含一个参数的构造方法: " + "A person's name is " + name);
  }// 构造方法(2)
}
package com.demo.test;

public class Chinese extends Person {

  Chinese() {
    super(); // 调用父类构造方法(1)
    prt("子类·调用父类“无参数构造方法“: " + "A chinese coder.");
  }

  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("codersai");
    cn = new Chinese("codersai", 18);
  }
}

运行结果:

父类·无参数构造方法: A Person.
子类·调用父类“无参数构造方法“: A chinese coder.
父类·含一个参数的构造方法: A person's name is codersai
子类·调用父类”含一个参数的构造方法“: his name is codersai
父类·含一个参数的构造方法: A person's name is codersai
子类·调用父类”含一个参数的构造方法“: his name is codersai
子类:调用子类具有相同形参的构造方法:his age is 18

从本例可以看到,可以用super和this分别调用父类的构造方法和本类中其他形式的构造方法。

例子中Chinese类第三种构造方法调用的是本类中第二种构造方法,而第二种构造方法是调用父类的,因此也要先调用父类的构造方法,再调用本类中第二种,最后是重写第三种构造方法。

三、super 和 this 的异同

  • super(参数):调用基类中的某一个构造函数(应该为构造函数中的第一条语句)
  • this(参数):调用本类中另一种形成的构造函数(应该为构造函数中的第一条语句)
  • super:它引用当前对象的直接父类中的成员(用来访问直接父类中被隐藏的父类中成员数据或函数,基类与派生类中有相同成员定义时如:super.变量名 super.成员函数据名(实参)
  • this:它代表当前对象名(在程序中易产生二义性之处,应使用this来指明当前对象;如果函数的形参与类中的成员数据同名,这时需用this来指明成员变量名)
  • 调用super()必须写在子类构造方法的第一行,否则编译不通过。每个子类构造方法的第一条语句,都是隐含地调用super(),如果父类没有这种形式的构造函数,那么在编译的时候就会报错。
  • super()和this()类似,区别是,super()从子类中调用父类的构造方法,this()在同一类内调用其它方法。
  • super()和this()均需放在构造方法内第一行。
  • 尽管可以用this调用一个构造器,但却不能调用两个。
  • this和super不能同时出现在一个构造函数里面,因为this必然会调用其它的构造函数,其它的构造函数必然也会有super语句的存在,所以在同一个构造函数里面有相同的语句,就失去了语句的意义,编译器也不会通过。
  • this()和super()都指的是对象,所以,均不可以在static环境中使用。包括:static变量,static方法,static语句块。
  • 从本质上讲,this是一个指向本对象的指针, 然而super是一个Java关键字。

一、this

Java关键字this只能用于方法体内。当一个对象创建后,Java虚拟机(JVM)就会给这个对象分配一个引用自身的指针,这个指针的名字就是this。因此,this只能在类中的非静态方法中使用,静态方法和静态的代码块中绝对不能出现this。并且this只和特定的对象关联,而不和类关联,同一个类的不同对象有不同的this。下面给出一个使用this的综合实例,以便说明问题:

package com.demo.test;

public class Testthis {

  private int number;
  private String username;
  private String password;
  private int x = 100;

  public Testthis(int n) {
    number = n; // 这个还可以写为: this.number=n;
  }

  public Testthis(int i, String username, String password) {
    // 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
    this.username = username;
    this.password = password;
  }

  // 默认不带参数的构造方法
  public Testthis() {
    this(0, "未知", "空"); // 通过this调用另一个构造方法
  }

  public Testthis(String name) {
    this(1, name, "空"); // 通过this调用另一个构造方法
  }

  public static void main(String args[]) {
    Testthis t1 = new Testthis();
    Testthis t2 = new Testthis("游客");
    t1.outinfo(t1);
    t2.outinfo(t2);
  }

  private void outinfo(Testthis t) {
    System.out.println("-----------");
    System.out.println(t.number);
    System.out.println(t.username);
    System.out.println(t.password);
    f(); // 这个可以写为: this.f();
  }

  private void f() {
    // 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
    int x;
    x = this.x++;
    System.out.println(x);
    System.out.println(this.x);
  }

  // 返回当前实例的引用
  private Testthis getSelf() {
    return this;
  }
}

运行结果如下:

-----------
未知
空
101
-----------
游客
空
101

看着上面的例子,说明在什么情况下需要用到this:

第一、通过this调用另一个构造方法,用法是this(参数列表),这个仅仅在类的构造方法中,别的地方不能这么用。

第二、函数参数或者函数中的局部变量和成员变量同名的情况下,成员变量被屏蔽,此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然,在没有同名的情况下,可以直接用成员变量的名字,而不用this,用了也不为错,呵呵。

第三、在函数中,需要引用该函数所属类的当前对象的时候,直接用this。其实这些用法总结都是从对“this是指向对象本身的一个指针”这句话的更深入的理解而来的,死记不然容易忘记而且容易搞错,要理解!

二、super

super关键字和this作用类似,使被屏蔽的成员变量或者成员方法变为可见,或者说用来引用被屏蔽的成员变量和成员方法。不过super是用在子类中,目的是访问直接父类中被屏蔽的成员,注意是直接父类(就是类之上最近的超类)。下面是一个综合运用super的例子,有两个类:一个Father类,一个Father类的子类Son,通过这两个类完全演示了super的用法,以下是代码:

package com.demo.test;

public class Father {

  public String v = "Father";
  public String x = "输出了Father类的public成员变量x!!!";

  public Father() {
    System.out.println("Father构造方法被调用!");
  }

  public Father(String v) {
    this.v = "Father类的带参数构造方法!运行了.";
  }

  public void outinfo() {
    System.out.println("Father的outinfo方法被调用");
  }

  public static void main(String[] args) {
    // TODO 自动生成方法存根
  }
}
package com.demo.test;

public class Son extends Father {

  public String v = "Son";

  public Son() {
    super(); // 调用超类的构造方法,只能放到第一行.
    System.out.println("Son无参数构造方法被调用!");
    // super(); //错误的,必须放到构造方法体的最前面.
  }

  public Son(String str) {
    super(str);
    System.out.println("Son带参数构造方法被调用!");
  }

  // 覆盖了超类成员方法outinfo()
  public void outinfo() {
    System.out.println("Son的outinfo()方法被调用");
  }

  public void test() {

    String v = "哈哈哈哈!"; // 局部变量v覆盖了成员变量v和超类变量v

    System.out.println("------1-----");
    System.out.println(v); // 输出局部变量v
    System.out.println(this.v); // 输出(子类)成员变量v
    System.out.println(super.v); // 输出超类成员变量v

    System.out.println("------2-----");
    System.out.println(x); // 输出超类成员变量v,子类继承而来
    System.out.println(super.x); // 输出超类成员变量v

    System.out.println("------3-----");
    outinfo(); // 调用子类的outinfo()方法
    this.outinfo(); // 调用子类的outinfo()方法
    super.outinfo(); // 调用父类的outinfo()方法
  }

  public static void main(String[] args) {
    new Son().test();

  }
}

运行结果:

Father构造方法被调用!
Son无参数构造方法被调用!
------1-----
哈哈哈哈!
Son
Father
------2-----
输出了Father类的public成员变量x!!!
输出了Father类的public成员变量x!!!
------3-----
Son的outinfo()方法被调用
Son的outinfo()方法被调用
Father的outinfo方法被调用

说明:此例子仅仅为了说明super的用法,实际在设计类的时候一般都尽可能私有(private)化。

通过上面的例子,下面总结一下super的用法:

第一、在子类构造方法中要调用父类的构造方法,用“super(参数列表)”的方式调用,参数不是必须的。同时还要注意的一点是:“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。

第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时,也就是子类局部变量覆盖父类成员变量时,用“super.成员变量名”来引用父类成员变量。当然,如果父类的成员变量没有被覆盖,也可以用“super.成员变量名”来引用父类成员变量,不过这是不必要的。

第三、当子类的成员方法覆盖了父类的成员方法时,也就是子类和父类有完全相同的方法定义(但方法体可以不同),此时,用“super.方法名(参数列表)”的方式访问父类的方法。

this、super的用法也不过这些,只有理解了其中的原理,才不会跌入陷阱!

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • 详解java中this.getClass()和super.getClass()的实例

    详解java中this.getClass()和super.getClass()的实例 前言: 遇到this.getClass()和super.getClass()的返回值感到疑惑,经过探索豁然开朗. getClass()是java中Object类的一个方法,其原型为: public final Class<?> getClass() 返回值为 当前运行时类的Class对象. 所以写了一段代码来说明: getClass()不受this和super影响,而是有当前的运行类决定的. 代码如下: 父类

  • Java中的构造方法this、super的用法详解

    1.构造方法 定义:与类同名没有返回值的方法称为构造方法: public class test1 { private String name; private int age; public test1(){ } } 上面的test1()是默认构造方法,即使没有定义java虚拟机在运行的时候也会自动生成, 当然如果定义了重载的构造方法便不会自动生成: 构造方法的作用有两点1.通过构造方法建立一个对象:2.通过构造方法可以快速的赋初值: public class Main { public sta

  • java中this与super关键字的使用方法

    java中this与super关键字的使用方法 这几天看到类在继承时会用到this和super,这里就做了一点总结,与各位共同交流,有错误请各位指正~ this this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针. this的用法在java中大体可以分为3种: 1.普通的直接引用 这种就不用讲了,this相当于是指向当前对象本身. 2.形参与成员名字重名,用this来区分: class Person { private int age = 10; public Perso

  • java基础知识 super和this使用解析

    这篇文章主要介绍了java基础知识 super和this使用解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 super关键字的用法有三种: 1.在子类的成员方法中,访问父类的成员变量 2.在子类的成员方法中,访问父类的成员方法 3.在子类的构造方法中,访问父类的构造方法 this和super区别 super关键字用来访问父类内容,this关键字用来访问本类内容. 1.在本类的成员方法中,访问本类的成员变量 2.在本类的成员方法中,访问本类的

  • 详解Java中super的几种用法并与this的区别

    1. 子类的构造函数如果要引用super的话,必须把super放在函数的首位 复制代码 代码如下: class Base { Base() { System.out.println("Base"); } } public class Checket extends Base { Checket() { super();//调用父类的构造方法,一定要放在方法的首个语句 System.out.println("Checket"); } public static voi

  • 举例讲解Java编程中this关键字与super关键字的用法

    this 总要有个事物来代表类的当前对象,就像C++中的this指针一样,Java中的this关键字就是代表当前对象的引用. 它有三个主要的作用: 1.在构造方法中调用其他构造方法.       比如有一个Student类,有三个构造函数,某一个构造函数中调用另外构造函数,就要用到this(),而直接使用Student()是不可以的. 2.返回当前对象的引用. 3.区分成员变量名和参数名. 看下面的例子: public class Student { private String name; p

  • java this super使用方法详解

    super是Java语言的保留字,用来指向类的超类. 假设在Teacher类中定义了一个类变量boolean gender; 在子类的方法中gender就应该是指子类的gender变量,如果要引用超类的gender变量的话就必须使用 super.genderthis对象在类的构造方法中,要给对象的域进行初始化,这时如果参数和类变量同名,则类变量的名字将会被参数名屏蔽, 必须知道当前的对象名称,才能用对象名引用对象的域 复制代码 代码如下: public DotLoc(double XX,doub

  • Java this super代码实例及使用方法总结

    这几天看到类在继承时会用到this和super,这里就做了一点总结,与各位共同交流,有错误请各位指正~ 一.this this是自身的一个对象,代表对象本身,可以理解为:指向对象本身的一个指针. this的用法在java中大体可以分为3种: 1.普通的直接引用 这种就不用讲了,this相当于是指向当前对象本身. 2.形参与成员名字重名,用this来区分: package com.demo; public class Person { private int age = 10; public Pe

  • Windows下Java调用可执行文件代码实例

    这篇文章主要介绍了Windows下Java调用可执行文件代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 缘起: 由于没有找到java转换文件的接口,因此使用java调用exe文件进行文件转换 public void convertFile(){ Runtime rn = Runtime.getRuntime(); Process p =null; try{ p = rn.exec("D:/convert/Convert.exe D:/c

  • 通过Java压缩JavaScript代码实例分享

    通过移除空行和注释来压缩 JavaScript 代码 /** * This file is part of the Echo Web Application Framework (hereinafter \"Echo\"). * Copyright (C) 2002-2009 NextApp, Inc. * * Compresses a String containing JavaScript by removing comments and whitespace. */ public

  • Java加密算法RSA代码实例

    这篇文章主要介绍了Java加密算法RSA代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 代码如下 import javax.crypto.BadPaddingException; import javax.crypto.Cipher; import javax.crypto.IllegalBlockSizeException; import javax.crypto.NoSuchPaddingException; import java

  • JAVA各种OOM代码示例与解决方法

    周末了,觉得我还有很多作业没有写,针对目前大家对OOM的类型不太熟悉,那么我们来总结一下各种OOM出现的情况以及解决方法. 我们把各种OOM的情况列出来,然后逐一进行代码编写复现和提供解决方法. 1. 堆溢出-java.lang.OutOfMemoryError: Java heap space. 2. 栈溢出-java.lang.OutOfMemorryError. 3. 栈溢出-java.lang.StackOverFlowError. 4. 元信息溢出-java.lang.OutOfMem

  • Java表格JTable代码实例解析

    代码如下: import javax.swing.JTable; import javax.swing.table.AbstractTableModel; import javax.swing.JScrollPane; import javax.swing.JFrame; import javax.swing.JOptionPane; import java.awt.*; import java.awt.event.*; public class JTableDemo extends JFram

  • 基于java实现斗地主代码实例解析

    斗地主 规则: 1. 组装54张扑克牌 2. 将54张牌顺序打乱 3. 三个玩家参与游戏,三人交替摸牌,每人17张牌,最后三张留作底牌. 4. 查看三人各自手中的牌(按照牌的大小排序).底牌 手中扑克牌从大到小的摆放顺序:大王,小王,2,A,K,Q,J,10,9,8,7,6,5, 4,3 分析: 准备牌: 完成数字与纸牌的映射关系: 使用双列Map(HashMap)集合,完成一个数字与字符串纸牌的对应关系(相当于一个字典). 洗牌: 通过数字完成洗牌发牌 发牌: 将每个人以及底牌设计为Array

  • java 实现回调代码实例

    JAVA实现回调 熟悉MS-Windows和X Windows事件驱动设计模式的开发人员,通常是把一个方法的指针传递给事件源,当某一事件发生时来调用这个方法(也称为"回调").Java的面向对象的模型目前不支持方法指针,似乎不能使用这种方便的机制. Java支持interface,通过interface可以实现相同的回调.其诀窍就在于定义一个简单的interface,申明一个被希望回调的方法. 例如,假定当某一事件发生时会得到通知,我们可以定义一个interface: public i

  • Java缓存池代码实例详解

    这篇实例中有四个类,分别为 CacheItem  缓存实体类 CachePool  缓存池 Student  学生实体类 MainTest  主测试类 其中,缓存实体类CacheItem  中存放管理学生实体对象Student  ,缓存实体类CacheItem  存放在缓存池CachePool  中,MainTest  主要负责整体的测试工作. 缓存实体类 package com.paic.zhangqi.cache; import java.util.Date; /** * 缓存实体 * @a

  • Java编程实现调用com操作Word方法实例代码

    实例代码如下: import com.jacob.activeX.ActiveXComponent; import com.jacob.com.Dispatch; import com.jacob.com.Variant; /** * jacob操作MSword类 * @author */ public class WordBean { // word文档 private Dispatch doc; // word运行程序对象 private ActiveXComponent word; //

随机推荐