super&&this的应用

同名属性访问问题：

1、在同一个类中如果成员变量和形参（局部变量）名字一样时，就用this

2、当子类的成员变量和父类的成员变量一样时用super  访问   ：指代父类的

this的用法：

1、指代当前对象  谁调用这个方法this就指向谁   用法：this.成员变量  不带this的那个就是形参

2、另一个用途是调用当前对象的另一个构造方法    使用方法：this（参数）

并且必须放在别的构造方法的第一句话，目的是省代码，便于维护   This只能用在本类里

class B {
	int a;
	int b;
	void value(int a,int b){
		this.a=a;
		this.b=b;
		System.out.println(a+"  "+b);
	}
}
class Text{
	public static void main(String[] args){
		B b=new B();
		b.value(5,10);
	}
}

super的用法：

1、调用父类的构造方法    用法  super(参数);  super只能用在子类中

class A{
	A(){
		System.out.println("A");
	}
}

class B extends A{
	B(){
		super();//调用父类的构造方法时一定要写在子类的首个语句上调用与父类有相同形参的构造方法super（name）;
		System.out.println("B");
		
	}
}

class Text{
	public static void main(String[] args){
		B b=new B();
	}
}

运行结果为：

如果想用super继承父类的构造方法时，如果没有放在第一行的话，在super之前的语句，肯定是为了满足自己想要完成某些行为的语句，但是又用了super继承父类的构造方法，那么之前所做的就都回到了以前，也就是说又成了父类的构造方法

2、在Java中有时候会遇到子类中的成员变量或成员方法和超类（父类）中的成员变量或方法同名时，因为子类中的成员变量和方法的名的优先级高，所以子类中的成员变量或方法就隐藏了父类的成员变量和方法，此时就需要用到super。

class A{
	int a=10;
}
class B extends{
	int a=50;
}
class Text{
	public static void main(String[] args){
		B b=new B();
		System.out.println(b.a);
	}
}

运行结果为50可以看出当子类和父类的成员变量名相同时，子类的优先级更高,就近原则

class A{
	int a=10;
}


class B extends A{
	int a=20;
	System.out.println(super.a);
}
class Text{
	public static void main(String[] args){
		B b=new B();
	}
}

会出错？

当把super.a放到函数中访问就不会出错了。

class A{
	int a=10;
}


class B extends A{
	int a=20;
	void show(){
		System.out.println(super.a);
	}
}
class Text{
	public static void main(String[] args){
		B b=new B();
		b.show();
	}
}

class A{
	String name;
	void value(){
		name="A";
	}
}

class B extends A{
	String name;
	void value(){
		name="B";
		super.value();
		System.out.println(name);
		System.out.println(super.name);
	}
}
class Text{
	public static void main(String[] args){
		B b=new B();
		b.value();
	}
}

输出只能是方法中写

class Car{
	String name;
	String num;
	void show(){
		System.out.println("车名为"+name+"车牌为："+num+"的车正在开");
	}
}
class QiChe extends Car{
	QiChe(String name,String num){
		this.name=name;
		this.num=num;
	}
}
class ChuZuChe extends Car{
	String company;
	ChuZuChe(String name,String num,String company){
		this.name=name;
		this.num=num;
		this.company=company;
	}
}
class Text{
	public static void main(String[] args){
		QiChe q=new QiChe("奥迪","蒙A8888");
		q.show();
		ChuZuChe c=new ChuZuChe("qiya","蒙D8888","顺丰");
		c.show();
	}
}

如果把父类Car改为：

class Car{
	String name;
	String num;
	Car(String name,String num){
		this.name=name;
		this.num=num;
	}
	void show(){
		System.out.println("车名为"+name+"车牌为："+num+"的车正在开");
	}
}

其余的类内容不变，编译后会得到如下的结果：

如果再给父类Car该成：

class Car{
	String name;
	String num;
	Car(){
		
	}
	Car(String name,String num){
		this.name=name;
		this.num=num;
	}
	void show(){
		System.out.println("车名为"+name+"车牌为："+num+"的车正在开");
	}
}

即添加一个无参的构造方法。当自己在类中写了构造方法，无参构造方法就不会默认存在，得手写才会有

运行结果为：

宗上可知：肯定是哪里用了父类的无参的构造方法。

class QiChe extends Car{
	QiChe(String name,String num){
		super();
		this.name=name;
		this.num=num;
	}
}
class ChuZuChe extends Car{
	String company;
	ChuZuChe(String name,String num,String company){
		super();
		this.name=name;
		this.num=num;
		this.company=company;
	}
}

由上可知： QiChe类和ChuZuChe类调用默认了父类Ｃar无参的构造方法。

纵观以上代码，QIChe和ChuZuChe的构造方法中有大量重复的代码所以可以改为：

class Car{
	String name;
	String num;
	Car(String name,String num){
		this.name=name;
		this.num=num;
	}
	void show(){
		System.out.println("车名为"+name+"车牌为："+num+"的车正在开");
	}
}
class QiChe extends Car{
	QiChe(String name,String num){
		super(name,num);
	}
}
class ChuZuChe extends Car{
	String company;
	ChuZuChe(String name,String num,String company){
		super(name,num);
		this.company=company;
	}
}
class Text{
	public static void main(String[] args){
		QiChe q=new QiChe("奥迪","蒙A8888");
		q.show();
		ChuZuChe c=new ChuZuChe("qiya","蒙D8888","顺丰");
		c.show();
	}
}

综上：通过在父类进行初始化，可以让子类进行掉用父类的构造方法，从而简化代码，进行维护

把出租车改为：

class ChuZuChe extends Car{
	String company;
	ChuZuChe(String name,String num,String company){
		
		this.company=company;
		super(name,num);
	}
}

其余代码不变结果会报错：

所以调用父类的构造方法必须在子类的初始化方法的第一句话写。super（）

class ChuZuChe extends Car{
	String company;
	ChuZuChe(String name,String num,String company){
		super(name,num);
		this.company=company;
	}
	ChuZuChe(String name,String num){
		this(name,num,"雀巢");
	}
}

如果给ChuZuChe加一个构造方法，用this调用本类中其他的构造方法，那么此时还可以在这个地方加super吗？ 不能加，因为this（）和Super（）调用构造方法不能同时出现在同一个构造方法中。并且只能有一个放在第一句上，最后调用肯定会调用父类的构造函数