面向对象3

1. 向上转型：子类的对象可以当作父类的对象来使用称为向上转型（upcasting）。

    向下转型：父类的对象可以当作子类的对象来使用称为向下转型（downcasting）。

   public class Mb{
      public static void main(String args[]){
         Animal cat = new Cat();  //向下转型
         Cat c = (Cat)cat;        //类型转换
         c.name = "tom";
         c.sleep();
         Person p = new Person();
         p.playwithAnimal(c); 
      } 
   }

    class Animal{
      String name;
      public void sleep(){
         System.out.println(name + " is sleepping"); 
      } 
   }

   class Cat extends Animal{
      String eyescolor;
      public void catchMouse(){
         System.out.println("catch"); 
      } 
  }

   class Person{
      public void playwithAnimal(Animal a){
         System.out.println("play"); 
      } 
  }

2. 多态的必要条件：（1）要有继承 ；（2）要有方法的重写；（3）要有父类的引用指向子类的对象。

   public class Mb{
      public static void main(String args[]){     
         Cat c = new Cat();              
         Person p = new Person();
         p.playwithAnimal(c); 
      } 
   }

   class Animal{
      String name;
      public void sleep(){
         System.out.println(name + " is sleepping"); 
      }
      public void enjoy(){
         System.out.println("Animal is enjoy"); 
      } 
   }

   class Cat extends Animal{
      String eyescolor;
      public void catchMouse(){
         System.out.println("catch"); 
     } 
     public void enjoy(){
        System.out.println("cat is enjoy"); 
      }
   }

   class Person{
      public void playwithAnimal(Animal a){
         a.enjoy();
      }    
   }

3. 抽象类：当一个类不需要创建对象，作用只是用来被继承，那么这个类是个抽象类，在类前加上abstract 。

  （1）不能创建对象。

    注：抽象方法：就是用来被重写（覆盖）的，抽象方法不能有方法体。

    抽象类中可以有抽象方法，也可以有非抽象的方法。

   public class Mb{
      public static void main(String args[]){    
         Cat c = new Cat();
         c.enjoy();                   
      } 
   }

   abstract class Animal{
      String name;
      public void sleep(){
         System.out.println(name + " is sleepping"); 
      }
      public abstract void enjoy(); 
   }

   class Cat extends Animal{
      String eyescolor;
      public void catchMouse(){
         System.out.println("catch"); 
      } 
      public void enjoy(){
         System.out.println("cat is enjoy"); 
      }
   }

   class Dog extends Animal{
      String furcolor;
      public void enjoy(){
         System.out.println("dog is enjoy"); 
      }
  }

4. final关键字：加上final的类不能被继承，同样加上final的方法不能被重写，加上final的变量不能被改变。

   public class Mb{
      public static void main(String args[]){    
         T c = new T();
         System.out.println(c.a);
         c.z();                      
      } 
   }

   class T{                      //加了final的类不能被继承
  
      final int  a = 10;         //加了final的变量不能被改变                          
      public final void z(){    //加了final的方法不能被重写
    
         System.out.println("张三");
      }
   }

5. 接口（interface）：接口就是一种规范，规则，标准。

    接口里面的方法都是默认 public abstract 的，方法都是常量，且默认为 public static final.

  （1)  接口是特殊的抽象类.

  （2）只能有常量和抽象方法。

  （3）接口称之为实现，接口可以多实现。

  （4）接口之间叫继承，可以继承多个接口。

   public class Mb{
      public static void main(String args[]){    
         Bmv c = new Bmv();
         System.out.println(c.s);                   
      } 
   }

   interface Car{
      String s = "as";         //默认为public static final
      public void run();       //方法默认是public abstract
      public void stop();
  }

  interface A extends Car {    //接口之间叫继承，可以多继承
                            //如果不写继承，也可以在下面这样写
      public void r();         //class Bmv implements Car，A {}
  }

  class Bmv implements A {     //接口可以多实现
      public void run(){
          System.out.println("Bmv is running"); 
     } 
      public void stop(){
          System.out.println("Bmv is stoped"); 
    } 
      public void r(){}
   }