Java基础接口

public class InterfaceTest01{
  public static void main(String[] args){
  //输出常量
  System.out.println(MyMath.PI);
  //编译报错，无法为最终变量PI分配值
  //MyMath.PI = 15.2;
  System.out.println(MyMath.k);
  // MyMath.k = 111;
  }
}
//接口A
interface A{
}
//接口可以单继承
interface B extends A{
}
//接口可以多继承
interface c extends B,A{
}
//我的数学接口
interface MyMath{
  //常量
  public static final double PI = 3.1415926;
  //public static final 可以省略吗？[可以]
  //double PI = 3.1415926;//编译通过
  //k是不是常量？？？是
  //接口中随便写一个变量就是常量
  //常量：值不能发生改变的常量
  int k = 80;
  //抽象方法
  public abstract int sumInt(int a,int b);
  //public abstract 可以省略并且接口中的方法不能带有主体
    int sum(int x,int b);
}

public class InterfaceTest02{
  public static void main(String[] args){
  //接口可以使用多态
  //父类型的引用指向子类型的对象
  MyMath mm = new MyMathImpl();
  //调用接口里面的方法(面向接口编程)
  int result1 = mm.sum(10,20);
  System.out.println(result1);
  int result2 = mm.sub(20,10);
  System.out.println(result2);
  }
}
//特殊的抽象类，完全抽象的，叫做接口
interface MyMath{
  double PI = 3.1415926;
  int sum(int a,int b);
  int sub(int a,int b);
}
// 这样没问题
/*
abstract class MyMathImpl implements MyMath {
}
*/
//编写一个类(这个类是一个“非抽象”的类)
//此类名字随意
//错误：MYMathImpl不是抽象的，并且未覆盖MyMath中的抽象方法sub（int，int）
//class MyMathImpl implements MyMath{}
class MyMathImpl implements MyMath{
  //错误：正在尝试分配更低的访问权限; 以前访问权限为public【访问权限控制符】
  /*
  int sum(int a, int b){
  return a + b;
  }
  */
  // 重写/覆盖/实现 接口中的方法（通常叫做实现。）
  public int sum(int a,int b){
  return a + b;
  }
  public int sub(int a,int b){
  return a - b;
  }
}

public class InterfaceTest03{
  public static void main(String[] args){
    // 多态该怎么用呢？
    // 都是父类型引用指向子类型对象
    A a = new D();
    B b = new D();
    C c = new D();
    //a.m2(); // 编译报错。A接口中没有m2()方法。
    // 这个编译没问题，运行也没问题。
    // 调用其他接口中的方法，你需要转型（接口转型。）
    B b2 = (B)a;
    b2.m2();
    // 直接向下转型为D可以吗？可以
  D d = (D)a;
  d.m2();
       m m = new e();
    // 经过测试：接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强转。
    // 但是一定要注意，运行时可能会出现ClassCastException异常。
    // 编译没问题，运行有问题。
    //k k = (k)m;
       if(m instanceof k){
     k k = (k)m;
    }    
  }
}
interface X{
}
interface Y{
}
interface Z extends X,Y{ //接口和接口支持多继承。
}
interface k{
}
interface m{
}
class e implements m{
}
interface A{
  void m1();
}
interface B{
  void m2();
}
interface C{
  void m3();
}
// 实现多个接口，其实就类似于多继承。
class D implements A,B,C{
    public void m1(){
  }
    public void m2(){
  System.out.println("m .....");
  } 
  public void m3(){
  } 
}

public class InterfaceTest04{
  public static void main(String[] args){
  // 创建对象（表面看Animal类没起作用！）
  Flyable f = new Cat();//多态。
  f.fly();
  // 同一个接口
  Flyable f2 = new Fish();
  // 调用同一个fly()方法，最后的执行效果不同。
  f2.fly();
  }
}
// 动物类：父类
class Animal{
}
// 可飞翔的接口（是一对翅膀）
// 能插拔的就是接口。（没有接口你怎么插拔。）
// 内存条插到主板上，他们之间有接口。内存条可以更换。
// 接口通常提取的是行为动作。
interface Flyable{
  void fly();
}
// 动物类子类：猫类
// Flyable是一个接口，是一对翅膀的接口，通过接口插到猫身上，让猫变的可以飞翔。
class Cat extends Animal implements Flyable{
  public void fly(){
  System.out.println("我是一只猫，我在太空翱翔，我喜欢飞！");
  }
}
// 蛇类，如果你不想让它飞，可以不实现Flyable接口
// 没有实现这个接口表示你没有翅膀，没有给你插翅膀，你肯定不能飞。
class snake extends Animal{
}
// 想飞就插翅膀这个接口。
// 鱼（默认实际上是存在继承的，默认继承Object。）
/*
class Fish extends Object implements Flyable{
}
*/
class Fish implements Flyable{//没写extends，也是有的，默认继承Object。
  public void fly(){
  System.out.println("我是一只鱼，我学会了飞！(六眼飞鱼！)");
  }
}