第十四章 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(实参)【调用父类的构造方法】
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 目录名
# 1 super
### 1.1 super概述
```java1、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 子类构造执行时必然调用父类的构造方法
```java/*判断程序的输出结果：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
```java/*举个例子：在恰当的时间使用：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 getterpublic 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
```javapublic 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."什么时候不能省略
```java/*1、“this.”和“super.”大部分情况下都是可以省略的。
2、“this.”什么时候不能省略？public void setName(String name){this.name = name;}
3、“super.”什么时候不能省略？父类中有，子类中又有，如果想在子类中访问“父类中的特征”，“super.”不能省略。
4、java是怎么区分子类和父类的同名属性的？this.name: 当前对象的namesuper.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使用时后面必须有个点
```java/*通过这个测试得出的结论：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调用父类的方法
```java/*在父类和子类中有同名的属性，或者说有相同的方法，如果此时想在子类中访问父类的数据，必须使用“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关键字
```javasuper能出现在实例方法和构造方法中。
super的语法是：“super.”、“super()”
super不能使用在静态方法中。
super. 大部分情况下是可以省略的。父类和子类中有同名属性，或者说有同样的方法，想在子类中访问父类的，super. 不能省略。
super() 只能出现在构造方法第一行，通过当前的构造方法去调用“父类”中的构造方法，目的是：创建子类对象的时候，先初始化父类型特征。
super的使用：super.属性名【访问父类的属性】super.方法名（实参） 【访问父类的方法】super(实参)【调用父类的构造方法】```
# ps
### 1 cmd命令中操作文件相关的命令
```java1 创建一个空文件copy nul 文件名例如：copy nul a.txt2 创建一个有内容的文件echo 内容 > 文件名例如：echo aaa > b.txt3 在原有的内容文件中继续添加内容echo 内容 >> 文件名例如：echo bbb >> b.txt4 删除文件del 文件名例如：del a.txt5 修改文件名ren 原文件名 新文件名例如：ren a.txt aaa.txt6 查看文件内容type 文件名例如：type a.txt```
### 2 1 cmd命令中操作文件夹相关的命令
```java1 切换目录cd2 切换盘符盘符: + 回车例如: c: + 回车
2 查看当前目录下的子目录和文件dir3 创建文件夹/目录md 目录名例如：md 图片4 删除空目录rd 目录名例如：rd 图片5 删除非空目录rd /s /q 目录名 // /s是删除当前目录以及当前目录下的所有目录和文件，/q是安静的删除6 修改目录名ren 原目录 新目录7 查看目录名dir 目录名```
标签：name,构造方法,关键字,第十四章,println,super,public,String 来源： https://www.cnblogs.com/jingxian666/p/16477685.html