this\super关键字

1、super,this只能放在构造方法的第一行
1、如果子类没有构造方法，则默认调用父类无参构造方法；如果父类没有无参的构造方法，则会报错
2、 如果子类有构造方法，那么在创建子类的对象时，则将先执行父类的构造方法，然后再执行子类构造方法
3、如果子类有构造方法，但没有在构造方法中使用super关键字，则默认执行该构造方法时自动产生super（）代码，即该构造方法会调用父类无参的构造方法
4、可以用super关键字来在子类的构造方法中引用父类的有参构造方法，但必须是子类构造方法中的第一条语句

this

如果要在一个构造方法中，调用另一个构造方法，可以使用this()

this(name);//调用有一个参数的构造方法
this();//调用无参构造方法

super(name);//调用有一个参数的构造方法
super();//调用无参构造方法

public class Hero {
        
    String name; //姓名
        
    float hp; //血量
        
    float armor; //护甲
        
    int moveSpeed; //移动速度
        
    //带一个参数的构造方法
    public Hero(String name){
        System.out.println("一个参数的构造方法");
        this.name = name;
    }
      
    //带两个参数的构造方法
    public Hero(String name,float hp){
        this(name);//调用有一个参数的构造方法
        this();//调用无参构造方法
        System.out.println("两个参数的构造方法");
        this.hp = hp;
    }

super

#####################################################################

父类：重本线是***
子类：重本线***+100(武汉大学）
就是在父类的基础上添加东西。

不带参数的是省略了super（） 所以调子类构造方法会打印父类的构造方法

/*
*super 格式
*/

class A{
//注意写一个空方法，不然子类省略super会报错
	A(){};
	A(int n){}
}

class B extends A{
B（）{
	//super（）;    //A()
	super(10);
}
}

#####################################################################

1、用super操作被隐藏的成员变量和方法.
2、使用super调用父类的构造方法。

package charactor;
  
public class ADHero extends Hero implements AD{
 
    int moveSpeed=400; //移动速度
    //this是当前 
    public int getMoveSpeed(){
        return this.moveSpeed;//400
    }
     //super是父类
    public int getMoveSpeed2(){
        return super.moveSpeed;//父类的moveSpeed  = 0
    }
     
    public static void main(String[] args) {
        ADHero h= new ADHero();
         
        System.out.println(h.getMoveSpeed());//要实例化一个对象之后再调用
        System.out.println(h.getMoveSpeed2());
         
    }
  
}

/*
* super 1、
* 用super操作被隐藏的成员变量的方法。（p122）
*/
public class Sum {
	int n;//成员变量的n
	float f() {
		int sum = 0;
		for(int i = 1 ; i <= n; i++) {
			sum = sum + i;
		}
		return sum;
	}
	
	//主方法
	public static void main(String[] args) {
		Average aver = new Average();
		aver.n  = 100;//在主方法里赋值
		float resultOne = aver.f();//把得到的结果赋值，最后才有办法输出
		float resultTwo = aver.g();//调子方法的g（）
		System.out.println(resultOne);
		System.out.println(resultTwo);
	}
}


//子类Average
class Average extends Sum{
	//隐藏成员变量
	int n;//子类又有n，把成员变量的n隐藏了。
	
	//方法重写
	float f() {
		float c;
		super.n = n;//把100赋值给父类的n，没有这一步，父类n是默认值0，计算出来是0。
		c = super.f();//把父类计算出来的5050赋值给c
		return c/n;
	}
	
	//子类继承再写新方法
	float g() {
		float c;
		//super.n = n;  //可以省略，因为先调f（）时已经给父类的n赋值了
		c = super.f();
		return c/2;
	}	
}

先调f()，再调g()

先调g(),再调f()

先调g（），父类的n默认值是0；
在g（）中加一句，super.n = 100;

package character;
/*
*super 2、
*使用super调用父类的构造方法
*/
class Student{
	int number;
	String name;
	//构造方法
	
	Student(){
	}
	
	Student(int number,String name){
		this.name = name;
		this.number = number;
		System.out.println("我的名字是：" + name + ",我的学号是：" + number);
	}
}

class UniverStudent extends Student{//is a
	boolean 婚否;
	//子类在父类构造的基础上增加了婚否状态
	UniverStudent(int number, String name,boolean 婚否) {//注意子类的构造方法不再叫Student
		//继承用super
		super(number, name);
		this.婚否 = 婚否;
		System.out.println("婚否："+ 婚否);
	}
	
}

public class launch {
	public static void main(String[] args) {
		new Student(2018061023,"ConanLEE");
		new UniverStudent(9901,"何晓林",true);
	}
}

子类构造方法如果省略super

//注意父类要有一个空的构造方法，不然会报错。
Student(){
	}
//有参构造方法
Student(int number,String name){
		this.name = name;
		this.number = number;
		System.out.println("我的名字是：" + name + ",我的学号是：" + number);
	}

如果在子类里直接传值呢
会输出ConanLEE还是 何晓林的信息？

UniverStudent(int number,String name,boolean 婚否){
		super(9901,"何晓林");
		this.婚否 = 婚否;
		System.out.println("婚否："+ 婚否);

	public static void main(String[] args) 
		UniverStudent s2 = new UniverStudent(2017062058,"ConanLEE",true);