java中多态的简单学习与实践

//引用类型转换
/*
 * 1.向上类型转换（隐式/自动类型转换）,是小类型向大类型转换
 * 2.向下类型转换（强制类型转换），是大类型转小类型（存在一定风险）
 * 3.instanceof运算符，来解决引用对象的类型，避免类型转换的安全性问题
 *     a instanceof b  //判断一个引用是否是某个类型或者是某个类型的子类,返回布尔类型值
 */
public class Animal {
  public void eat(){
	  System.out.println("动物具有吃的能里");
  }
}

//对象的多种形态：继承是多态实现的基础
/*1、引用多态
*     父类的引用可以指向本类的对象
*     父类的引用可以指向子类的对象
*2、方法多态
*            创建本类对象时，调用的方法为本类方法
*            创建子类对象时，调用的方法为子类重写的方法或者继承的方法,不能调用子类中独有的方法
*/
public class Dog extends Animal {
  public void eat(){
	  System.out.println("狗是吃肉的！");   
  }
  public void watchDoor(){
	  System.out.println("狗具有看门的能力");
  }
}

public class Cat extends Animal {

}

//抽象类前使用abstract关键字修饰，则该类为抽象类
/*
 2、应用场景：
a、在某些情况下，某个父类只是知道其子类应该包含怎样的方法，但无法准确知道这些子类如何实现这些方法。
b、从多个具有相同特征的类中抽象出一个抽象类，以这个抽象类作为子类的模板，从而避免了子类设计的随意性。

3、作用：
限制规定子类必须实现某些方法，但不关注实现细节。

4、使用规则
a、abstract定义抽象类
b、abstract定义抽象方法，只有声明
c、包含抽象方法的类是抽象类
d、抽象类中可以包含普通的方法，也可以没有抽象方法
e、抽象类不能直接创建，可以定义引用变量
 */
public abstract class my_abstarct {
  public abstract void call();    //只要声明抽象方法就可以
  public abstract void message();
}

//接口：接口可以理解为一种特殊的类，由全局常量和公共的抽象方法所组成
/*
             如果说类是一种具体的实现体，而接口定义了某一批所需要遵守的规范，接口不关心这些类的内部数据，
     也不关心这些类里方法的实现细节，它只规定这些类里必须提供某些方法。
            定义接口不使用class关键字，而是使用interface关键字
           定义接口的格式：
    [修饰符]abstract interface 接口名[extends 父接口1,父接口2...]（可以继承多个父接口，也可以不继承父接口）{
                           零个到多个常量定义...
                            零个到多个抽象方法的定义... 
     }                 
           注：
                 接口就是用来被继承，被实现的，修饰符一般建议用public，否则只能在本包中使用，不能用private和protected修饰接口
          可以不加abstract，系统会默认的
              接口的定义：
              常量：
                      接口中的属性是常量，总是使用public static/final修饰符，即使定义时不添加public static/final修饰符，系统也会自动加上。
               方法：
                       接口中的方法只能是抽象方法，总是使用public abstract修饰符，即使定义时不添加public abstract修饰符，系统也会自动加上。
              使用接口：
                       一个类可以实现一个或多个接口，实现接口使用implements关键字。java中一个类只能继承一个父类，是不够灵活的，通过实现多个接口可以补充。
         eg：[修饰符] class 类名 extends 父类 implements 接口1,接口2...{
                                       类体部分//如果继承了抽象类，需要实现继承的抽象方法；要实现接口中的抽象方法。
            }
         5. 接口与匿名内部类配合使用
              IplayGame ip3=new IPlayGame(){
                  publick void playGame(){
                     System.out.println("使用匿名内部类的方式实现接口");
                  }
               };(有分号)

                                也可以直接new

                  new IPlayGame(){
                      publick void playGame(){
                           System.out.println("使用匿名内部类的方式实现接口")
                    }
                  }.playGame();




 */
public interface IplaGame { //接口定义一般首字母用I，以区别类和接口
  public void playGanme();

}

public class SmartPhone extends my_abstarct implements IplaGame{

	
	public void call() {
		// TODO 自动生成的方法存根
      System.out.println("通过语音打电话");
	}

	@Override
	public void message() {
		// TODO 自动生成的方法存根
	  System.out.println("通过语音发短信");
	}

	@Override
	public void playGanme() {//使用接口必须实现接口中的抽象方法
	  System.out.println("具有玩游戏的功能");
	}
}

public class Telphone extends my_abstarct {

	@Override
	public void call() {
	  System.out.println("通过键盘来打电话");
	}

	@Override
	public void message() {
		// TODO 自动生成的方法存根
      System.out.println("通过键盘来发短信");public class Psp implements IplaGame {

	@Override
	public void playGanme() {
		// TODO 自动生成的方法存根
      System.out.println("PSP具有玩游戏功能");
	}
}

public class Initail {

	public static void main(String[] args) {
		Animal n1=new Animal();
		Animal n2=new Dog();//父类的引用是可以指向其子类对象
		//Dog n3=new Animal();//错，不能用子类的引用指向父类
		Animal n3=new Cat();
		n1.eat();
		n2.eat();//调用的是子类中的方法
		n3.eat();//子类中没有重写，调用从父类中继承的方法
	    //n2.watchDoor();//不能通过父类的引用，调用子类独有的方法
	    Dog dog=new Dog();
	    Animal animal=dog;//自动类型提升，向上类型转换
	    Dog dog2=(Dog)animal;//向下类型转换，强制类型转换（）；
	    if(animal instanceof Cat){//判断一个引用是否是某个类型或者是某个类型的子类
	    //1.在编译时Cat类型2.运行时是Dog类型，出错
	      Cat cat=(Cat)animal;//两个不同对象之间进行强制类型转换，编译器不报错，但执行是会出现错误
	    }
	    else{
	    	System.out.println("无法进行强制类型转换");
	    }
	    my_abstarct tel1= new Telphone();
	    tel1.call();
	    tel1.message();
	    my_abstarct tel2=new SmartPhone();
	    tel2.call();
	    tel2.message();
	    IplaGame ip1=new SmartPhone();//接口也可以指向其实现的方法
	    ip1.playGanme();
	    IplaGame ip2=new Psp();
	    ip2.playGanme();
	    
	    IplaGame ip3=new IplaGame(){//采用匿名内部类
			@Override
			public void playGanme() {
				// TODO 自动生成的方法存根
				System.out.println("使用匿名内部类实现的");
			}
	    }; //要加”;“
	    ip3.playGanme();
	    
	    new IplaGame(){
			@Override
			public void playGanme() {
				// TODO 自动生成的方法存根
				System.out.println("使用匿名内部类实现的2");
			}
	    }.playGanme();
	}

}