abstrac和interface

一、抽象类：abstract

抽象类就是为了继承而存在的，如果你定义了一个抽象类，却不去继承它，那么等于白白创建了这个抽象类，因为你不能用它来做任何事情。对于一个父类，如果它的某个方法在父类中实现出来没有任何意义，必须根据子类的实际需求来进行不同的实现，那么就可以将这个方法声明为abstract方法，此时这个类也就成为abstract类了。

格式如下

　　包含抽象方法的类称为抽象类，但并不意味着抽象类中只能有抽象方法，它和普通类一样，同样可以拥有成员变量和普通的成员方法。注意，抽象类和普通类的主要有三点区别：

　　1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public。

　　2）抽象类不能用来创建对象，但是它可以有构造方法，用来帮助子类实例化。

　　3）如果一个类继承于一个抽象类，则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

抽象类的具体实例如下：

//定义一个抽象类,切记它不能用来创建对象
abstract class Employee
{
        //声明受保护的属性
    protected String name;
    protected String id;
    protected double pay;

        //抽象类的构造方法
    public Employee(String name,String id,double pay)
    {
          this.name = name;
          this.id = id;
          this.pay = pay;
    }
        //抽象类的普通成员方法
    public void print()
    {
     System.out.println("name = "+name+"id = "+id+"pay = "+pay);
    }

        //抽象类的抽象方法，子类必须实现该方法，不然子类也是抽象类
    public abstract void work();
}

//抽象类的一个子类
class Pro extends Employee
{
    public Pro(String name,String id,double pay)
    {
       //调用父类的构造函数进行初始化
       super(name,id,pay);
    }
    //实现了父类中的抽象方法,所以子类不再是抽象类
    public void work()
    {
       System.out.println("Pro work");
    }
}    

//抽象类的另一个子类
class Manager extends Employee
{
    private double bonus;
    public Manager(String name,String id,double pay,double bonus)
    {
      //调用父类的构造方法进行初始化
      super(name,id,pay);
      this.bonus = bonus;
    }
    //实现了父类中的方法,所以子类不再是抽象类
    public void work()
    {
     System.out.println("Manager work");
    }
}

//测试类
class YuanGongDemo
{
    public static void main(String[] args)
    {
      Pro p1 = new Pro("Liding","jfisd",578.5);
      p1.work();
      Manager p2 = new Manager("LiNing","技术部",4578.5,786.75);
      p2.work();
    }
}

二、接口：Interface

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

接口的主要特点：

1、接口中的成员变量默认都是public、static、final类型的，必须被显示初始化。

2、接口中的方法默认都是public、abstract类型的。

3、接口中只能包含public、static、final类型的成员变量和public、abstract类型的成员方法。

4、接口没有构造方法，不能被实例化。

5、一个接口不能实现另一个接口，但它可以继承多个其他接口。

6、接口必须通过类来实现它的抽象方法。

7、与子类继承抽象父类相似，当类实现了某个接口时，它必须实现接口中所有的抽象方法，否则这个类必须被定义为抽象类。

8、一个类只能继承一个直接的父类，但能实现多个接口。

接口声明和实现方式如下：

具体举例如下：

多态的功能扩展
基于电脑的实例（电脑主板）
扩展（网卡、声卡、、、）

interface PCI             //扩展功能的接口（规则）
{
    public abstract void open();
    public abstract void close();
}

class MainBoard
{
    public void run()
    {
        System.out.println("Mi anBoard run");
    }
    public void usePCI(PCI p)  //PCI p = new NetCard() //接口型的引用指向自己的子类对象
    {
        p.open();
        p.close();
    }    

}

class NetCard implements PCI     // 实现网卡的连接
{
    public void open()
    {
      System.out.println("NetCard open");
    }
    public void close()
    {
       System.out.println("NetCard close");
    }
}

class SoundCard  implements PCI    // 实现声卡的连接
{
    public void open()
    {
      System.out.println("soundcard open");
    }
    public void close()
    {
       System.out.println("soundcard close");
    }
}

class DuoTaiDemo1   //测试类
{
    public static void main(String[] args)
    {
        MainBoard mb = new MainBoard();
        mb.run();
        mb.usePCI(new NetCard());
        mb.usePCI(new SoundCard());
    }
}

总结：抽象类和接口的区别

1）抽象类可以提供成员方法的实现细节，而接口中只能存在public abstract 方法；

　　 2）抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的；

　　 3）接口中不能含有静态代码块以及静态方法，而抽象类可以有静态代码块和静态方法；

　　 4）一个类只能继承一个抽象类，而一个类却可以实现多个接口。

5）抽象类中的方法子类必须全部实现,不然子类也是抽象类,而接口中的抽象方法子类必须全部实现,是可选择实现的。

6）抽象类是一种模板设计模式,而接口是一种行为规范。