java中抽象类和接口的区别

抽象类和接口

一、抽象类

• 抽象类和具体类的关系就是一般类和特殊类之间的关 is-a ，在继承体系中对外提供抽象的子类公共的行为接口
• 抽取共同行为接口，抽取可复用的变量

public abstract class Shape {
   protected double x,y,z; //子类可见
   //抽象方法
   abstract public double getArea();
   abstract public double getPerimeter();

   //抽象类可以有构造方法，初始化从父类继承的实例变量
   public Shape(double x,double y,double z){
     this.x = x;
     this.y = y;
     this.z = z;
   }
}


public class Rect extends Shape {
  public Rect(double height, double width) { super(height,width, 0.0); }
  public double getArea(){
     return x * y;
  }
  public double getPerimeter(){
     return (x + y)*2;
  }
}


public class Circle extends Shape{
   public Circle(double radius){
       super(radius,0.0,0.0);
   }
   public double getArea(){ 
        return( x * x *Math.PI);
   }
   public double getPerimeter(){
        return(2*Math.PI* x);
   }}

public class Triangle extends Shape {
 public Triangle(double lenX,double lenY,double lenZ){
       super(lenX, lenY, lenZ);
 }
  public double getArea(){
     double m= (x + y+ z)/2.0;
     return Math.sqrt(m*( m-x)*( m-y)*(m-z));
  }
  public double getPerimeter(){
      return x + y + z;
  }}


public class TestShape {
   public static void main(String[] args) {
   Rect rect = new Rect(25,25);
   Triangle tri = new Triangle(5,5,8);
   Circle cir = new Circle(12.5);
   printArea(rect);
   printPerimeter(rect);
   printArea(tri);
   printPerimeter(tri);
   printArea(cir);
   printPerimeter(cir);
  }

   public static void printArea(Shape s){
       System.out.println(s.getClass().getName() +
                         " Area:"+s.getArea());
  }
   public static void printPerimeter(Shape s){
       System.out.println(s.getClass().getName() +
                         "Perimeter:"+s.getPerimeter());
  }
}

二、接口

• 接口的设计用途：通用可扩展代码，多态体现

public interface  Washer {
    public static final int ON = 1 ;
    public static final int OFF = 0 ;
    abstract void startUp();     //启动  
    abstract void letWaterIn();  //进水
    abstract void washClothes(); //洗衣
    abstract void letWaterOut(); //排水
    abstract void stop();        //停止
}

class RoseBrand implements Washer{
    public  void startUp(){System.out.println("startUp");}
    public  void letWaterIn(){System.out.println("letWaterIn");}
    public  void washClothes(){System.out.println("washClothes");}
    public  void letWaterOut(){System.out.println("letWaterOut");}
    public  void stop(){System.out.println("stop");}
    public  void dehydrate(){System.out.println("dehydrate ");}//脱水
}


public class Consumer {
  public static void main(String args[]){
      //接口声明引用实现接口的RoseBrand类的对象。
      Washer  w = new RoseBrand();
      w.startUp();
      w.letWaterIn();
      w.washClothes();
      w.letWaterOut();
      w.stop();
      //w.dehydrate ();当通过接口调用玫瑰洗衣机类独有的，  
                     //接口未定义的功能方法，编译会报错。
  }  
}

三、两者区别

共同点：

• 二者都可具有抽象方法
• 都不能实例化，但都可有自己的声明，并能引用子类或实现类对象。

不同点：

抽象类在被继承时体现的是 is a 的关系，接口在被实现时体现的是 can do 的关系

本篇文章只举例说明了两者的不同，详细内容请点击 => 多态详细讲解