super()的使用：当父类对象为私有时，子类可以通过自己的构造函数
第一行写上super(实参);，通过父类中含有私有对象的构造函数执行过程来完成属性的赋值，即初始化父类型特征
1.super是一个关键字，全部小写
2.super和this对比着学习：
this：
this能出现在实例方法和构造方法中，不能出现在静态方法中
this的语法为：this.和this()
this大多情况下是可以省略的
this.在区分局部变量和实例变量的时候不能省略。
例如this.name=name;
this()只能出现在构造方法第一行，通过当前的构造方法去调用本类中的其他的构
造方法
super：
super能出现在实例方法和构造方法中，不能出现在静态方法中
super的语法为：super.和super()
super大多情况下是可以省略的
super.在区分的时候不能省略。
super()只能出现在构造方法第一行，一个构造函数只能有一个super，写在子类中去调用父类的构造方法，通过当前的构造方法去调用父类中的构造方法，目的是创建子类对象时，先初始化父类型特征。
3.super()
调父类方法
表示通过子类的构造方法调用父类的构造方法。模拟现实世界中的这种场景，现有父亲才有儿子
建议手动将一个类的无参构造写出来。
思考：super(实参)到底是干什么的
super(实参)的作用是：初始化当前对象的父类型特征，并不是直接创建新对象没实际上对象只创建了一个。
super关键字代表了什么？
代表当前对象的那部分特征，例如我继承了父亲的一部分特征，眼睛嘴巴，但这些特征是在我身上。
7.super.与this.:
如果父类和子类当中，都有同名属性，并且希望在子类内放访问父类特征时，super.不能省略。当前对象在父类的属性。调父类属性
this.访问当前对象的属性
4.当一个构造方法第一行，既没有this()又没有super()的话，默认会有一个super();
表示通过当前子类的构造方法调用父类的无参构造方法。所以必须保证父类的无参数构造方法是存在的。
5.this与super不能共存。
如果一个构造方法里有this，代表通过这个构造方法去调用本类中的其它构造方法。如果一个构造方法中有super，代表这个构造方法去调用所在类的父类这中的构造方法。
6.无论是怎么样，父类的构造方法是一定会执行的
package Super;
public class SuperTest {
public static void main(String[] args) {
new B();//1.开始，跳转到B类的无参数构造方法
}
}
class A extends Object{
public A(){//5.接收无参数，执行。
//这里默认也有super();
System.out.println("A类的无参数构造调用");
}
public A(int i){
//这里默认也有super();
System.out.println("A类的有参数构造调用");
}
}
class B extends A{
public B(){
this("zhangsan");//2.这里this指该构造方法去调用本类中的其他构造方法，即B的有参数构造方法
System.out.println("b类的无参数构造方法");
}
public B(String name){//3.从B的无参构造跳转到这里
super();//4.这里的super再跳转到B类的父类A类中构造方法去
System.out.println("B类的有参数构造方法");
}
}
例子2:
public class SuperTest2 {
public static void main(String[] args) {
new CC();
}
}
class AA{
public AA(){
System.out.println("AA无参");
}
}
class BB extends AA{
public BB(){
//默认有super();
System.out.println("BB无参");
}
public BB(String name){
//默认有super();
System.out.println("BB有参数");
}
}
class CC extends BB{
public CC(){
this("zhangsan");
System.out.println("CC无参");
}
public CC(String name){
this(name,20);
System.out.println("CC有参数名字");
}
public CC(String name,int age){
super(name);
System.out.println("CC有参数名字年龄");
}
}
不管new什么对象，最后object类的无参数构造方法一定会执行
object的无参数构造方法是处于栈顶部，最后调用，最先执行结束。
后进先出原则。
super(实参)的用法：
父类中有私有变量，子类的构造方法调用父类的构造方法时，因为私有变量无法跨类，子类的构造方法的形参如果有父类的私有变量的话，需要在子类的构造方法中使用super(私有变量)来调用父类含有私有变量的构造方法。
实例：
public class Bank {
public static void main(String[] args) {
Credit bank1 = new Credit("fang",1000.10,99.9);
System.out.println(bank1.getActno()+" "+bank1.getBalance()+" "+
bank1.getCredit());
}
}
class Account{
//属性
private String actno;
private double balance;
//构造函数
public Account(){
}
public Account(String actno, double balance) {
this.actno = actno;
this.balance = balance;
}
//封装
public String getActno() {
return actno;
}
public void setActno(String actno) {
this.actno = actno;
}
public double getBalance() {
return balance;
}
public void setBalance(double balance) {
this.balance = balance;
}
}
class Credit extends Account{
private double credit;
//构造方法
public Credit(){
}
public Credit(String actno,double balance,double credit){
super(actno,balance);//让子类构造方法可以调用父类构造方法
this.credit=credit;
}
//封装
public double getCredit() {
return credit;
}
public void setCredit(double credit) {
this.credit = credit;
}
}
super内存图：
super代表的是”当前对象（this）“的”父类型特征“
方法区内存：
所有的class，如果类加载过程中，这个类有静态代码块，有静态变量，一律都会执行，分配空间。
栈内存：
main方法栈帧。构造函数压栈
