1 super是一个关键字,全部小写
2 super和this对比着学习
this:
-
this能出现在实例方法和构造方法中
-
this的语法是:“this.”、“this()”
-
this不能使用在静态方法中
-
this.大部分情况下是可以省略的
-
this.什么时候不能省略呢?在区分局部变量和实例变量的时候不能省略
public void setName(String name){
this.name = name;
} -
this()只能出现在构造方法第一行,通过当前的构造方法去调用“本类”中其他的构造方法,目的是:代码复用
super:
- super能出现在实例方法和构造方法中
- super的语法是:”super.“、”super()“
- super不能使用在静态方法中
- super.大部分情况下是可以省略的
- super.什么时候不能省略?
- super只能出现在构造方法第一行,通过当前的构造方法去调用”父类“中的构造方法,目的是:创建子类对象的时候,先初始化父类型特征。
3 super()
表示通过子类的构造方法调用父类的构造方法
模拟现实世界中这种场景,想要有儿子,需要先有父亲
4 重要的结论:
当一个构造方法第一行:
既没有this()又没有super()的话,默认会有一个super();
表示通过当前子类的构造方法调用父类的无参数构造方法
所以必须保证父类的无参数构造方法是存在的
5 注意:
this()和super()不能共存,它们都是只能出现在构造方法的第一行
6 无论是怎样折腾,父类的构造方法是一定会执行的(百分比的)
public class SuperTest01{
public static void main(String[] args){
// 创建子类对象
/*
A类的无参数构造方法!
B类的无参数构造方法!
*/
new B();
}
}
class A extends Object{
// 建议手动的将一个类的无参数构造方法写出来。
public A(){
//super(); // 这里也是默认有这一行代码的。
System.out.println("A类的无参数构造方法!");
}
// 一个类如果没有手动提供任何构造方法,系统会默认提供一个无参数构造方法。
// 一个类如果手动提供了一个构造方法,那么无参数构造系统将不再提供。
public A(int i){
//super();
System.out.println("A类的有参数构造方法(int)");
}
}
class B extends A{
/*
public B(){
super();
System.out.println("B类的无参数构造方法!");
}
*/
public B(){
this("zhangsan");
// 调用父类中有参数的构造方法
//super(123);
System.out.println("B类的无参数构造方法!");
}
public B(String name){
super();
System.out.println("B类的有参数构造方法(String)");
}
}
判断程序的输出结果
1
3
6
5
4
在java语言中不管是new什么对象,最后老祖宗的Object类的无参构造方法一定会执行。(Object类的的无参数构造方法是处于”栈顶部“)
栈顶的特点:
最后调用,但是最先执行结束
后进先出原则
大家要注意:
以后写代码的时候,一个类的无参数构造方法还是建议大家手动的写出来
如果无参数构造方法丢失的话,可能会影响到”子类对象的构建“
public static void main(String[] args){
new C();
}
}
/*
class Object{
public Object(){
}
}
*/
class A extends Object{
public A(){
System.out.println("1"); //1
}
}
class B extends A{
public B(){
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
}
}
-
举个栗子:在恰当的时间使用:super(实际参数列表);
-
注意:在构造方法执行过程中一连串调用了父类的构造方法,父类的构造方法又继续向下调用它的父类的构造方法,但是实际上对象只创建了一个
-
思考:”super(实参)“到底是干啥的?
super(实参)的作用是:初始化当前对象的父类型特证
并不是创建对象,实际上对象只创建了1个 -
super关键字代表什么呀?
super关键字代表的就是”当前对象“的那部分父类型特征
我继承了我父亲的一部分特征:
例如:眼睛、皮肤等。
super代表的就是”眼睛、皮肤等“。
”眼睛、皮肤等“虽然是继承了父亲的,但这部分是在我身上呢。
// 测试程序
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;
}
}
super的原理
public class SuperTest04{
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;
}
}
class Vip extends Customer{
public Vip(){}
public Vip(String name){
super(name);
}
// super和this都不能出现在静态方法中。
public void shopping(){
// this表示当前对象。
System.out.println(this.name + "正在购物!");
// super表示的是当前对象的父类型特征。(super是this指向的那个对象中的一块空间。)
System.out.println(super.name + "正在购物!");
System.out.println(name + "正在购物!");
}
}
super关键字的理解
1、“this.”和“super.”大部分情况下都是可以省略的。
2、this. 什么时候不能省略?
public void setName(String name){
this.name = name;
}
3、super. 什么时候不能省略?
父中有,子中又有,如果想在子中访问“父的特征”,super. 不能省略。
public class SuperTest05{
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!");
}
}
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 正在购物
System.out.println(super.name + "正在购物!"); // 张三正在购物
System.out.println(name + "正在购物!"); //null 正在购物
}
}
superTest05内存图
通过以下这个测试得出结论:
super不是引用。super也不不保存内存地址,super也不指向任何对象
super只是代表当前内部的那一块父类型的特征
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();
// main方法是静态的
// 错误的。
/*
System.out.println(this);
System.out.println(super.xxxx);
*/
}
}
在父和子中有同名的属性,或者说有相同的方法
如果此时想在子类中访问父中的数据,必须使用”super.“加以区分
super.属性名【访问父类的属性】
super.方法名(实参)【访问父类的方法】
super(实参)【调用父类的构造方法】
public class SuperTest07{
public static void main(String[] args){
/*
Cat move!
Cat move!
Animal move!
*/
Cat c = new Cat();
c.yiDong();
}
}
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();
// super. 不仅可以访问属性,也可以访问方法。
super.move();
}
}
重点以及结论
super的用法:super. 和 super()
super. 大部分可以省略,当父子都有相同的属性和方法时,
在子类中访问父类的特征时,必须使用super.
一个构造方法第一行啥也没有,自动会有一个super()
super不能出现在静态方法中,只能是实例方法。
super()是干啥的:是通过子类的构造方法调用父类的构造方法。
下一篇:final