继承2

/*
	问题是：
		我不仅仅要输出局部范围的num，还要输出本类成员范围的num。怎么办呢?
		我还想要输出父类成员范围的num。怎么办呢?
			如果有一个东西和this相似，但是可以直接访问父类的数据就好了。
			恭喜你，这个关键字是存在的：super。
			
	this和super的区别?
		分别是什么呢?
			this代表本类对应的引用。
			super代表父类存储空间的标识(可以理解为父类引用,可以操作父类的成员)

		怎么用呢?
			A:调用成员变量
				this.成员变量 调用本类的成员变量
				super.成员变量 调用父类的成员变量
			B:调用构造方法
				this(...)	调用本类的构造方法
				super(...)	调用父类的构造方法
			C:调用成员方法
				this.成员方法 调用本类的成员方法
				super.成员方法 调用父类的成员方法
*/
class Father {
	public int num = 10;
}

class Son extends Father {
	public int num = 20;
	
	public void show() {
		int num = 30;
		System.out.println(num);
		System.out.println(this.num);
		System.out.println(super.num);
	}
}

class ExtendsDemo5 {
	public static void main(String[] args) {
		Son s = new Son();
		s.show();
	}
}

------------------------------------------------------------------------------------------------------------------------
/*
	继承中构造方法的关系
		A:子类中所有的构造方法默认都会访问父类中空参数的构造方法
		B:为什么呢?
			因为子类会继承父类中的数据，可能还会使用父类的数据。
			所以，子类初始化之前，一定要先完成父类数据的初始化。
			
			注意：子类每一个构造方法的第一条语句默认都是：super();
*/
class Father {
	int age;

	public Father() {
		System.out.println("Father的无参构造方法");
	}
	
	public Father(String name) {
		System.out.println("Father的带参构造方法");
	}
}

class Son extends Father {
	public Son() {
		//super();
		System.out.println("Son的无参构造方法");
	}
	
	public Son(String name) {
		//super();
		System.out.println("Son的带参构造方法");
	}
}	

class ExtendsDemo6 {
	public static void main(String[] args) {
		//创建对象
		Son s = new Son();
		System.out.println("------------");
		Son s2 = new Son("林青霞");
	}
}
--------------------------------------------------------------------------------------------------------------------
/*
	如果父类没有无参构造方法，那么子类的构造方法会出现什么现象呢?
		报错。
	如何解决呢?	
		A:在父类中加一个无参构造方法
		B:通过使用super关键字去显示的调用父类的带参构造方法
		C:子类通过this去调用本类的其他构造方法
			子类中一定要有一个去访问了父类的构造方法，否则父类数据就没有初始化。
			
	注意事项：
		this(...)或者super(...)必须出现在第一条语句上。
		如果不是放在第一条语句上，就可能对父类的数据进行了多次初始化，所以必须放在第一条语句上。
*/
class Father {
	/*
	public Father() {
		System.out.println("Father的无参构造方法");
	}
	*/
	
	public Father(String name) {
		System.out.println("Father的带参构造方法");
	}
}

class Son extends Father {
	public Son() {
		super("随便给");
		System.out.println("Son的无参构造方法");
		//super("随便给");
	}
	
	public Son(String name) {
		//super("随便给");
		this();
		System.out.println("Son的带参构造方法");
	}
}

class ExtendsDemo7 {
	public static void main(String[] args) {
		Son s = new Son();
		System.out.println("----------------");
		Son ss = new Son("林青霞");
	}
}

-----------------------------------------------------------------------------------------------------------------------
/*
	继承中成员方法的关系:
		A:子类中的方法和父类中的方法声明不一样，这个太简单。
		B:子类中的方法和父类中的方法声明一样，这个该怎么玩呢?
			通过子类对象调用方法：
				a:先找子类中，看有没有这个方法，有就使用
				b:再看父类中，有没有这个方法，有就使用
				c:如果没有就报错。
*/
class Father {
	public void show() {
		System.out.println("show Father");
	}
}

class Son extends Father {
	public void method() {
		System.out.println("method Son");
	}
	
	public void show() {
		System.out.println("show Son");
	}
}

class ExtendsDemo8 {
	public static void main(String[] args) {
		//创建对象
		Son s = new Son();
		s.show();
		s.method();
		//s.fucntion(); //找不到符号
	}
}
--------------------------------------------------------------------------------------------------------------
/*
	方法重写：子类中出现了和父类中方法声明一模一样的方法。
	
	方法重载：
		本类中出现的方法名一样，参数列表不同的方法。与返回值无关。

	子类对象调用方法的时候：
		先找子类本身，再找父类。
		
	方法重写的应用：
		当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法。
		这样，即沿袭了父类的功能，又定义了子类特有的内容。
		
	案例：
		A:定义一个手机类。
		B:通过研究，我发明了一个新手机，这个手机的作用是在打完电话后，可以听天气预报。
		按照我们基本的设计，我们把代码给写出来了。
		但是呢?我们又发现新手机应该是手机，所以，它应该继承自手机。
		其实这个时候的设计，并不是最好的。
		因为手机打电话功能，是手机本身就具备的最基本的功能。
		所以，我的新手机是不用在提供这个功能的。
		但是，这个时候，打电话功能就没有了。这个不好。
		最终，还是加上这个功能。由于它继承了手机类，所以，我们就直接使用父类的功能即可。
		那么，如何使用父类的功能呢?通过super关键字调用
*/
class Phone {
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
}

class NewPhone extends Phone {
	public void call(String name) {
		//System.out.println("给"+name+"打电话");
		super.call(name);
		System.out.println("可以听天气预报了");
	}
}

class ExtendsDemo9 {
	public static void main(String[] args) {
		NewPhone np = new NewPhone();
		np.call("林青霞");
	}
}
---------------------------------------------------------------------------------------------------------
/*
	方法重写的注意事项
		A:父类中私有方法不能被重写
			因为父类私有方法子类根本就无法继承
		B:子类重写父类方法时，访问权限不能更低
			最好就一致
		C:父类静态方法，子类也必须通过静态方法进行重写
			其实这个算不上方法重写，但是现象确实如此，至于为什么算不上方法重写，多态中我会讲解
			
		子类重写父类方法的时候，最好声明一模一样。
*/
class Father {
	//private void show() {}
	
	/*
	public void show() {
		System.out.println("show Father");
	}
	*/
	
	void show() {
		System.out.println("show Father");
	}
	/*
	public static void method() {
		
	}
	*/
	
	public void method() {
		
	}
}

class Son extends Father {
	//private void show() {}

	/*
	public void show() {
		System.out.println("show Son");
	}
	*/
	
	public void show() {
		System.out.println("show Son");
	}
	
	
	public static void method() {
	
	}
	
	/*
	public void method() {
	
	}
	*/
}

class ExtendsDemo10 {
	public static void main(String[] args) {
		Son s = new Son();
		s.show();
	}
}