抽象类和接口

给你个很经典的例子。。自己悟吧[code]abstract class Animal   [color=Red] //定义抽象类.至少有一个方法是抽象方法的类[/color]{
    String str;
    Animal(String s)     //定义抽象类的一般方法
   {
        str=s;
   }
   abstract void eat();      [color=Red][/color]//定义抽象方法--这就是抽象方法，没有方法体。
}
class Horse extends Animal     //定义继承Animal的子类。子类实现了父类的抽象方法eat()
{   
    String str;
    Horse(String s)
   {
      super(s);      //调用父类的构造方法
   }
    void eat()      //重写父类的抽象方法
   {      
      System.out.println("马吃草料！");
   }
}
class Dog extends Animal   //定义继承Animal的子类。子类实现了父类的抽象方法eat()
{
    String str;
    Dog(String s)
  {
      super(s);
    }
    void eat()
    {
    System.out.println("狗吃骨头！");
    }
}
public class test1
{
   public static void main(String args[])
   {
      Animal    Horse1 = new Horse("马");  //多态
      Animal    Dog1 = new Dog("狗");
      Horse1.eat();
      Dog1.eat();
    }
}[/code]

1、抽象
    首先，我们看抽象的意思是笼统的、模糊的、不具体的。关键字是abstract。那么JAVA中为什么会出现这么个关键字呢。个人认为是为了程序更加严谨而设置的。我们不妨来看一个例子。
    说的是人要睡觉，但是每个人的睡觉方式后不太一样，我们就拿小孩子和大人来做比较，假如小孩子都是趴着睡或侧着睡。大人都是仰着睡的。那么就有两个类Child和Adult，他们都有共同的特点就是睡觉，大人小孩都有共性，那么一般是向上抽取出一个类Person，具有方法sleep()，Child和Adult继承Person
    class Person                                                         class Child  extends  Person
         {                                                                               {
        sleep()                                                                   sleep()
                     {                                                                               {
                                 System.out.println("睡觉");                                    System.out.println("趴着睡");
                     }                                                                               }
         }                                                                               }

        class  Adult   extends  Person
        {
                  sleep()
                  {
                           System.out.println("仰着睡");           
                  }
         }                       

         接着我们来看，Child类和Adult类继承Person类，并覆写sleep方法，既然不同的人继承Person的sleep()方法，还要覆写一遍。那么Person里面的sleep()岂不是没有存在的意义了么？既然没有存在的意义的话，为了程序更加严谨，我们就sleep()方法的方法体，即把sleep()后面的大括号去掉，并在前面加上修饰符abstract表示Person类具有sleep()这个功能，至于怎么去睡觉Person类里面就不用定义了。这就是抽象方法，一个类里面有一个抽象方法的话，这个类也要被定义成抽象的。这就有了抽象类。

2、接口
        我们知道JAVA是不支持多继承的，就是子类继承了父类A的同时就不能去继承B了，因为假如A类中有一个方法叫run(),B类中也具有一个方法叫run()，那么子类就不知道继承那个方法好了，就会发生错误。JAVA为了解决这样的问题，就有了接口。接口可以理解为一个抽象类，里面的方法都是抽象的，关键字是interface。JAVA支持多接口。为什么支持多接口，而不支持多继承呢？因为接口类里面的方法都是抽象的，我实现接口A之后就要对A里面的方法进行覆写，同时实现接口B也要对接口B里面的方法进行覆写，这样就不会发生冲突了。这就是接口。

这里面的每个sleep()方法前面还要加上void表示没有返回值！

唉。。这个题目真抽象，我也以厕所来说说自己的看法吧
传说以前没有厕所，大家都随地又随意，这苦恼了上帝，于是他构想着发明一个东西。
abstract class 厕所 {
    String name=“厕所” //这东西就叫厕所了
    String 地方;
    厕所(String 地方){  //注意，这虽然是构造方法，但实际不能被直接new 厕所()来调用，只能是他的子类来调用
         厕所.地方=地方
    }
   
    abstract 气味 想到厕所(); //定义抽象方法：想到厕所，返回"气味"

}
----------------------------------------------------------
厕所就这样发明了，不过还是个概念，需要有人以这个概念去做设计图再修建
于是有了
class 公厕设计图 extends 厕所
    String name 厕所名字
    公厕设计图(String 地方){
     super(地方); //调父类构造
    }
   男厕所(String 地方,int 面积大小) {
   }
   女厕所(String 地方,int 面积大小) {
   }
   @override
   public 气味 想到厕所() { //重写
     return "臭味" ;
   }
   public 收费 (){
     ....
   }
}
--------------------------------------
设计图有了，现在创建实例

new  公厕设计图(北京)

//于是终于有了个匿名厕所
---------------------------------------------
后来，厕所可以评星了，五星级厕所，政府规定必须没有臭味，还得有马桶，还得有音乐，于是政府出台了一个接口,所有实现此接口的都 是五星级厕所
interface 五星厕所(){
    马桶 建马桶(int 个数)  
    音乐 放音乐()
    气味 想到厕所()
}
于是，上面的公厕要升级五星于是需要
class 公厕设计图 extends 厕所 implements 五星级厕所{
   ....
   马桶 建马桶(int 个数) {
     新建 个数 个马桶
   }
   音乐 放音乐() {
      放XXX歌;
   }
   气味 想到厕所(){
    return 返回香味
   }
}
--------------------------------
好设计图改了，来按着他建立个厕所
厕所1 =new 公厕设计图(北京)

抽象类和接口很像都不能被实例化，都可以包含抽象方法。接口一旦在系统中改变，系统中的部分类都需要改写。他们在方法上有所差别：
1.接口和抽象类定义就不同：接口定义不使用class关键字而是使用interface关键字抽象类需用关键字abstract修饰符来定义。
2.接口里只能包含abstract抽象方法，抽象类中可以包含普通方法；接口里不允许使用static修饰接口中的方法，抽象类可以使用。//系统自动为接口定义的方法增加abstract修饰符；

3.接口里只能定义静态常量属性，不能定义普通属性，抽象类则什么都可定义；//系统自动为接口定义的的属性增加public static final修饰符；
4.接口不包含构造方法，抽象类可以包含构造方法，但不是用于创建对象
而是让其子类调用来完成属于抽象类的初始化操作；

5.接口里不能包含初始化块，但抽象类可以；

6.以各类最多只能有一个直接父类包括抽象类，但可以直接实现多个接口；

bucuo........