面向接口编程

接口：

//接口:一种完全的抽象类，里面所有的方法都是抽象的,所有的变量都是静态常量。
//为了表示这个类和普通抽象类的不同，我们把它定义成接口
/*
public abstract class Area {
  public static final double PI=3.14;
  public abstract double area();    
}
*/

/*完整的写法
public interface Area{
  public static final double PI=3.14;
  public abstract double area();
}
*/
//简化的写法
public interface Area{
    double PI=3.14; //接口中的变量全是静态常量，即使我们不手动写，Java也会帮我们自动添加：public static final
    double area();//接口中的方法全是公共抽象的，即使我们不手动写，Java也会帮我们自动添加：public abstract
    public abstract void aa();
  int x=3;
}

//接口之所以会成软件设计的第一原则(面向接口编程)，就是因为它有"封装隔离功能"

//一个类要实现接口，那么接口中的所有抽象方法必须都要实现，否则只能声明成抽象类
public class Rectangle implements Area {
  private int width;
  private int height;
  public Rectangle(int width,int height){
    this.width=width;
    this.height=height;
  }
  public double area(){
    return width*height;
  }
  public String toString(){
    return "矩形，高："+height+",宽："+width+",面积："+area();
  }
  /*
  public void aa(){
    System.out.println(PI);
    //x++. //WA:接口中的变量全是静态常量，不能拿修改值
  } 
  */
}

public interface  Volume {
  public abstract double volume();
}

//Java中，类只能单继承，接口可以多继承、多实现
public class Cuboid extends Rectangle implements Volume {
  private int length;
  public Cuboid(int length,int width,int height ){    
    super(width,height);
    this.length=length;
  }
  
  public double volume(){
    return length*area();
  }  
  
  //父类的area()方法不符合子类的工程需要，因此要覆盖它
  public double area(){
    return (length*width+length*height+width*height)*2;
  }

}



public class Run {
  public static void main(String[] args) {
    Area g = new Rectangle(10,20);
    System.out.println(g.toString());
    //g.aa();
    Area g2 = new Cuboid(10,20,30);
    System.out.println("长方体面题："+g2.toString());
    
    //下一句是WA,原因：g2是Area类型，编译时多态限制它只能调用Area类中的方法,后者当中没有volume()方法----接口的封装隔离功能
      //System.out.println("长方体体积:"+ g2.volume() );
       
       Volume v =(Volume)g2;
       System.out.println("长方体体积："+v.volume());
  }
}