黑马程序员-JAVA面向对象之抽象、接口、多态

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

一、抽象

抽象定义：抽象就是从多个事物中将共性的，本质的内容抽取出来。

抽象方法：多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。

抽象类：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。

抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰。

抽象类的特点

1，抽象方法一定在抽象类中。抽象方法和抽象类都必须被abstract关键字修饰（可以描述类和方法，不可以描述变量）。
2，抽象方法只定义方法声明，并不定义方法实现。
3，抽象类不可以用new创建对象(实例化)。因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用（继承），必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。即只有通过子类继承抽象类并覆盖了抽象类中的所有抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

抽象类注意点：

1，抽象类有构造函数，用于子类对象初始化

2，抽象关键字abstract和final ,private , static不可以共存

3，抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

4，抽象类中有构造函数，抽象类是一个父类，可以给子类提供实例初始化

代码实例：

我们在开发一个系统时需要对员工进行建模，员工包含3个属性：姓名，工号以及工资，经理也是员工，除了含有员工的属性外，另外还有一个奖金属性，请使用继承的思想设计出员工类和经理类，要求类中提供必要的方法进行属性访问。

class Employee  {      private String name;      private String id;      private double pay;      Employee(String name,String id,double pay)      {          this.name = name;          this.id = id;          this.pay = pay;      }      public abstract void work();  }  class Manager extends Employee  {      private int bonus;      Manager(String name,String id,double pay,int bonus)      {          super(name,id,pay);          this.bonus = bonus;      }      public void work()      {          System.out.println("manager work");      }  }  class Pro extends Employee  {      Pro(String name,String id,double pay)      {          super(name,id,pay);      }      public void work()      {          System.out.println("pro work");      }  }  class    {      public static void main(String[] args)       {          System.out.println("Hello World!");      }  }  

模板方法设计模式：

解决的问题：当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现

abstract class GetTime  {     //获取某段时间的代码，其中runcode();是不确定的，暴露到外边去。其他的是确定的。      public final void getTime()//此功能如果不需要复写，可加final限定      {          long start = System.currentTimeMillis();          runcode();//不确定的功能部分，提取出来，通过抽象方法实现          long end = System.currentTimeMillis();          System.out.println("毫秒："+(end-start));      }      public abstract void runcode();//抽象不确定的功能，让子类复写实现  }  class SubTime extends GetTime  {      public void runcode()//子类复写功能方法      {          for(int x=0; x<4000; x++)          {              System.out.print(x);          }      }  }  class  TemplateDemo  {      public static void main(String[] args)       {          //GetTime gt = new GetTime();          SubTime gt = new SubTime();          gt.getTime();      }  }  

-------------------------------------------------------------------------------------------------------------------

二、接口

接口：

可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。接口看上去是一个特殊的抽象类。里面存的都是抽象方法。

格式：

interface Innter{}

修饰常量：public static final

修饰方法：

public abstract  interface  Inter    {       public static final intNUM = 3;       public  abstract  void   show();    }

接口中成员是共有的，一个类可以继承类的同时实现多个接口，接口允许多继承

interface A  {      void methodA();  }  interface B extends A  {      void methodB();  }  interface C extends B  {      void methodC();  }  class D implements C  {      public void methodA(){}      public void methodC(){}      public void methodB(){}  }//建立D的对象必须实现3个方法。  接口之间可以多继承。Java支持多继续，只有接口之间有多继承 。类之间是单继承  

接口特点：

1：接口是对外提供的规则。
2：接口是功能的扩展。
3：接口的出现降低了耦合性

抽象类和接口的区别：

1：抽象类只能被继承，而且只能单继承。
      接口需要被实现，而且可以多实现。也就是说：接口的出现避免了单继承的局限性。
2：抽象类中可以定义抽象方法和非抽象方法，子类可以直接继承使用。
      接口中只能定义抽象方法，需要子类去实现。
3：继承和实现的关系不一致，抽象类使用的是 is a 关系。
     接口使用的 like a关系。
4：抽象类的成员修饰符可以自定义。
     接口中的成员修饰符是固定的。全都是public的。

------------------------------------------------------------------------------------------------------------

三、多态

定义：某一类事物的多种存在形态。即可以理解为事物存在的多种体现形态

1，多态的体现
    父类的引用指向了自己的子类对象。Animal a = new Cat();
    父类的引用也可以接收自己的子类对象。
2，多态的前提
      必须是类与类之间有关系。要么继承，要么实现。
      通常还有一个前提：存在覆盖操作。
3，多态的好处
      多态的出现大大的提高程序的扩展性。
4，多态的弊端：
     当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)即：提高了扩展性，但是只能使用父类的引用访问父类中的成员。
5，多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现。

代码范例：

abstract class Animal  {      abstract void eat();  }  class Cat extends Animal  {      public void eat()      {          System.out.println("吃鱼");      }      public void catchMouse()      {          System.out.println("抓老鼠");      }  }  class Dog extends Animal  {      public void eat()      {          System.out.println("吃骨头");      }      public void kanJia()      {          System.out.println("看家");      }  }  class Pig extends Animal  {      public void eat()      {          System.out.println("饲料");      }      public void gongDi()      {          System.out.println("拱地");      }  }  

关键字 instanceof

 判断对象是否实现了指定的接口或继承了指定的类

格式：

对象 instanceof类型

Student instanceof Person = true;//student继承了person类

多态在子父类中的成员上的体现的特点：

1，成员变量：在多态中，子父类成员变量同名。
    在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）
    运行时期：也是参考引用型变量所属的类中是否有调用的成员。
    简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。
    再说的更容易记忆一些：成员变量---编译运行都看 =左边。
2，成员函数。
    编译时期：参考引用型变量所属的类中是否有调用的方法。
    运行时期：参考的是对象所属的类中是否有调用的方法。
 为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。
    简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。
    更简单：成员函数 --- 编译看 =左边，运行看 = 右边。
3，静态函数。
    编译时期：参考的是引用型变量所属的类中是否有调用的成员。
    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

详情请查看：http://edu.csdn.net/heima