精华内容
下载资源
问答
  • Java super关键字使用

    2017-05-16 15:44:36
    Java super关键字使用demo
  • 主要介绍了java Super 用法详解及实例代码的相关资料,需要的朋友可以参考下
  • 主要介绍了Java super关键字的使用方法详解的相关资料,希望通过本文能帮助到大家,让大家对super关键字彻底掌握,需要的朋友可以参考下
  • Java super关键字(超详细!)

    千次阅读 多人点赞 2021-04-20 19:13:00
    1.什么是supersuper是一个关键字,全部小写。 2.怎么学?super和this对比着学习。 this: this能出现在实例方法和构造方法中。 this的语法是:“this.”、“this()” this 不能 使用在静态方法中。 this. 大部分...

    1.什么是super?

    super是一个关键字,全部小写。

    2.怎么学?super和this对比着学习。

    this:

    1. this能出现在实例方法构造方法中。
    2. this的语法是:“this.”、“this()
    3. this 不能 使用在静态方法中。
    4. this. 大部分情况下是可以省略的。
    5. this.什么时候不能省略呢? 在区分局部变量和实例变量的时候不能省略。

    eg.

    public void setName(String name){
    	this.name = name;
    }
    
    1. this() 在构造方法里,只能出现在构造方法第一行,通过当前的构造方法去调用“本类”中其它的构造方法
      目的是:代码复用

    2021.07.07补充:(感谢 “迷~麟” 指出错误)

    1. this.”可以引用本类的属性方法

    2. this” 可以作为函数的返回值。

    eg.

    //重新JList渲染类(部分代码)
    
    private rolecolor = red;
    
    public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
    
        super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
        
           if (isSelected) {
               setBackground(this.rowcolor);
               setFont(getFont().deriveFont((float) (getFont().getSize() + 2)));
           }
            
        return this;//返回当前JList对象
    }
    

    super:

    1. super能出现在实例方法构造方法中。
    2. super的语法是:“super.”、“super()

    2.1 super()

        2.1.1 在恰当的时间使用:super(实际参数列表);

        2.1.2 注意:在构造方法执行过程中一连串调用了父类的构造方法,父类的构造方法又继续向下调用它的父类的构造方法,但是实际上对象只 创建了一个

        2.1.3 “super(实参)”到底是干啥的?

    super(实参)的作用是:初始化当前对象的父类型特征
    并不是创建新对象。实际上对象只创建了1个。

        2.1.4 super关键字代表什么呀?

    super关键字代表的就是“当前对象”的那部分父类型特征

    eg.

    public class SuperTest03{
    	public static void main(String[] args){
    
    		CreditAccount ca1 = new CreditAccount();
    		System.out.println(ca1.getActno() + "," + ca1.getBalance() + "," + ca1.getCredit());
    
    		CreditAccount ca2 = new CreditAccount("1111", 10000.0, 0.999);
    		System.out.println(ca2.getActno() + "," + ca2.getBalance() + "," + ca2.getCredit());
    
    	}
    }
    
    // 账户
    class Account extends Object{
    	// 属性
    	private String actno;
    	private double balance;
    
    	// 构造方法
    	public Account(){
    	//默认有以下代码
    		//super();
    		//this.actno = null;
    		//this.balance = 0.0;
    	}
    	public Account(String actno, double balance){
    		// super();
    		this.actno = actno;
    		this.balance = balance;
    	}
    
    	// setter and getter
    	public void setActno(String actno){
    		this.actno = actno;
    	}
    	public String getActno(){
    		return actno;
    	}
    	public void setBalance(double balance){
    		this.balance = balance;
    	}
    	public double getBalance(){
    		return balance;
    	}
    }
    
    // 信用账户
    class CreditAccount extends Account{
    
    	// 属性:信誉度(诚信值)
    	// 子类特有的一个特征,父类没有。
    	private double credit;
    
    	// 构造方法
    	// 分析以下程序是否存在编译错误????
    	public CreditAccount(String actno, double balance, double credit){
    
    		// 私有的属性,只能在本类中访问。
    		/*
    		this.actno = actno;
    		this.balance = balance;
    		*/
    
    		// 以上两行代码在恰当的位置,正好可以使用:super(actno, balance);
    		// 通过子类的构造方法调用父类的构造方法。
    		super(actno, balance);
    		this.credit = credit;
    	}
    
    	// 提供有参数的构造方法
    	public CreditAccount(){
    		//super();
    		//this.credit = 0.0;
    	}
    
    	// setter and getter方法
    	public void setCredit(double credit){
    		this.credit = credit;
    	}
    	public double getCredit(){
    		return credit;
    	}
    	
    }
    

    内存图:
    在这里插入图片描述

    2.2 super.

    1. super 不能 使用在静态方法中。
    2. super. 大部分情况下是可以省略的。
    3. super.什么时候不能省略呢?
      父中有,子中又有,如果想在中访问“父的特征”,super. 不能省略。
      父和子中同名属性,或者说有相同方法
      如果此时想在子类中访问父中的数据,必须使用“super.”加以区分。

    eg1.

    class Animal{
    	public void move(){
    		System.out.println("Animal move!");
    	}
    }
    
    class Cat extends Animal{
    	// 对move进行重写。
    	public void move(){
    		System.out.println("Cat move!");
    	}
    
    	// 单独编写一个子类特有的方法。
    	public void yiDong(){
    		this.move();//子类的move
    		//前面不写默认有this.
    		move();//子类的move
    		// super. 不仅可以访问属性,也可以访问方法。
    		super.move();//父类的move
    	}
    }
    

    eg2.

    public class Super{
    	public static void main(String[] args){
    		Vip v = new Vip("张三");
    		v.shopping();
    	}
    }
    class Customer {
    	String name;
    	public Customer(){}
    	public Customer(String name){
    		super();
    		this.name = name;
    	}
    
    	public void doSome(){
    		System.out.println(this.name + " do some!");
    		System.out.println(name + " do some!");
    		//错误: 找不到符号
    		//System.out.println(super.name + " do some!");//Object类没有name属性
    	}
    }
    class Vip extends Customer{
    
    	// 假设子类也有一个同名属性
    	// java中允许在子类中出现和父类一样的同名变量/同名属性。
    	String name; // 实例变量
    
    	public Vip(){
    	}
    	public Vip(String name){
    		super(name);
    		// this.name = null;
    	}
    	public void shopping(){
    		/*
    			java是怎么来区分子类和父类的同名属性的?
    				this.name:当前对象的name属性
    				super.name:当前对象的父类型特征中的name属性。
    		*/
    		System.out.println(this.name + "正在购物!"); // null 正在购物  子类的name
    		System.out.println(super.name + "正在购物!"); // 张三正在购物   父类的name
    		System.out.println(name + "正在购物!"); //null 正在购物   子类的name
    	}
    }
    
    

    内存图:
    在这里插入图片描述

    1. super() 只能出现在构造方法第一行,通过当前的构造方法去调用“父类”中的构造方法
      目的是:创建子类对象的时候,先初始化父类型特征

    3.1 super()

    表示通过子类的构造方法调用父类的构造方法。

    模拟现实世界中的这种场景:要想有儿子,需要先有父亲。

    3.重要的结论:

    3.1 当一个构造方法第一行:既没有this()又没有super()的话,默认会有一个super();

    表示:通过当前子类的构造方法调用父类的无参数构造方法。
    所以必须保证父类的无参数构造方法是存在的。

    3.2 在java语言中不管是是new什么对象,最后老祖宗的Object类无参数构造方法一定会执行。(Object类的无参数构造方法是处于“栈顶部”)

    4. 注意:

    4.1 this()super() 不能共存,它们都是只能出现在构造方法第一行。

    4.2 无论是怎样折腾,父类的构造方法是一定会执行的。(百分百)

    4.3 结论

    • this是引用。this也保存内存地址,this也指向任何对象
    • super 不是引用。super也不保存内存地址,super也不指向任何对象
      super 只是代表当前对象内部的那一块父类型的特征。

    eg.

    public class SuperTest06 {
    
    	// 实例方法
    	public void doSome(){
    		// SuperTest06@2f92e0f4
    		System.out.println(this);
    		// 输出“引用”的时候,会自动调用引用的toString()方法。
    		//System.out.println(this.toString());
    
    		//编译错误: 需要'.'
    		//System.out.println(super);
    	}
    
    	// this和super不能使用在static静态方法中。
    	/*
    	public static void doOther(){
    		System.out.println(this);
    		System.out.println(super.xxx);
    	}
    	*/
    
    	// 静态方法,主方法
    	public static void main(String[] args){
    		SuperTest06 st = new SuperTest06();
    		st.doSome();
    	}
    }
    

    eg.

    public class Super{
    	public static void main(String[] args){
    		new C();
    
    	}
    }
    
    /*
    class Object{
    	public Object(){	
    	}
    }
    */
    
    //不写默认继承Object
    class A /*extends Object*/{
    	public A(){
    		//默认有super();不写默认存在;调用Object构造方法
    		super();
    		System.out.println("1"); //1
    	}
    }
    
    class B extends A{
    	public B(){
    		//默认有super();不写默认存在;调用Object构造方法
    		super();
    		System.out.println("2"); //2
    	}
    	public B(String name){
    		super();
    		System.out.println("3"); // 3
    	}
    }
    
    class C extends B{
    	public C(){ // 这个是最先调用的。但是最后结束。
    		this("zhangsan");
    		System.out.println("4");//4
    	}
    	public C(String name){
    		this(name, 20);
    		System.out.println("5");//5
    	}
    	public C(String name, int age){
    		super(name);
    		System.out.println("6");//6
    	}
    }
    

    5.结论

    • super.属性名 【访问父类的属性】
    • super.方法名(实参) 【访问父类的方法】
    • super(实参) 【调用父类的构造方法】
    展开全文
  • java super()方法的使用

    2010-06-21 14:47:00
    java super()方法的使用 java super()方法的使用
  • java super关键字

    千次阅读 2019-02-20 17:32:16
    java中有很多关键字,我们需要掌握和理解这些关键字怎么使用,这样我们才可以写出更健壮和高效的程序,这篇文章主要来说一下java中的关键字supersuper关键字有两种用途,分别是: 可以使用super关键字来访问...

    在java中有很多关键字,我们需要掌握和理解这些关键字怎么使用,这样我们才可以写出更健壮和高效的程序,这篇文章主要来说一下java中的关键字super。super关键字有两种用途,分别是:

    1. 可以使用super关键字来访问父类的成员

    如果你的子类重写了父类中的方法,你可以通过使用super关键字来回调父类中被重写的方法。你也可以使用super关键字来查询一个隐藏域。考虑下面这两个类,父类SuperClass和子类SubClass:

    package com.java8.learn;
    
    public class SuperClass {
    
        public void printMethod(){
            System.out.println("superClass printMethod");
        }
    }
    
    
    package com.java8.learn;
    
    public class SubClass extends SuperClass {
        @Override
        public void printMethod() {
            super.printMethod();
            System.out.println("subClass printMethod");
        }
    
        public static void main(String[] args){
            SubClass subClass = new SubClass();
            subClass.printMethod();
        }
    }
    
    

    控制台输出结果:

    superClass printMethod
    subClass printMethod
    

    从上面的程序运行结果可以看出,创建SubClass的对象并调用了该类中的printMethod方法,而该方法中又使用了super关键字调用了父类中的printMethod方法,所以最终的打印结果如上图所示。

    1. 可以使用super关键字来访问父类的构造方法

    通过使用super关键字调用父类的构造方法必须在子类构造方法的第一行。可以是调用无参的super();也可以是调用父类有参数的构造方法super(parameter,list);

    如果构造函数未显式调用超类构造函数,则Java编译器会自动插入对超类的无参数构造函数的调用。 如果超类没有无参数构造函数,则会出现编译时错误。

    在这里插入图片描述

    展开全文
  • Java super继承

    千次阅读 2019-06-09 14:34:31
    super关键字 super的用法和this很像 this代表本类对应的引用。 super代表父类存储空间的标识(可以理解为父类引用) 用法(this和super均可如下使用) 访问成员变量 this.成员变量 super.成员变量 访问构造方法(子...

    super关键字

    super的用法和this很像

    1. this代表本类对应的引用。
    2. super代表父类存储空间的标识(可以理解为父类引用)

    用法(this和super均可如下使用)

    1. 访问成员变量

    this.成员变量 super.成员变量

    1. 访问构造方法(子父类的构造方法问题讲)

    this(…) super(…)

    1. 访问成员方法(子父类的成员方法问题讲)

    this.成员方法() super.成员方法()

    子类中所有的构造方法默认都会访问父类中空参数的构造方法:

    1. 因为子类会继承父类中的数据,可能还会使用父类的数据。所以,子类初始化之前,一定要先完成父类数据的初始化
    2. 每一个构造方法的第一条语句默认都是:super()

    继承中构造方法的关系

    如果父类中没有构造方法

    1. 子类通过super去显示调用父类其他的带参的构造方法
    2. 子类通过this去调用本类的其他构造方法

    本类其他构造也必须首先访问了父类构造

    1. super(…)或者this(….)必须出现在第一条语句山

    否则,就会有父类数据的多次初始化

    例子:

    class Father{
    			public Father(){
    				System.out.println("Father的无参构造方法");
    			}
    			public Father(String name){
    				System.out.println("Father的带参构造方法");
    			}
    		}
    		class Son extends Father{
    			public Son(){
    				System.out.println("Son的无参构造方法");
    			}
    			public Son(String name){
    				System.out.println("Son的带参构造方法");
    			}
    		}

    继承中成员方法的关系

    通过子类对象去访问一个方法,首先在子类中找,然后在父类中找,如果还是没有就报错。(不考虑父亲的父亲…)

    方法重写概述

    1. 子类中出现了和父类中一模一样的方法声明,也被称为方法覆盖,方法复写。
    2. 使用特点:

    如果方法名不同,就调用对应的方法

    如果方法名相同,最终使用的是子类自己的

    方法重写的应用:

    当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容。

    方法重写的注意:

    1. 父类中私有方法不能被重写
    2. 子类重写父类方法时,访问权限不能更低
    3. 父类静态方法,子类也必须通过静态方法进行重写。

    final关键字

    final关键字是最终的意思,可以修饰类,成员变量,成员方法。

    1. 修饰类,类不能被继承
    2. 修饰变量,变量就变成了常量,只能被赋值一次
    3. 修饰方法,方法不能被重写

    final修饰局部变量

    1. 在方法内部,该变量不可以被改变
    2. 在方法声明上,分别演示基本类型和引用类型作为参数的情况

    基本类型,是值不能被改变

    引用类型,是地址值不能被改变

    1. final修饰变量的初始化时机

    在对象构造完毕前即可

    使用final方法的原因有两个。第一个原因是把方法锁定,以防任何继承类修改它的含义;第二个原因是效率。

    总结:把多个类中相同的成员给提取出来定义到一个独立的类中。然后让这个类和该独立的类产生一个关系,这个类就具备了这些内容,这个关系叫继承。

     

    展开全文
  • 主要介绍了Java super和this的对比及使用的相关资料,java中this与super会经常在使用的时候混淆,需要的朋友可以参考下
  • Java super关键字详解

    万次阅读 多人点赞 2016-07-15 17:14:48
    一.super关键字作用 1:主要存在于子类方法中,用于指向子类对象中父类对象。 2:访问父类的属性 3:访问父类的函数 4:访问父类的构造函数 二.super注意的地方 this和super很像,this指向的是当前对象的调用,...

    一.super关键字作用

    1:主要存在于子类方法中,用于指向子类对象中父类对象。

    2:访问父类的属性

    3:访问父类的函数

    4:访问父类的构造函数

    二. super注意的地方

    thissuper很像,this指向的是当前对象的调用,super指向的是当前调用对象的父类。类加载完毕,创建对象,父类的构造方法会被调用(默认自动无参),然后执行子类相应构造创建了一个子类对象,该子类对象还包含了一个父类对象。该父类对象在子类对象内部。this super只能在有对象的前提下使用,不能在静态上下文使用。

    三.super关键字的使用

    1.子类的构造函数默认第一行会默认调用父类无参的构造函数,隐式语句

    super();

    Son(int y) {
    		//super();隐式语句
    		this.y = y + x;
    		System.out.println("这是子类的有参构造");
    	}

    2.子类显式调用父类构造函数

    在子类构造函数第一行通过super关键字调用父类任何构造函数。如果显式调用父类构造函数,编译器自动添加的调用父类无参数的构造就消失。构造函数间的调用只能放在第一行,只能调用一次。super()this()不能同时存在构造函数第一行。

    Son(int y) {
    		super(y);// 子类显式调用父类构造函数
    		this.y = y + x;
    		System.out.println("这是子类的有参构造");
    	}
    四.super思考

    如果开发者自定义了一个类,没有显示的进行类的继承,那么该类中成员函数是否可以使用super关健健字?可以使用,继承了Object类,Object类是所有类的父类。

    class Demo7 {
    	public  void print(){
    		System.out.println(super.toString());
    	}
    	public static void main(String[] args){
    		new Demo7().print();
    		System.out.println();
         	}
    }


    展开全文
  • Java读写CSV之SuperCSV

    2019-04-06 01:24:27
    NULL 博文链接:https://rensanning.iteye.com/blog/1552053
  • 由于子类不能继承父类的构造方法,因此,要调用父类的构造方法,必须在子类的构造方法体的第一行使用 super() 方法。该方法会调用父类相应的构造方法来完成子类对象的初始化工作。 在以下情况下需要使用 super ...
  • super-csv:一个快速、程序员友好、开源的CSV读写Java
  • Java super关键字用法

    千次阅读 2015-03-20 14:02:15
    分别介绍了在构造方法和非构造方法中super关键字的四种不同的用法。
  • 主要介绍了java 关键字super详解及用法的相关资料,需要的朋友可以参考下
  • Javasuper()方法

    千次阅读 2019-11-26 12:03:11
    super()方法:(直接父类对象的引用。可以通过super.*来访问和调用父类中被子类覆盖(重写)的方法或属性) 自动生成构造方法第一句总为super();(写或不写都会有,系统自动加)来调用父类的构造方法(一直追溯到Object...
  • javasuper的三种用法

    万次阅读 多人点赞 2019-07-11 21:12:56
    javasuper的用法 super只在子类中出现 super有三种用法 【1】 super.xxx; xxx可以是类的属性。 例如super.name;即从子类中获取父类name属性的值 【2】 super.xxx(); xxx()可以是类中的方法名。 super.xxx();的意义...
  • Javasuper()的使用

    万次阅读 多人点赞 2018-09-12 22:10:18
    1.super()的使用实例 一一一子类重写父类的方法 2.super()的使用实例 一一一子类重写父类的变量 3.super()的使用实例 一一一在子类的构造方法中  4.关于构造方法中super() 第一种情况:编译不通过 第二种情况...
  • Javasuper关键字及super()的使用

    万次阅读 多人点赞 2020-07-06 22:52:15
    super关键字的使用: (1)super是一个关键字; (2)super和this很类似,我们对比着学习。 先复习一下this关键字的使用。 this关键字: this能出现在实例方法和构造方法中; this的语法是“this.”和“this()”; ...
  • Java中的super关键字

    万次阅读 多人点赞 2018-05-18 11:20:04
    本文重点介绍super关键字,在Java中的作用以及用法。一、定义 它是一个指代变量,用于在子类中指代父类对象。二、应用2.1 应用范围 只能用于构造函数和实例方法中,不能用于类(静态)方法中。原因是super指代的...
  • java super 和 this 关键字的区分和使用

    千次阅读 多人点赞 2018-10-10 16:07:46
    java super 和 this 关键字的区分和使用 在java类中使用super来调用父类中的指定操作: super可用于访问父类中定义的属性 super可用于调用父类中定义的成员方法 super可用于在子类构造方法中调用父类的构造器 ...
  • Java 常识(013):Java中的super关键字

    千次阅读 2019-08-10 23:39:00
    文章目录1、Javasuper 是什么2、为什么要用 super 关键字3、Javasuper 的用法3.1、使用 super 调用父类的构造方法3.2、引用父类实例变量3.3、调用父类方法4、super 关键字与 this 关键字的区别 1、Java 中 ...
  • javasuper关键字的三种用法
  • Java编程中super关键字的用法

    千次阅读 2016-11-29 23:02:14
    详解Java编程中super关键字的用法 作者:孤傲苍狼 字体:[增加 减小] 类型:转载 时间:2015-10-19 我要评论 这篇文章主要介绍了Java编程中this与super关键字的用法,包括从内存结构方面分析super的作用域,需要的...
  • Javasuper函数的用法

    千次阅读 2020-05-18 20:53:37
    super指代变量,用于在子类中指代父类对象。 三种用法: 访问父类的方法。 调用父类构造方法。 访问父类中的隐藏成员变量。 常用的是访问父类方法,且参数个数类型必须一致 class A{ int x,y; A(int x,int y){ ...
  • Java super关键字(android中常见)

    千次阅读 2015-10-06 10:45:19
    super在android中比较常见,没有java基础也并不理解,所以空出时间学习了一下。 在Java类中使用super来引用基类的成分,比较简单,示例如下: class FatherClass{ public int value; public void f(){ value...
  • 1.JAVAsuper关键字的使用

    千次阅读 2019-09-09 00:16:29
    1.super()的使用示例——子类重写,调用父类方法 public class A { private String nameA="父"; public void getName() { System.out.println("父类:"+nameA); } public static void main(String[] ...
  • Java中关于super关键字的作用

    万次阅读 2019-01-07 20:57:52
    在子类继承父类中,一般有一行super的语句,需要记住三种使用方法: 1、super.变量/对象名; 使用这种方法可以直接访问父类中的变量或对象,进行修改赋值等操作 2、super.方法名(); 直接访问并调用父类中的方法 3、...
  • 3."超"关键字(super keyword) Super是一个参考(或说指针)指向他紧邻的父类(见下面的例子)。 用super可以指向被隐藏的父类的同名成员。 3.1 super指向父类的成员 注意: 下例中:子类和父类都有i,我们一共有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,024,732
精华内容 409,892
关键字:

javasuper

java 订阅