JavaSE_day27(接口知识接上、继承与接口整合的实际运用例子，多态前提，动态绑定，上下转型，多态成员特点，多态能调用哪些成员，多态优缺点)

1 A_InterfaceDemo3

 * 类与类： 继承关系 extends，单一继承，多层继承 
 * 类与接口：实现关系 implements ，多实现
 * 接口与接口的关系：   继承关系，多继承
 * 
 * 
 * Eclipse如何读源码：ctrl+shift+t查找~所需类，接口的源码

public class A_InterfaceDemo3 {

}

interface InterA{
	
	public abstract void method();
}

interface InterB{
	public abstract void method2();
	
}

interface InterC extends InterA ,InterB{   //已经继承了method(),method2()方法！
	
}

class Demo implements InterC {  //实现接口的所有方法

	@Override
	public void method() {
		// TODO Auto-generated method stub
	}
	@Override
	public void method2() {
		// TODO Auto-generated method stub
		
	}
}

2  B_InterfaceTest

 * 需求例子：继承和接口的实际运用！
              篮球运动员和教练
              乒乓球运动员和教练
              现在篮球运动员和教练要出国访问，需要学习英语
              请根据你所学的知识，分析出来哪些是类，哪些是抽象类，哪些是接口？？？

 * 类：  B_Person（共性1） ,  B_BasketbalPlayer 与 B_PingPangCoach（分别继承B_Player 与 B_Coach）
 * 抽象类：B_Player 与 B_Coach  （继承B_Person）
 * 接口：B_SpeakEnglish（共性2）
 * 
 * 总体流程：人--抽象教练，运动员--具体教练，运动员，（其中具体教练，运动员还实现了接口）。
 *         人    ：   吃饭睡觉行为
 *                        姓名年龄性别属性
 *         教练：    抽象方法教方法（不同教练教不同内容，所以使用抽象类的抽象方法定义声明，方法体根据不同教练实现不同效果！）
 *         运动员： 抽象方法学习方法（不同运动员学习不同内容，所以...）
 * 
 *         乒乓球教练：    继承教练抽象类【教学方法】和实现说英语接口，重写这俩个方法【教学方法和说英语】
 *         篮球教练：       继承教练抽象类【教学方法】和实现说英语接口，重写这俩个方法【教学方法和说英语】
 * 
 *         乒乓球运动员： 继承运动员抽象类【学习方法】和实现说英语接口，重写这俩个方法【学习方法和说英语】
 *         篮球运动员：    继承教练抽象类【学习方法】和实现说英语接口，重写这俩个方法【学习方法和说英语】
 * 
 * 图解：关系之间的直观展现！

package day27;

public class B_Person {
	
	public String name;
	public int age;
	public String gender;
	public B_Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	public B_Person(String name, int age, String gender) {
		super();
		this.name = name;
		this.age = age;
		this.gender = gender;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getGender() {
		return gender;
	}
	public void setGender(String gender) {
		this.gender = gender;
	}
	
	public void eat(){
		System.out.println("人类吃饭...");
	}
	
	public void sleep(){
		System.out.println("人类睡觉...");
	}

}

public interface B_SpeakEnglish {
	
	public abstract void speakEnglish();

}

/*
 * 抽象教练类
 * */
public abstract class B_Coach extends B_Person{
	
	
	public abstract void teach();

}

/*
 * 运动员抽象类
 * */
public abstract class B_Player extends B_Person{

	
	public abstract void study();
}

public class B_BaskbalCoach extends B_Coach implements B_SpeakEnglish{

	@Override
	public void teach() {
		System.out.println("教扣篮..");
	}

	@Override
	public void speakEnglish() {
		System.out.println("说英语");
		
	}

}

package day27;

public class B_PingPangCoach extends B_Coach implements B_SpeakEnglish{

	@Override
	public void teach() {
		
		System.out.println(name+"教抽球..");
	}

	@Override
	public void speakEnglish() {
		// TODO Auto-generated method stub
		System.out.println(name+"教练学英语");
	}
	

}

package day27;

public class B_BasketbalPlayer extends B_Player implements B_SpeakEnglish{

	@Override
	public void study() {

		System.out.println(name+"学习扣篮...");
		
	}

	@Override
	public void speakEnglish() {
		System.out.println(name+"说英语");
		
	}

}

package day27;

public class B_PingPangPlayer  extends B_Player implements B_SpeakEnglish{

	@Override
	public void study() {
		System.out.println(name+"学习抽球...");
	}

	@Override
	public void speakEnglish() {
		// TODO Auto-generated method stub
		System.out.println(name+"要学英语");
	}

}

public class B_InterfaceTest {
	
	public static void main(String[] args) {
		
		//创建篮球运动员对象
		
		B_BasketbalPlayer bp = new B_BasketbalPlayer();
		bp.setName("库里运动员");
		bp.setAge(25);
		bp.setGender("男");
		bp.eat();
		bp.sleep();
		bp.study();
		bp.speakEnglish();
		System.out.println("----------------");
		//创建篮球运教练对象
		
		B_BaskbalCoach bc = new B_BaskbalCoach();
		bp.setName("科尔教练");
		bp.setAge(25);
		bp.setGender("男");
		bp.eat();
		bp.sleep();
		bp.study();
		bp.speakEnglish();
				
		System.out.println("----------------");
		
		
		//创建乒乓球运动员
		B_PingPangPlayer ppp = new B_PingPangPlayer();
		ppp.setName("马龙运动员");
		ppp.setAge(40);
		ppp.setGender("男");
		ppp.eat();
		ppp.sleep();
		ppp.study();
		ppp.speakEnglish();
		System.out.println("----------------");
		
		//创建乒乓球教练
		B_PingPangCoach ppc = new B_PingPangCoach();
		ppc.setName("刘国梁教练");
		ppc.setAge(40);
		ppc.setGender("男");
		ppc.eat();
		ppc.sleep();
		ppc.teach();
		ppc.speakEnglish();
		
	}

}

3 C_DuoTaiDemo

 * 多态的前提：
 *     子父类的继承关系
 *     方法的重写
 *     父类引用指向子类对象

 * 动态绑定：  运行期间调用的方法，是根据其具体的类型而去调用的！【Animal a = new Cat();】

 * 优秀博客：(127条消息) Java学习——上转型与下转型对象_java 对象转型_蔡军帅的博客-CSDN博客
 * 优秀博客：动态绑定：

(127条消息) Java的动态绑定和静态绑定_ting说你跳的博客-CSDN博客

public class C_DuoTaiDemo {

		public static void main(String[] args) {
			
			//纯父类对象
			Animal a1=new Animal();
			a1.eat();   //父类吃东西
			a1.self();//可以输出父类的方法
			System.out.println("---------");//纯父类对象只能用自己的成员
			
			//纯子类对象
			Cat c =new Cat();
			c.eat();//调用的是子类方法  ：输出父类吃东西和子类猫吃鱼，因为有super
			c.self();//可以调用子类继承的方法
			c.sonSelf();//纯子类对象可以调用子类新增的方法
			
			
			System.out.println("--------");
			
			/*
			 父类引用  Animal a 
			指向   =  
			子类对象  new Cat();
			*/
			Animal a = new Cat();  //上转型
			a.eat();  //调用的是子类方法  ：输出父类吃东西和子类猫吃鱼，因为有super
			a.self();//继承的方法也可以用!
//			a.sonsel();报错了，子类新增的方法上转型用不了一点！
		}
}

class Animal{
	
	public void eat(){
		System.out.println("1.父类吃东西");
	}
	public void self(){
		System.out.println("2.父类写的---继承的方法上转型也可以用!");
	}
	
}
class Cat extends Animal{
	
	public void eat(){
		super.eat();
		System.out.println("3.子类猫吃鱼，子类重写父类的方法");
	}
	public void sonSelf(){
		System.out.println("4.子类自己的新增方法上转型用不了一点！!");
	}
	
}

 

4  C_DuoTaiDemo2

* 多态的成员特点：
 * 
 *        成员变量  : 编译时看的是左边，运行时看的是左边
 *        成员方法  : 编译时看的是左边，运行时看的是右边【注意是继承重写的方法，而不是新增方法，新增的方法都调用不了...】
 *        静态方法  : 编译时看的是左边，运行时看的是左边
 * 
 * 编译时看的都是左边，运行时成员方法【注意是继承的方法！！！不是新增的方法！】看的是右边，其他（成员变量和静态的方法）看的都是左边
 * 

public class C_DuoTaiDemo2 {
	public static void main(String[] args) {
		
		Dad d = new Kid();  //上转型对象！ 
		System.out.println(d.num); //调用的是父类的num=20!
		
//		System.out.println(d.k);//报错了,子类新增变量上转型也用不了。结论：上转型用不了自己新增的成员！
		d.method();//这是一般方法，调用的是子类重写的方法
		d.function();//这是静态方法不是一般方法，所以调用的是父类的方法		

/*		d.selfSon();报错了  --子类新增的方法，上转型用不了 。结论：上转型用不了自己新增的成员！
		System.out.println(d.a);报错了 ，子类新增的静态变量用不了
		*/
		System.out.println(d.b);  //父类的静态变量可以用
	}
}

class Dad{
	int num = 20;
	static int b=990;
	
	public void method(){
		System.out.println("我是父类方法");
	}
	
	public static void function(){
		System.out.println("我是父类的静态方法");
	}
}

class Kid extends Dad{
	int num  = 10;
//	int k=20;
//	static int a=20;
	public void method(){
		System.out.println("我是子类方法");
	}
	public static void function(){
		System.out.println("我是子类的静态方法");
	}
	//子类新增的方法
	public void  selfSon(){
		System.out.println("这是子类新增的方法！");
	}
	
}

5 C_DuoTaiDemo3

 * 多态中的向上转型和向下转型：
 * 
 * 引用类型之间的转换：
 *         向上转型
 *             由小转到大（子类型转成父类型）
 *         向下转型
 *             由大转小（父类型转成子类型）
 * 
 * 基本数据数据类型的转换：
 *      自动类型转换：
 *           由小到大
 *              byte short char --- int --- long --- float --- double 
 *      强制类型转换：
 *              由大到小

public class C_DuoTaiDemo3 {
	
	public static void main(String[] args) {
		
		Animal2 a = new Dog();  //向上转型

		a.eat();
		System.out.println(a.num);
//		System.out.println(a.kk);//子类新增的变量用不了，报错了
		System.out.println("----");
		
//		a.swim(); 子类新增的方法用不了，报错了
		
		Dog d= (Dog)a;  //向下转型  ：相当于 Dog d = new Dog();
		d.swim();  //纯子类对象可以用子类特有成员
		System.out.println(d.kk);  //纯子类对象可以用子类特有成员
		
	}
}

class Animal2{
	int num=10;
	public void eat(){
		System.out.println("吃东西");
	}
}

class Dog extends Animal2{
	int kk=20;
	public void eat(){
		System.out.println("啃骨头");
	}
	public void swim(){
		System.out.println("狗刨");
	}
}

6  C_DuoTaiDemo4

 * 多态的优缺点：
 * 
 *         优点：可以提高可维护性（前提是在多态的前提下）,提高代码的可扩展性.[在本例代码中体现！Phone p = new MiPhone()/new RedPhone() 上转型！;]
 *         缺点： 无法直接访问子类特有的成员[因为编译时看的是左边，根本就无法看到你右边子类里创建的是什么子类对象]
 * 

public class C_DuoTaiDemo4 {
	public static void main(String[] args) {
		MiFactory factory = new MiFactory();
		
		factory.createPhone(new MiPhone());//小米
		factory.createPhone(new RedPhone());//红米
	}
}
class MiFactory{
	
	/*public void createPhone(MiPhone mi){
		mi.call();
	}
	public void createPhone(RedPhone mi){
		mi.call();
	}*/
	public void createPhone(Phone p){
		p.call();
	}
}

abstract class Phone{
	public abstract void call();
	
}

//小米手机
class MiPhone extends Phone{

	@Override
	public void call() {
		System.out.println("小米手机打电话");
	}
}
//红米手机
class RedPhone extends Phone{
	@Override
	public void call() {
		System.out.println("红米打电话");
	}
	
}