Java基础系列19-接口interface

x33g5p2x  于2021-12-18 转载在 其他  
字(3.5k)|赞(0)|评价(0)|浏览(449)

一.接口概述

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

继续回到我们的猫狗案例,我们想想狗一般就是看门,猫一般就是作为宠物了。
  但是,现在有很多的驯养员或者是驯兽师,可以训练出:猫钻火圈,狗跳高,狗做计算等。而这些额外的动作,并不是所有猫或者狗一开始就具备的,这应该属于经过特殊的培训训练出来的。
  所以,这些额外的动作定义到动物类中就不合适,也不适合直接定义到猫或者狗中,因为只有部分猫狗具备这些功能。
  所以,为了体现事物功能的扩展性,Java中就提供了接口来定义这些额外功能,并不给出具体实现,将来哪些猫狗需要被训练,只需要这部分猫狗把这些额外功能实现即可。

二.接口的特点

接口的特点:

  1. 接口格式
  1. public interface 接口名 {}

类实现接口 (用 implements 表示)

  1. public class 类名 implements 接口名 {}
  1. 特点
    1)接口不能实例化
    2)那么,接口如何实例化呢?
      按照多态的方式,由具体的实现类实例化。其实这也是多态的一种,接口多态。
    3)接口的实现类
      要么是抽象类
      要么重写接口中的所有抽象方法

代码:
interface1

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 跳高接口 接口的特点
  7. *
  8. */
  9. public interface interface1 {
  10. //抽象方法
  11. public abstract void jump();
  12. }

interface2

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 跳高接口的实现类-猫类 接口的特点
  7. *
  8. */
  9. public class interface2 implements interface1 {
  10. @Override
  11. public void jump() {
  12. System.out.println("猫可以跳高了");
  13. }
  14. }

interface3

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 跳高接口的实现类-狗类 接口的特点
  7. *
  8. */
  9. public abstract class interface3 implements interface1 {
  10. }

interface4

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 跳高接口的实现类-测试类 接口的特点
  7. *
  8. */
  9. public class interface4 {
  10. public static void main(String[] args) {
  11. //C:接口不能实例化
  12. //interface1 i1 = new interface1();
  13. //c1:参照多态的形式使用实现类来实例化。
  14. interface1 jumpping = new interface2();
  15. jumpping.jump();//猫可以跳高了
  16. }
  17. }

三. 接口的成员特点

成员变量:
  只能是常量
  默认修饰符 public static final

构造方法:
  没有,因为接口主要是扩展功能的,而没有具体存在

成员方法:
  只能是抽象方法
  默认修饰符 public abstract

代码:
interface5

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 接口类 接口的成员特点
  7. *
  8. */
  9. public interface interface5 {
  10. public int num1 = 10;
  11. public final int num2 = 20;
  12. public static final int num3 = 30;
  13. //接口没有构造器
  14. //public interface5() {}
  15. //接口不能有方法体
  16. //public void show() {}
  17. //接口的抽象方法
  18. public abstract void method();
  19. }

interface6

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 接口类的实现类 接口的成员特点
  7. *
  8. */
  9. public class interface6 implements interface5 {
  10. public interface6() {
  11. super();
  12. }
  13. @Override
  14. public void method() {
  15. }
  16. }

interface7

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 接口类的测试类 接口的成员特点
  7. *
  8. */
  9. public class interface7 {
  10. public static void main(String[] args) {
  11. //按照多态的形式创建接口对象
  12. interface6 i1 = new interface6();
  13. //interface5.num1 = 30; //无法为最终变量num1分配值
  14. //System.out.println(i1.num);
  15. //i.num2 = 40;//无法为最终变量num2分配值
  16. //System.out.println(i.num2);
  17. System.out.println(interface6.num1);//10
  18. System.out.println(interface6.num2);//20
  19. }
  20. }

四. 类与类_类与接口_接口与接口的关系

类与类:
  继承关系,只能单继承,但是可以多层继承

类与接口:
  实现关系,可以单实现,也可以多实现。还可以在继承一个类的同时实现多个接口

接口与接口:
  继承关系,可以单继承,也可以多继承

代码:
interface8

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 父类接口1 类与类_类与接口_接口与接口的关系
  7. *
  8. */
  9. public interface interface8 {
  10. }

interface9

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 父类接口2 类与类_类与接口_接口与接口的关系
  7. *
  8. */
  9. public interface interface9 {
  10. }

interface10

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 子类1 类与类_类与接口_接口与接口的关系
  7. *
  8. */
  9. public class interface10 extends Object implements interface8,interface9 {
  10. }

interface11

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 子类2 类与类_类与接口_接口与接口的关系
  7. *
  8. */
  9. public class interface11 extends interface10 implements interface8,interface9 {
  10. }

interface12

  1. package Java_study;
  2. /**
  3. *
  4. * @author 只是甲
  5. * @date 2021-06-28
  6. * @remark 测试类 类与类_类与接口_接口与接口的关系
  7. *
  8. */
  9. public class interface12 {
  10. public static void main(String[] args) {
  11. //实例化对象
  12. interface11 sister = new interface11();
  13. //c1:参照多态的形式使用实现类来实例化。
  14. interface8 son = new interface10();
  15. }
  16. }

五. 抽象类与接口的区别

  1. 成员区别
    抽象类:
    1)成员变量:可以是变量,也可以是常量
    2)构造方法:有构造方法
    3)成员方法:可以是抽象方法,也可以是非抽象方法
    接口:
    1)成员变量:只能是常量
    2)构造方法:没有构造方法
    3)成员方法:只能是抽象方法
  2. 关系区别
    1)类与类:继承关系,只能单继承,可以多层继承
    2)类与接口:实现关系,可以单实现,也可以多实现
    3)接口与接口:继承关系,可以单继承,也可以多继承
  3. 设计理念的区别
    1)抽象类 被继承体现的是:"is a"抽象类中定义的是继承体系的共性功能
    2)接口 被实现体现的是:“like a” 接口中定义的是该体系的扩展功能
  4. 举例
    1)猫,动物
    2)猫,跳高运动员

参考:

  1. https://blog.csdn.net/qq_43529621/article/details/115303081
上一篇:抽象类abstract
下一篇:包package

相关文章