Java抽象类和多态

一、       抽象类

1.    概述

当多个类出现相同功能，但是功能主体不同，可以抽取，但是只抽取功能定义，不抽取功能主体。

2.    特点

               i.         抽象方法一定在抽象类中

              ii.         抽象方法和抽象类都必须被abstract修饰

             iii.         抽象类不可以用new创建对象，没有意义

abstract class Student

{

   abstractvoid study();  

   void sleep()

   {

      System.out.println("Zzz...");

   }

} 

class AbstractDemo

{

   publicstatic void main(String [] args)

   {

      newStudent().study(); //报错！抽象类不能实例化

   }

}

             iv.         抽象类中的抽象方法要被使用，必须由子类重写其所有的抽象方法后，建立子类对象调用。如果子类只重写了部分抽象方法，那么子类还是一个抽象类。

3.    抽象类跟一般类的区别：

事物该怎么描述还怎么描述，只不过，该事物出现了一些看不懂的（抽象的）东西。

4.    程序示例：学生都学习，但低年级跟高年级学的内容不同

abstractclass Student

{

   abstract void study();      //抽象方法不能有主体

   voidsleep()

   {

      System.out.println("Zzz...");

   }

}

class BaseStudent

{

   voidstudy()

   {

      System.out.println("basiclesson");

   }

}

class AdvStudent

{

   void study()

   {

      System.out.println("advancedlesson");

   }

}

 

二、     接口（interface）

1. 可以初步理解为是，一个特殊的抽象

即当一个抽象类中的方法都是抽象的，那么该类可以通过“接口”的形式表示。

interface Practice

{

   public abstract void method01();

 

public abstract void method02();

}

2. 接口同样不可以创建对象，因为有抽象方法，需要被子类实现（implements），子类对方法采用覆盖，才可以实例化。

3. 接口定义的格式特点：

       i.     接口中常见定义：常量，抽象方法

     ii.     接口中的成员都有固定修饰符

常量：public static final

方法：public abstact

记住：接口中的成员的权限都是public

4. 接口可以被类 多实现（即一个类可以实现多个接口）

5. 程序示例：

interface MyInterface01

{

publicstatic final int NUM=3;

publicabstract void show();

}

interface MyInterface02

{

publicabstract void method();

}

class Test implementsMyInterface01,MyInterface01

{

   publicvoid show(){}       

   publicvoid method(){}

}

class InterfaceDemo

{

   publicstatic void main(String[] args)

   {

      Test test= new Test();

      System.out.println(test.NUM);

      System.out.println(MyInterface01.NUM);

      System.out.println(Test.NUM);

   }

}

6. 接口之间支持多继承

interface A

{

   public abstract void run_1();

}

interface B

{

   public abstract void run_2();

}

interface C extends A,B    //支持多继承

{

   public abstract void run_3();

}

interface D

{

   public abstract void run_4();

}

class Temp

{

   public static void temp(){}

}

//在继承的同时，多实现(implements)

class Demo extends Temp implements C,D    

{

   public void run_1(){}

   public void run_2(){}

   public void run_3(){}

   public void run_4(){}

}

三、     多态

1. 理解多态：

可以理解为事物存在的多种体现形态，比如：

人：男人，女人 / 小孩，青年，老人

动物：狗，猫，虎，兔

2. 多态概述

       i.     多态的体现：父类的引用指向了其子类对象，如

Animal c = new Cat();  c.eat();

 

     ii.     多态的前提：必须是类与类之间有关系，要么继承(extends)，要么实现（implements）

   iii.     多态的好处：多态的出现大大的提高了程序的扩展性

 

3. 程序示例：

interface Animal

{

   public abstract void eat();

}

class Cat implements Animal

{

   public void eat()

   {

      System.out.println("@eatfish@");

   }

   public void catchMouse()

   {

      System.out.println("%捉老鼠%");

   }

}

class MutiForms

{

  publicstatic void main(String [] args)

  {

     //多态自始至终都是子类对象在做变化

     Animal cat = new Cat();//向上转型，Cat->Animal

     cat.eat();

     Cat C =(Cat)cat;//向下转型，Animal->Cat

     C.catchMouse();

   }

4. 多态在代码中的特点：

class Fu

{

   int num = 1989;

   void founc_1()

   {

      System.out.println("fufounc_1");

   }

   void founc_2()

   {

      System.out.println("fufounc_2");

   }

   static void founc_4()

   {

      System.out.println("fufounc_4");

   }

}

class Zi extends Fu

{

   int num = 2012;

   void founc_1()

   {

      System.out.println("zifounc_1");

   }

   void founc_3()

   {

      System.out.println("zifounc_3");

   }

   static void founc_4()

   {

      System.out.println("zifounc_4");

   }

}

class MutiForms

{

   public static void main(String[]args)

   {

      Zi z = new Zi();

      z.founc_1();

      z.founc_2();

      z.founc_3();

      System.out.println("-----------------");

      /*

      多态中（非静态）成员函数的特点：

      成员函数在多态调用时，编译看左边，运行看右边

      */

      Fu f = new Zi();

      f.founc_1();

      f.founc_2();

      f.founc_3(); //error

      System.out.println("-----------------");

      /*

      多态中成员变量的特点：

      无论编译或运行，都参考左边（引用型变量所属的类）

      */

      System.out.println("z.num---"+z.num);

      System.out.println("f.num---"+f.num);

      System.out.println("-----------------");

      /*

      在多态中，静态成员函数（同样适用于静态变量）

无论编译或运行，都参考左边（静态方法不需要对象，类名即可调用）

      */

      f.founc_4();//founc_4()是静态

      z.founc_4();

   }

}