第十四章 super关键字

1 super

1.1 super概述

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()不能共存，它们都是只能出现在构造方法第一行。 
​
​
public class SuperTest01{
public static void main(String[] args){
// 创建子类对象
/*
A类的无参构造方法
B类的无参构造方法
*/
new B();
}
}
​
class A{
// 建议手动的将一个类的无参构造方法写出来。 
/*
public A(){
System.out.println("A类的无参构造方法");
}
*/
​
// 一个类如果没有提供构造任何构造方法，系统会默认提供一个无参构造方法。 
// 一个类如果手动提供了一个构造方法，那么无参数构造系统将不再提供。
public A (int i){
System.out.println("A类的有参数构造方法(int)");
}
}
​
class B extends A{
public B(){
this("zhangsan");
// 调用父类中有参数的构造方法
// super(123);
System.out.println("B类的无参构造方法");
}
​
public B(String name){
super();
System.out.println("B类的有参数构造方法(String)");
}
}
​

 

1.2 子类构造执行时必然调用父类的构造方法

​
/*
判断程序的输出结果：
A类的无参数构造执行
B类的有参数构造执行(String)
C类的有参数构造执行(String, int)
C类的有参数构造执行(String)
C类的无参数构造执行
​
在java语言中不管是new什么对象，最后Object类的无参构造方法一定会执行。（Object类的无参数构造方法是处于“栈顶部”）
​
栈顶部的特点：
最后调用，但是最先执行结束。
后进先出原则。
*/
​
public class SuperTest02{
public static void main(String[] args){
new C();
}
}
​
class A{
public A(){
System.out.println("A类的无参数构造执行");
}
}
​
class B extends A{
public B(){
super();
System.out.println("B类的无参数构造执行");
}
​
public B(String name){
System.out.println("B类的有参数构造执行(String)");
}
}
​
class C extends B{
public C(){
this("zhangsan");
System.out.println("C类的无参数构造执行");
}
​
public C(String name){
this(name, 20);
System.out.println("C类的有参数构造执行(String)");
}
​
public C(String name, int age){
super(name);
System.out.println("C类的有参数构造执行(String, int)");
}
}
​

 

1.3 super(实参)的用法1

​
/*
举个例子：在恰当的时间使用：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("111111", 10000000.0, 0.99);
System.out.println(ca2.getActno() + "," + ca2.getBalance() + "," + ca2.getCredit());
​
}
}
​
// 账户
class Account{  
// 属性
private String actno;
private double balance;
​
// 构造方法
public Account(){}
public Account(String actno, double balance){
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(){
}
public CreditAccount(String actno, double balance, double credit){
// 私有的属性，只能在本类中访问。
/*
this.actno = actno;
this.balance = balance;
*/
​
// 以上的两行代码在恰当的位置，正好可以使用：super(actno, balance);
// 通过子类的构造方法调用父类的构造方法。
super(actno, balance);
this.credit = credit;
}
​
// settter and getter方法
public void setCredit(double credit){
this.credit = credit;
}
public double getCredit(){
return credit;
}
}
​

 

1.4 super(实参)的用法2

​
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){
this.name = name;
}
}
​
class Vip extends Customer{
​
public Vip(){}
public Vip(String name){
super(name);
}
​
public void shopping(){
System.out.println(this.name + "正在购物");
System.out.println(super.name + "正在购物");
System.out.println(name + "正在购物");
}
}
​

 

1.5 "super."什么时候不能省略

​
/*
1、“this.”和“super.”大部分情况下都是可以省略的。
​
2、“this.”什么时候不能省略？
public void setName(String name){
this.name = name;
}
​
3、“super.”什么时候不能省略？
父类中有，子类中又有，如果想在子类中访问“父类中的特征”，“super.”不能省略。
​
4、java是怎么区分子类和父类的同名属性的？
this.name: 当前对象的name
super.name: 当前对象的父类型特征中的name特征
*/
​
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){
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(){
System.out.println(this.name + "正在购物");  // null正在购物
System.out.println(super.name + "正在购物");  // 张三正在购物
System.out.println(name + "正在购物");  // null正在购物
}
}
​

 

1.6 super使用时后面必须有个点

​
/*
通过这个测试得出的结论：
super 不是引用。super也不保存内存地址，super也不指向任何对象。
super 只是代表当前对象的内部的那一块父类型的特征。
*/
​
public class SuperTest06{
​
// 实例方法
public void doSome(){
System.out.println(this);  // SuperTest06@24d46ca6
// 输出“引用”的时候，会自动调用“引用”的toString()方法。
// System.out.println(this.toString());
​
// 编译错误：需要'.'
// System.out.println(super);
}
​
// this和super不能使用在静态方法中。
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.xxx);
*/

}
}
​

 

1.7 使用super调用父类的方法

​
/*
在父类和子类中有同名的属性，或者说有相同的方法，
如果此时想在子类中访问父类的数据，必须使用“super.”加以区分。
​
super.属性名  【访问父类的属性】
super.方法名()  【访问父类的方法】
super(实参)  【调用父类的构造方法】
*/
​
public class SuperTest07{
public static void main(String[] args){
​
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();
}
}
​

 

1.8 super关键字

super能出现在实例方法和构造方法中。
​
super的语法是：“super.”、“super()”
​
super不能使用在静态方法中。
​
super. 大部分情况下是可以省略的。
父类和子类中有同名属性，或者说有同样的方法，
想在子类中访问父类的，super. 不能省略。
​
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。
​
super的使用：
super.属性名【访问父类的属性】
super.方法名（实参）  【访问父类的方法】
super(实参)【调用父类的构造方法】

 

2 day16作业

​
/*
    猜数字游戏
        一个类A有一个实例变量v，从键盘接收一个正整数作为实例变量v的初始值。
        另外再定义一个类B，对A类的实例变量v进行猜测。
            如果大了则提示大了
            小了就提示小了
            等于则提示猜测成功
*/
​
public class Test01{
    public static void main(String[] args){
        // 创建A对象
        A a = new A(100);
​
        // 创建B对象
        B b = new B(a);
​
        // 开始猜测
        java.util.Scanner s = new java.util.Scanner(System.in);
        while(true){
            System.out.print("请输入要猜测的数字: ");
            int caiCeNum = s.nextInt();
            b.cai(caiCeNum);
        }
​
    }
}
​
class A{
    private int v;
​
    public A(){}
    public A(int v){
        this.v = v;
    }
​
    public void setV(int v){
        this.v = v;
    }
    public int getV(){
        return v;
    }
}
​
class B{
​
    // 把A作为B的实例变量
    private A a;
​
    public B(){}
    public B(A a){
        this.a = a;
    }
​
    public void setA(A a){
        this.a = a;
    }
    public A getA(){
        return a;
    }
​
    // 猜测的方法
    public void cai(int caiCeNum){
        // 实际数字
        // int shiJiZhi = this.getA().getV();
        int shiJiZhi = a.getV();
        if(caiCeNum == shiJiZhi){
            System.out.println("猜对了");
            // 终止程序的执行
            // 退出JVM
            System.exit(0);  // 退出JVM
        }else if(shiJiZhi > caiCeNum){
            System.out.println("猜小了");
        }else{
            System.out.println("猜大了");
        }
​
    }
}
​

 

ps

1 cmd命令中操作文件相关的命令

1 创建一个空文件
copy nul 文件名
例如：copy nul a.txt

2 创建一个有内容的文件
echo 内容 > 文件名
例如：echo aaa > b.txt

3 在原有的内容文件中继续添加内容
echo 内容 >> 文件名
例如：echo bbb >> b.txt

4 删除文件
del 文件名
例如：del a.txt

5 修改文件名
ren 原文件名 新文件名
例如：ren a.txt aaa.txt

6 查看文件内容
type 文件名
例如：type a.txt

 

2 1 cmd命令中操作文件夹相关的命令

1 切换目录
cd

2 切换盘符
盘符: + 回车
例如: c: + 回车
​
2 查看当前目录下的子目录和文件
dir

3 创建文件夹/目录
md 目录名
例如：md 图片

4 删除空目录
rd 目录名
例如：rd 图片

5 删除非空目录
rd /s /q 目录名  // /s是删除当前目录以及当前目录下的所有目录和文件，/q是安静的删除

6 修改目录名
ren 原目录 新目录

7 查看目录名
dir 目录名