接口

最新推荐文章于 2024-12-24 14:49:58 发布

luotianyi1

最新推荐文章于 2024-12-24 14:49:58 发布

阅读量123

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/luotianyi1/article/details/105331386

* 接口的语法
 *   1. 在Java语言中interface也可以表示一种类型
 *      a. 我们的自己定义的一个类，就表示java语言中的一种数据类型
        b. 我们自己定义的一个接口，也表示java语言中的数据类型

        从数据类型的角度，类和接口，地位是平等，都表示数据类型，但是它们的侧重点不同：
        a. 类这种数据类型，描述的是一组数据集合(成员变量)和基于这个数据集合的 一组操作
           ，这一组操作，它们有联系(间接)，都操作同一个数据集合

        b. 接口这种数据类型，首先接口这种数据类型，并不关心数据集合，
           它关心的仅仅只是一组特殊的操作(方法)，这些特殊操作，没有直接关系，接口中
           定义的行为，非常的松散
 *
 *  接口语法：
    2.接口用关键字interface表示
      格式：interface 接口名 {}

      同时，接口的抽象程度比我们的抽象类高，接口中只能定义一种方法, 就是抽象方法(使用JDK8以前)


    接口和类的关系：
    3.类和接口的关系，类实现接口有实现关系， 用 implements 表示
      类和接口的实现关系, 其实是一种实质上的继承关系

    格式： class 类名 implements 接口名 {}


    接口的特征：
    1. 接口不能直接实例化, 但是接口可以间接实例化
       接口类型 引用变量 = new 接口子类类型();

    2. 接口的子类
         可以是抽象类
         也可以是具体类(必须是实现接口中所有的抽象方法)

 */

代码示例：

public class Demo1 {

  public static void main(String[] args) {
    //接口不能直接实例化
    //MyInterface myInterface = new MyInterface();

    //接口可以间接实例化
    MyInterface myInterface = new MyClass();

  }


}

/*
     这就是一个接口，同时也代表一种数据类型
 */
interface MyInterface {

  // 接口中不能定义普通方法，有方法体的方法
//  public void test() {
//    System.out.println("hello interface");
//  }

  // 接口中只能定义抽象方法
  public abstract void testInterface();

 // public abstract void work();
}

//abstract
class MyClass implements MyInterface {

   @Override
   public void testInterface() {
     System.out.println("hello interface");
   }
 }


* 抽象类和接口的比较
    成员区别
    抽象类  成员变量可以是变量可以是常量;
           成员方法 有抽象方法;，非抽象方法
    接口   成员变量 常量 public final static
          成员方法：抽象方法(JDK8以前的代码)

    关系区别
    类与类 继承，单继承
    类与接口 实现，单实现，多实现(一个类，可以实现一个接口，也可以同时实现多个接口)
    接口与接口 继承，单继承，多继承

    设计理念区别
    抽象类
     a.体现的子类和父类：”is a”的关系。
       因为在java语言中，一个类只能继承另一个类，把一个子类类型看做父类类型
     b.描述的是子类和父类共性

    接口
    a. 被实现, 体现的是：”like a”的关系。
       因为java语言中，一个类可以实现 多个 接口，每个接口，
      都相当于给这个类，打开了一扇小小的窗户

     通常，一个接口很难反映出一个类的全貌，换句话说我们认为接口
     只会放映一个类的冰山一角，所以我们通常我们只能说 一个类 like a 接口

    b. 描述的是一个额外的功能的结合，接口通常用来，给类扩展功能

代码示例：

public class Demo1 {

  public static void main(String[] args) {
    Inter1 inter1 = new Son();
    inter1.show1();

    Inter2 inter2 = new Son();
    inter2.show2();
  }

}

class Father {

  public void fatherDo() {
    System.out.println("father DO");
  }

  public void work() {
    System.out.println("work");
  }
}

interface Inter1 {

  void show1();
}

interface Inter2 {
  void show2();
}
class Son extends Father implements Inter1, Inter2 {

  @Override
  public void show1() {
    System.out.println("show1 in son");
  }

  @Override
  public void show2() {
    System.out.println("show2 in son");
  }
}

 * jdk8 中提供了两种特殊的方法：
 * 1. 默认方法
 * 2. 静态方法
 *
 * 他们在接口中，都可以有方法体，方法实现
 *
 * 默认方法，其实是java语言的一种折中，接口添加默认方法，不会影响所有实现了该接口的子类
 * 静态方法, 使用场景，通常作为工具方法
 *         a. 定义该静态方法的类中使用
 *         b. 通过定义该静态方法的接口名. 访问静态方法
 *

代码范例：

public class Demo1 {

  public static void main(String[] args) {
    MyInterface.testStatic();
  }

}

interface JDK8Interface {

  // 默认方法
//  default void testDefault() {
//    System.out.println("hello defatul method");
//  }

  //静态方法
//  static void toolMethod() {
//    System.out.println("hello static");
//  }

  // 在接口中，普通方法没有方法体
//  public void test() {
//
//  }



}

interface MyInterface {

  void test();

  //void show(); 在接口中添加抽象方法，会影响所有和该接口有关的类
  // default 关键字表示方法类型是默认方法，和权限没有关系
  default void show() {
    //默认实现
    System.out.println();
    testStatic();
  }

  // 工具方法使用
  static void testStatic() {
    System.out.println("static");
    // 静态上下文不能访问非静态的成员
   // show();
  }

}

class A implements MyInterface {

  @Override
  public void test() {
    System.out.println("A test()");
//    show();
  }

  @Override
  public void show() {
//    testStatic(); // 对于接口中的静态方法而言，只能在定义该静态方法的类
  }
}

abstract class B implements MyInterface {
  @Override
  public void test() {
    System.out.println("B test()");
    //show();
  }

  /*
       在子类中还可以把默认方法覆盖成抽象方法
   */
  @Override
  public abstract void show();
}

 * 接口的特点
    1. 无构造方法：没有构造方法
    2. 成员变量：只能是常量，修饰符public static final
               对于接口而言，定义的成员变量，默认的修饰符就是public static final

    3. 成员方法：只能是抽象方法，修饰符public abstract
                接口中的方法声明，默认修饰符public abstract

代码说明：

public class Demo1 {

  public static void main(String[] args) {

    //接口的中的成员变量是被 public static final
    //System.out.println(MemberInterface.a);
    //MemberInterface.a = 200;

  }

}

interface MemberInterface {

  //接口中没有构造方法
  //public MemberInterface() {}

  //定义成员变量
  int a = 100;

  //定义成员方法
  void method();
}

 * 在java语言中：
 * 1. 类与类之间，只能是单重继承，extends关键字后面只能跟一个类名
 *
 * java语言声称自己实现了多重继承？
 * 1. 仅从接口的角度来理解  接口与接口之间，可以实现多重继承
 * 2. 一个完整的类定义，除了可以声明一个类继承其他的某各类，除此之外
 *    我们还可以让该类，实现多个接口
 *
 *    就好像实现了多重继承
 *

代码说明：

public class Demo1 {

}

interface FirstInterface {
  void first();
}

interface SecondInterface {
  void second();
}

interface ThirdInterface extends FirstInterface, SecondInterface {}

class A implements ThirdInterface {

  @Override
  public void first() {

  }

  @Override
  public void second() {

  }
}




class B {
  public void doSomething() {
    System.out.println("doSomething");
  }
}

/*
    演示一个完整的类定义
 */
class CompleteClass extends B implements FirstInterface, SecondInterface {

  @Override
  public void first() {

  }

  @Override
  public void second() {

  }
}

练习示例：

* 教练和运动员案例

    乒乓球运动员和足球运动员。

    乒乓球教练和足球教练。

    为了出国交流，跟乒乓球相关的人员都需要学习英语。
    请用所学知识：
    分析，这个案例中有哪些抽象类，哪些接口，哪些具体类。

      乒乓球运动员
      属性：name, age, salary
      行为：eat(), sleep(), train(), match(), learnEnglish();

      乒乓球教练
      属性：name, age, salary,bonus
      行为：eat(), sleep(), teach(), learnEnglish()

      足球运动员
      属性：name, age, salary
      行为：eat(), sleep(), train(), match()

      足球教练
      属性：name, age, salary, bonus
      行为：eat(), sleep(), teach()

    如何描述：
    所有人的共性： 定义一个父类(具体父类)  其实是人的共性 Human
    1. 发现乒乓球运动员，乒乓球教练，足球运动员 足球教练有相同的属性 name, age, salary
    2. 发现乒乓球运动员，乒乓球教练，足球运动员 足球教练有相同的行为eat(), sleep()

    运动员有相同的行为： Athlete 描述运动员描述相同的行为(Athlete 抽象类)
    train(), match()，但实现，不同类型的远动员，训练和比赛的内容不同

    教练员有形同的属性性和行为：Coach 教练员的bonus属性，以及teach()方法声明（抽象类）
    a. bonus 属性
    b. teach() 但是，不同类型的教练，教的内容的不容

    有一种特殊的行为，学习英语的行为，这属于运动员额外的特殊技能
    而且，跟乒乓球相关的人员相关的人才需要有这样的特殊技能
 */

代码：

public class Exercise {
}

/*
    人具有的共性
 */
class Human {

}

/*
  描述运动员的类
 */
abstract class Athlete extends Human {
  public abstract void train();
  public abstract void match();
}

/*
    描述教练员
 */
abstract class Coach extends Human {
  private int bonus;

  public int getBonus() {
    return bonus;
  }

  public void setBonus(int bonus) {
    this.bonus = bonus;
  }

  public abstract void teach();

}


/*
    乒乓球运动员
 */
class TableTennisAthlete extends Athlete implements SpecialSkill  {

  @Override
  public void train() {

  }

  @Override
  public void match() {

  }

  @Override
  public void learningEnglish() {

  }
}

/**
 *    乒乓球教练
 */
class TableTennisCoach extends Coach implements SpecialSkill {

  @Override
  public void teach() {

  }

  @Override
  public void learningEnglish() {

  }
}


/**
 *    足球运动员
 */
class FootballAthlete extends Athlete{

  @Override
  public void train() {

  }

  @Override
  public void match() {

  }
}

/*
    足球教练
 */
class FootballCoach extends Coach {

  @Override
  public void teach() {

  }
}

interface SpecialSkill {

  void learningEnglish();
}