Java回顾第三章

[懒懒张187]

多态
生活中的例子：
人:Person 人：public class Person
学生：Student 学生：public class Student extends Person
工人：Worker 工人：public class Worker extends Person
人是人的一种 Person p = new Person();
学生是人的一种（多态） Person p = new Students();
工人是人的一种(多态) Person p = new Worker();
接口和实现类之间的多态 Myinter m = new MyinterImpl();

 //定义父类
 public classs Fu{
     public void show(){
             System.out.println("父类的方法");
     }
 }

 //定义子类
public class Zi extends Fu{
   //重写父类方法
   @Override
    public void show(){
          System.out.println("子类重写父类方法");
    }
}

public class DemoPolymorphsic{
   public static void main (String[] args){
             Fu f = new Fu();
             f.show();
   }
}

多态的好处和弊端
不使用多态：好处是可以使用子类特有的方法，弊端是延展性差
使用多态：与不使用多态相反
多态的转型（向上/向下）

public class Fu{
   public void work(){
      System.out.println("父亲在工作");
  }
}

//定义一个子类
public class Zi{
   @Override
    public void work(){
          System.out.println("儿子在工作");
    }

 //子类特有的方法
    public void playGame(){
         System.out.println("儿子在玩儿");
   }
}
/**
* 向上转型：多态本身就是向上转型，把子类对象赋值给父类的变量
*        格式： 父类类型 变量名 = new 子类对象();
*         好处：扩展性强，可以赋值不同子类对象  
*向下转型：把父类类型强转为子类类型（强转）
*       格式：子类类型 变量名 = （子类类型）父类变量名;
*       好处：强转完毕以后，多态变成了子类类型，可以用子类特有的功能
*
*/
public class Demo{
  public static void main (String[] args){
      Fu f= new Zi();
      f.work();

      //向下转型
      Zi z = (Zi)f;
      z.playGame(); // 子类特有方法
  }
}

注意：强转过程中有可能会发生异常ClassCastException: Dog cannot be cast to ……
这时可以先用instanceof关键字做个判断是否某个对象属于某种数据类型

         Animal a = new Dog();
         a.eat();
         a.bark();
         if(a instanceof Cat){  //在强转前用instanceof做一个判断
             Cat c = (Cat) a;
         }

匿名内部类

//不使用匿名内部类情况
 public abstract class Animal{
    public abstract void eat();
    public abstract void sleep();
 }

public class Cat extends Animal{
  @Override
   public void eat(){
         System.out.println("吃");
   }

@Override
   public void sleep(){
         System.out.println("睡");
   }

 //猫特有功能
   public void catchMouse(){
         System.out.println("抓鼠");
   }
 }

/**
*匿名内部类：
*        匿名：创建内部类，没有赋值给某一个变量，没有名字
*        内部类：是一个局部内部类（写在方法中）
*        作用：简化代码
*                   把子类继承父类和重写父类的方法以及创建子类对象，合成一步去完成
*                   把实现类实现接口和重写接口方法以及创建实现类对象，合成一步去完成
*        格式：
*                new 父类/接口(){
*                    重写父类/接口中的方法
*                }
*/
                new Animal(){
                     @Override
                      public void eat(){
                          System.out.println("吃");
                      }

                      @Override
                     public void sleep(){
                         System.out.println("睡");
                      }
                }.eat();