java 关键字super
java关键字的使用
demo

java关键字的使用


super:可用来修饰属性、方法、构造器


当子类与父类中有同名的属性时，可用通过“super.此属性”显示调用父声明的属性。


若想调用子类的同名的属性“用this.属性”调用


当子类重写父类的方法以后，在子类中若想调用父类的方法，就需要显示调用父类中的方法，用“super.方法”


demo
public class Person {

	private String name;
	private int age;
	int id;//身份证
	...
	public void eat() {
		System.out.println("吃饭");
	}
}

public class Student extends Person {
	private String schoolName;
	private int id;//学号
	public Student(String schoolName, int id) {
		super();//调用父类的构造器结构，加载父类的属性
		this.schoolName = schoolName;
		this.id = id;
	}
	
	public void show() {
		//默认this.id
		System.out.println(this.id);		
		System.out.println(super.id);
	}
}

java关键字super
super用来引用直接父类对象，每当创建子类的实例时，父类的实例被隐式创建，由super关键字引用变量引用

1，用法

①引用直接父类的实例变量，调用直接父类方法
class Animals{
    String color = "red";
    void output(){
        System.out.println("this is father......");
    }
}
class Dog extends Animals{
    String color = "green";
    void output(){
        System.out.println("this is son.......");
        super.output();//调用父类方法
        System.out.println(color);
        System.out.println(super.color);//引用父类变量

    }

}
    public class ex {
        public static void main(String[] args) {
           Dog dog = new Dog();
           dog.output();
        }
    }

运行结果
this is son.......
this is father......
green
red

我觉得super调用直接父类的方法有种撤销子类函数覆盖的意思，函数覆盖之后想要是被覆盖了的父类函数显现出来，用到super关键字

②引用直接父类的构造函数
class Animals{
    Animals(){
        System.out.println("Father's constructor");
    }
}
class Dog extends Animals{
    Dog(){
        super();//若果没有这行代码，编译器也会自动的添加上
        System.out.println("Son's constructor");

    }

}
    public class ex {
        public static void main(String[] args) {
           Dog dog = new Dog();
        }
    }


运行结果
Father's constructor
Son's constructor

Process finished with exit code 0


当创建一个子类实例的时候，一定会隐式的创建一个父类实例，既然创建了父类实例，就一定得调用父类的构造函数，所以上例的super()；可写可不写，但注意，写了必须放在子类构造函数的第一行。

2，小实例应用

体会一下super的用法
class Student{
    String name;
    int id;
    Student(int id,String name){
        this.name = name;
        this.id = id;
    }
}
class MiddleStudent extends Student{
    int grade;
    MiddleStudent(int grade,int id,String name) {
        super(id,name);//此行代码必须要有
        this.grade = grade;
    }
}
    public class ex {
        public static void main(String[] args) {
           MiddleStudent s = new MiddleStudent(8,1234,"Mary");
           System.out.println(s.grade+" "+s.name+" "+s.id);
        }

    }


结果
8 Mary 1234

Process finished with exit code 0

java 关键字super详解
一、super关键字
在JAVA类中使用super来引用父类的成分，用this来引用当前对象，如果一个类从另外一个类继承，我们new这个子类的实例对象的时候，这个子类对象里面会有一个父类对象。怎么去引用里面的父类对象呢？使用super来引用，this指的是当前对象的引用，super是当前对象里面的父对象的引用。
1.1.super关键字测试
package cn.galc.test;
/**
* 父类
* @author gacl
*
*/
class FatherClass {
public int value;
public void f() {
value=100;
System.out.println("父类的value属性值="+value);
}
}
/**
* 子类ChildClass从父类FatherClass继承
* @author gacl
*
*/
class ChildClass extends FatherClass {
/**
* 子类除了继承父类所具有的valu属性外，自己又另外声明了一个value属性，
* 也就是说，此时的子类拥有两个value属性。
*/
public int value;
/**
* 在子类ChildClass里面重写了从父类继承下来的f()方法里面的实现，即重写了f()方法的方法体。
*/
public void f() {
super.f();//使用super作为父类对象的引用对象来调用父类对象里面的f()方法
value=200;//这个value是子类自己定义的那个valu，不是从父类继承下来的那个value
System.out.println("子类的value属性值="+value);
System.out.println(value);//打印出来的是子类自定义的那个value的值，这个值是200
/**
* 打印出来的是父类里面的value值，由于子类在重写从父类继承下来的f()方法时，
* 第一句话“super.f();”是让父类对象的引用对象调用父类对象的f()方法，
* 即相当于是这个父类对象自己调用f()方法去改变自己的value属性的值，由0变了100。
* 所以这里打印出来的value值是100。
*/
System.out.println(super.value);
}
}
/**
* 测试类
* @author gacl
*
*/
public class TestInherit {
public static void main(String[] args) {
ChildClass cc = new ChildClass();
cc.f();
}
}
运行结果：
1.2. 画内存分析图了解程序执行的整个过程
分析任何程序都是从main方法的第一句开始分析的，所以首先分析main方法里面的第一句话：
ChlidClass cc = new ChlidClass();
程序执行到这里时，首先在栈空间里面会产生一个变量cc，cc里面的值是什么这不好说，总而言之，通过这个值我们可以找到new出来的ChlidClass对象。由于子类ChlidClass是从父类FatherClass继承下来的，所以当我们new一个子类对象的时候，这个子类对象里面会包含有一个父类对象，而这个父类对象拥有他自身的属性value。这个value成员变量在FatherClass类里面声明的时候并没有对他进行初始化，所以系统默认给它初始化为0，成员变量(在类里面声明)在声明时可以不给它初始化，编译器会自动给这个成员变量初始化，但局部变量(在方法里面声明)在声明时一定要给它初始化，因为编译器不会自动给局部变量初始化，任何变量在使用之前必须对它进行初始化。
子类在继承父类value属性的同时，自己也单独定义了一个value属性，所以当我们new出一个子类对象的时候，这个对象会有两个value属性，一个是从父类继承下来的value，另一个是自己的value。在子类里定义的成员变量value在声明时也没有给它初始化，所以编译器默认给它初始化为0。因此，执行完第一句话以后，
接下来执行第二句话：
1 cc.f();
当new一个对象出来的时候，这个对象会产生一个this的引用，这个this引用指向对象自身。如果new出来的对象是一个子类对象的话，那么这个子类对象里面还会有一个super引用，这个super指向当前对象里面的父对象。所以相当于程序里面有一个this，this指向对象自己，还有一个super，super指向当前对象里面的父对象。
这里调用重写之后的f()方法，方法体内的第一句话：“super.f();”是让这个子类对象里面的父对象自己调用自己的f()方法去改变自己value属性的值，父对象通过指向他的引用super来调用自己的f()方法，所以执行完这一句以后，父对象里面的value的值变成了100。接着执行“value=200；”这里的vaule是子类对象自己声明的value，不是从父类继承下来的那个value。所以这句话执行完毕后，子类对象自己本身的value值变成了200。
方法体内的最后三句话都是执行打印value值的命令，前两句打印出来的是子类对象自己的那个value值，因此打印出来的结果为200，最后一句话打印的是这个子类对象里面的父类对象自己的value值，打印出来的结果为100。
到此，整个内存分析就结束了
感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

在 Java关键字(五)——this 中我们说 this 关键字是表示当前对象的引用。而 Java 中的 super 关键字则是表示 父类对象的引用。
我们分析这句话“父类对象的引用”，那说明我们使用的时候只能在子类中使用，既然是对象的引用，那么我们也可以用来调用成员属性以及成员方法，当然了，这里的 super 关键字还能够调用父类的构造方法。具体有如下几种用法：
1、调用父类的构造方法
Java中的继承大家都应该了解，子类继承父类，我们是能够用子类的对象调用父类的属性和方法的，我们知道属性和方法只能够通过对象调用，那么我们可以大胆假设一下：
在创建子类对象的同时，也创建了父类的对象，而创建对象是通过调用构造函数实现的，那么我们在创建子类对象的时候，应该会调用父类的构造方法。
下面我们看这段代码：
1 public classParent {2
3     publicParent(){4         System.out.println("父类默认无参构造方法");5 }6 }7
8
9 public class Son extendsParent {10
11     publicSon(){12         System.out.println("子类默认无参构造方法");13 }14 }
下面我们创建子类的对象：
1     public static voidmain(String[] args) {2         Son son = newSon();3     }
打印结果：
通过打印结果看到我们在创建子类对象的时候，首先调用了父类的构造方法，接着调用子类的构造方法，也就是说在创建子类对象的时候，首先创建了父类对象，与前面我们猜想的一致。
那么问题又来了：是在什么时候调用的父类构造方法呢？
红色框内的英文翻译为：如果声明的类是原始类Object，那么默认的构造函数有一个空的主体。否则，默认构造函数只是简单地调用没有参数的超类构造函数。
也就是说除了顶级类 Object.class 构造函数没有调用父类的构造方法，其余的所有类都默认在构造函数中调用了父类的构造函数(没有显式声明父类的子类其父类是 Object)。
那么是通过什么来调用的呢？我们接着看官方文档：
上面的意思大概就是超类构造函数通过 super 关键字调用，并且是以 super 关键字开头。
所以上面的 Son 类的构造方法实际上应该是这样的：
①、子类默认是通过 super() 调用父类的无参构造方法，如果父类显示声明了一个有参构造方法，而没有声明无参构造方法，实例化子类是会报错的。
1 public classParent {2
3     publicParent(String name){4         System.out.println("父类有参构造方法");5 }6 }7
8 public class Son extendsParent {9
10     publicSon(){11         System.out.println("子类默认无参构造方法");12 }13
14     public static voidmain(String[] args) {15         Son son = newSon();16 }17
18 }
上面代码是会报错的：
解决办法就是通过 super 关键字调用父类的有参构造方法：
1 public class Son extendsParent {2
3     publicSon(){4         super("Tom");5         System.out.println("子类默认无参构造方法");6 }7
8     public static voidmain(String[] args) {9         Son son = newSon();10 }11
12 }
注意看第 4 行代码，同理，多个参数也是这种调法。
2、调用父类的成员属性
1 public classParent {2     publicString name;3
4     publicParent(){5         System.out.println("父类默认无参构造方法");6 }7 }8
9 public class Son extendsParent {10
11     publicSon(){12         System.out.println("子类默认无参构造方法");13 }14
15     public voidprintName(){16         System.out.println(super.name);17 }18
19 }
第 16 行代码 super.父类属性  通过这种形式来调用父类的属性。
3、调用父类的方法
1 public classParent {2     publicString name;3
4     publicParent(){5         System.out.println("父类默认无参构造方法");6 }7
8     public voidsetName(String name){9         this.name =name;10 }11 }12
13 public class Son extendsParent {14
15     publicSon(){16         super();//1、调用父类构造函数
17         System.out.println("子类默认无参构造方法");18 }19
20     public voidprintName(){21         super.setName("Tom");//2、调用父类方法
22         System.out.println(super.name);//3、调用父类属性
23 }24
25     public static voidmain(String[] args) {26         Son son = newSon();27         son.printName();//Tom
28 }29
30 }
这个例子我们在子类中分别调用了父类的构造方法、普通方法以及成员属性。
4、this 和 super 出现在同一个构造方法中？
不能！！！
在上一篇博客对 this 关键字 的介绍中，我们知道能够通过 this 关键字调用自己的构造方法。而本篇博客介绍 super 关键字，我们知道了能够通过 super 调用父类的构造方法，那么这两个关键字能同时出现在子类的构造方法中吗？
①、假设 super() 在 this() 关键字的前面
首先通过 super() 调用父类构造方法，对父类进行一次实例化。接着调用 this() ，this() 方法会调用子类的构造方法，在子类的构造方法中又会对父类进行一次实例化。也就是说我们对子类进行一次实例化，对造成对父类进行两次实例化，所以显然编译器是不允许的。
1 public classParent {2     publicString name;3
4     publicParent(){5         System.out.println("父类默认无参构造方法");6 }7
8     publicParent(String name){9         System.out.println("父类有参构造方法");10 }11
12 }13
14 public class Son extendsParent {15
16     publicSon(){17         super();//1、调用父类构造函数
18         this("Tom");//2、调用子类构造方法
19         System.out.println("子类默认无参构造方法");20 }21
22     publicSon(String name){23         System.out.println("子类有参构造方法");24 }25
26 }
反过来 this() 在 super() 之前也是一样。
而且编译器有限定 this() 和 super() 这两个关键字都只能出现在构造方法的第一行，将这两个关键字放在一起，总有一个关键字在第二行，编译是不能通过的。