zoukankan      html  css  js  c++  java
  • java学习面向对象之接口

    上一节当中我们说道抽象类,抽象类当中的方法可以是抽象的也可以是非抽象的,那么当抽象类中所有方法都是抽象的时候,我们就可以把它重新定义为接口。代码示例:

    1 abstract class Animal
    2 {
    3 
    4     abstract void eat();
    5     abstract void goToBed();
    6 
    7 }

    上述代码写成接口的形式为:

    1 interface Animals
    2 {
    3 
    4     public void eat();
    5     public void goToBed();
    6 
    7 }

    在接口当中的方法,也只能是方法名称,没有方法体。

    类与类当中存在的关系是继承关系,那么类与接口之间是什么关系呢?类与接口之间的关系就是实现的关系,类实现接口。类与类当中只能够单继承,作为体系的扩展延伸,但是类与接口之间的实现,就对类做了功能上的扩展。同时接口的出现,也是java支持多继承的表现。虽然java不支持类的多继承,但是java中接口是可以多实现的,也就是说可以做到跟多继承相像的多功能上的扩展。并且,实现和继承是可以同时实现的。

    类与接口的实现:

    比如我们现在有个笔记本电脑,笔记本电脑是继承自电脑的,具有电脑所有的功能,但是笔记本本身又特有,折叠这个特殊的功能。我们可以这样定义,笔记本电脑继承自电脑这个抽象类,同时实现了折叠的这个功能。我们用代码来体现下:

     1 /**
     2 *抽象类Pc抽取出了Pc当中必须实现的
     3 *一些功能
     4 */
     5 abstract class Pc
     6 {
     7     /**
     8     *抽象类方法connectNet(),实现连接网络的方法
     9     *没有返回值
    10     */
    11     abstract void connectNet();
    12     /**
    13     *抽象类方法hasMouse(),实现电脑都有鼠标的功能
    14     *没有返回值
    15     */
    16     abstract void hasMouse();
    17 
    18 }
    19 
    20 
    21 /**
    22 *接口ZheDie,提供折叠的功能
    23 */
    24 interface ZheDie
    25 {
    26     /**
    27     *zheDie()提供折叠的方法
    28     *没有返回值
    29     */
    30     public abstract void zheDie();
    31 
    32 }
    33 
    34 /**
    35 *笔记本电脑继承了电脑这个体系,证明笔记本电脑是属于电脑的
    36 *,具有电脑的所有功能以及属性。同时他又实现了折叠,这个特殊的
    37 *功能。
    38 */
    39 class BookPc extends Pc implements ZheDie
    40 {
    41     /**
    42     *实现了连网功能
    43     */
    44     public void connectNet()
    45     {
    46 
    47         System.out.println("BookPc can connectNet");
    48 
    49     }
    50     /**
    51     *实现了鼠标功能
    52     */
    53     public void hasMouse()
    54     {
    55 
    56         System.out.println("BookPc has a Mouse");
    57 
    58     }
    59     /**
    60     *实现了折叠的功能
    61     */
    62     public void zheDie()
    63     {
    64 
    65         System.out.println("BookPc can be zheDie");
    66 
    67     }
    68 
    69 }
    70 
    71 class InterDemo2
    72 {
    73 
    74     public static void main(String[] args) {
    75         
    76         new BookPc().zheDie();
    77 
    78     }
    79     
    80 
    81 }

    接口当中除了有方法之外,还可以有属性:

    1 interface Demo
    2 {
    3 
    4     public static final int a = 10;
    5 
    6 }

    那么接口都有哪些细节需要注意呢?

    1、接口不同于类,接口的定义方法是interface关键字不是class关键字。

    2、接口只能被类用implement关键字实现不能被类继承,但是接口与接口之间可以被继承

    3、接口可以实现类的多继承,也就是多实现。

    4、接口中的方法都是抽象的并且是公开的,包括属性,也就是接口当中的属性还有方法前面的修饰词都是固定的。如果不加修饰词的情况下,在编译的时候会给加上的。

    5、接口当中的方法还有成员变量都是公开的。成员函数用public abstract修饰,成员变量用public static final 修饰。因为类是实现接口,而不是继承接口。

    6、接口当中的方法,必须被要实现这个接口的类全部实现。否则,这个实现了这个接口的类就是一个抽象类。

    7、接口的出现,避免了单继承的局限性

    java利用接口实现多继承:

    在java当中不支持多继承,因为这样存在不确定性方法一样,不知道调用哪个?。但是java当中为了支持多继承,就用了“多实现”。多继承的意义存在于:提供功能,提高扩展性。

    一个类可以实现多个接口。

     1 interface A
     2 {
     3 
     4     public void show1();
     5 
     6 }
     7 
     8 interface B
     9 {
    10 
    11     public void show2();
    12 
    13 }
    14 
    15 class Test implements    A,B //这个地方就体现了java通过多实现的方式,实现了多继承
    16 {
    17 
    18     public void show1()
    19     {
    20 
    21         System.out.print("Show1()");
    22 
    23     }
    24 
    25     public void show2()
    26     {
    27 
    28         System.out.print("Show2()");
    29 
    30     }
    31 
    32 }
    33 
    34 class InterDemo3
    35 {
    36 
    37     public static void main(String[] args) {
    38         
    39         Test t = new Test();
    40         t.show1();
    41         t.show2();
    42 
    43     }
    44 
    45 }

    多实现需要注意的地方:

    1、多实现的时候,由于没有方法体,就没有了两个方法,同时具有不同的方法体,且当实现的时候不知道该实现哪个方法这个不确定性的隐患。因为即使一个类实现了多个接口的时候,多个接口当中又具有相同方法的时候,这个时候相同的方法都是抽象方法,并且这些个抽象的方法在被类实现的时候,就被一个方法覆盖了,所以并不存在不确定性。

    2、在抽象方法当中,返回值可以定义,方法接收的参数也是可以定义的。

     1 interface A
     2 {
     3 
     4     public void show();
     5 
     6 }
     7 
     8 interface B
     9 {
    10 
    11     public void show(int a,int b);
    12 
    13 }
    14 
    15 class Test implements    A,B 
    16 {
    17 
    18     public void show()
    19     {
    20 
    21         System.out.print("Show1()");
    22 
    23     }
    24 
    25     public void show(int a , int b)
    26     {
    27 
    28         System.out.print("a + b = "+(a+b));
    29 
    30     }
    31 
    32 }
    33 
    34 class InterDemo3
    35 {
    36 
    37     public static void main(String[] args) {
    38         
    39         Test t = new Test();
    40         t.show();
    41         System.out.println();
    42         t.show(7,8);
    43 
    44     }
    45 
    46 }

    这个样子写是正确的,但是这个样子写就是错误的:

     1 interface A
     2 {
     3 
     4     public void show();
     5 
     6 }
     7 
     8 interface B
     9 {
    10 
    11     public int show();//这样子写是错误的
    12 
    13 }
    14 
    15 class Test implements    A,B 
    16 {
    17 
    18     public void show()
    19     {
    20 
    21         System.out.print("Show1()");
    22 
    23     }
    24 
    25     public int show()
    26     {
    27 
    28         return 1;
    29 
    30     }
    31 
    32 }
    33 
    34 class InterDemo3
    35 {
    36 
    37     public static void main(String[] args) {
    38         
    39         Test t = new Test();
    40         t.show();
    41         System.out.println();
    42         t.show();
    43 
    44     }
    45 
    46 }

    这个就叫做,调用的不确定性。

    接口与接口之间的关系,接口与接口之间是继承关系,并且是多继承的关系。因为接口当中的抽象方法,就避免了不确定性,比如:

     1 interface AA
     2 {
     3 
     4     public void show1();
     5 
     6 }
     7 
     8 interface BB
     9 {
    10 
    11     public void show2();
    12 
    13 }
    14 
    15 interface CC extends AA,BB
    16 {
    17 
    18 
    19 
    20 }

    这个就是接口与接口之间的继承关系,并且是多继承关系。

    这样,当一个类实现CC这个接口的时候,就同时必须实现两个方法,即:

    1 class Test implements CC
    2 {
    3 
    4     public void show1(){}
    5     public void show2(){}
    6 
    7 }

    接口的特点:

    1、接口是对外曝露的规则;

    2、接口是对程序的扩展;

    3、接口能够降低程序的耦合性;

    4、接口可以用来多实现。

    5、类与接口之间是实现的关系,一个类可以继承自一个类的同时,实现多个接口。而接口与接口之间是继承且是多继承的关系。

    为了更形象的说明这个特点,我们来举一个例子来说一下,就拿笔记本电脑的这个例子来说:

    早期的笔记本电脑是没有usb接口的,因为早期的笔记本电脑是把所需要的功能直接嵌入到笔记本当中,这样我们就可以用了。但是这个时候就出现了一个问题,就是如果我们不习惯笔记本的触摸板,想把触摸板替换成鼠标的话,我们就需要把笔记本拆开,并且把触摸板上面的两个线接入到鼠标上面,这样鼠标就可以使用了。同时如果我们这个时候笔记本键盘坏掉了,我们应该怎么办呢,我们也需要把笔记本拆开把键盘上的线引出来 ,接到我们完好的键盘上面。在做这些事情的时候,我们就会发现一个问题,这样来回的接线,会显得我们的笔记本电脑不够人性化,我们就在想,如果我们在生产笔记本的时候,可以预先保留几个特定规格的且有特定规则的接口,来供我们使用,这样就大大提高了笔记本的扩展性,和使用性。比如说,笔记本的生产厂家,在生产笔记本的时候,提前预留了这个接口。同时,鼠标、键盘厂家也按照这个接口做了一些鼠标和键盘出来,这样当我们不想用原装的时候,就可以利用这个usb接口直接接外接的键盘或者鼠标。这就就显得方便了许多,同样我们电脑主板上面也有许多这样的接口,不如PCI接口啊,内存接口啊,等等之类的。

    我们用代码来体现的话就是:

     1 interface Usb
     2 {
     3 
     4     public void open();
     5     public void close();
     6 
     7 }
     8 
     9 
    10 class UMouse implements Usb
    11 {
    12 
    13     public void open()
    14     {
    15 
    16         System.out.println("Mouse has opened");
    17 
    18     }
    19 
    20     public void close()
    21     {
    22 
    23         System.out.println("Mouse has closed");
    24 
    25     }
    26 
    27 }
    28 
    29 class UKeypbord implements Usb
    30 {
    31 
    32     public void open()
    33     {
    34 
    35         System.out.println("Keybord has opened");
    36 
    37     }
    38 
    39     public void close()
    40     {
    41 
    42         System.out.println("Keybord has closed");
    43 
    44     }
    45 
    46 }
    47 
    48 class BookPc
    49 {
    50 
    51     public static void main(String[] args) {
    52         
    53         BookPc b = new BookPc();
    54         b.method(null);
    55         b.method(new UMouse());
    56         b.method(new UKeypbord());
    57     }
    58 
    59     private void method(Usb u)
    60     {
    61         if(u!=null){
    62             u.open();
    63             u.close();
    64         }
    65     }
    66 
    67 }

    这里来说一下 这个例子是如何体现接口的特点的:

    1、定义接口,这个时候提供了给外界使用,并且鼠标、键盘厂商必须实现的两个方法,设备的关闭和开启。这个就是对外曝露的规则。

    2、因为在笔记本出厂之前就实现了对这个功能的扩展,所以这个也是对笔记本电脑功能上的扩展。

    3、同时在利用接口的同时,就不用把所有的代码都写在笔记本这个类当中,这样就降低了程序的耦合性,这样当我们要增加外加设备的时候,比如说要增加一个usb摄像头,这个时候,我们 就可以在外边定义一个摄像头的类,然后实现usb这个接口中的所有方法,之后,在pc当中直接调用就好了。

    以上就是接口的好处还有优点。

    接口和抽象类的异同点总结:

    1、共性:都是不断抽取出来的抽象概念。

    2、异性一:抽象类体现继承关系,一个类只能单继承。接口体现实现的关系,一个类可以多实现。

    3、异性二:抽象类是继承,是is a关系,在定义该体系当中基本共性的内容。接口是实现,是like a关系,在定义体系额外功能。举个例子来说,学生都具有学习的功能,但是打架的功能就是额外的,有的孩子不打架,有的就是天天打架。在这个地方我们用一个例子来形容下:

    在我们生活当中犬又分为导盲犬、搜救犬等等,这个是按照功能来划分的,有的狗没有,有的狗就有。但是他们有一个共性就是都是犬,犬就是一个体系基本的功能,比如有叫,而导盲、搜救这些都属于额外功能,我们用代码来体现下。

     1 abstract class Dog
     2 {
     3 
     4     abstract public void houJiao();
     5 
     6 }
     7 
     8 interface DaoMang
     9 {
    10 
    11     public void lookWay();
    12 
    13 }
    14 
    15 interface SouJiu
    16 {
    17 
    18     public void giveHelp();
    19 
    20 }
    21 
    22 class DaoMangDog extends Dog implements DaoMang
    23 {
    24 
    25     public void houJiao()
    26     {
    27 
    28         System.out.println("Flow me!");
    29 
    30     }
    31 
    32     public void lookWay()
    33     {
    34 
    35         System.out.println("I can give you right way to home");
    36 
    37     }
    38 
    39 }
    40 
    41 class SouJiuDog extends Dog implements SouJiu
    42 {
    43 
    44     public void houJiao()
    45     {
    46 
    47         System.out.println("Is someone need Help?");
    48 
    49     }
    50 
    51     public void giveHelp()
    52     {
    53 
    54         System.out.println("Ok I can give you a hand");
    55 
    56     }
    57 
    58 }
    59 
    60 class InterDemo6
    61 {
    62 
    63     public static void main(String[] args) {
    64         
    65         new SouJiuDog().houJiao();
    66         new DaoMangDog().houJiao();
    67 
    68     }
    69 
    70 }

    4、异性三:抽象类当中有构造函数还有非抽象方法,可以直接供子类来使用。而接口当中只能存在抽象方法,并且都是公开属性,且有固定的修饰符。

  • 相关阅读:
    MySQL统计函数记录——按月、按季度、按日、时间段统计
    Myslq查询字段为null的数据
    表情包
    在线logo制作
    在线图片识别 图片转文字 OCR
    PDF
    php读取access数据库
    java注解的自定义和使用
    zookkeper原理学习
    mybatis源码阅读心得
  • 原文地址:https://www.cnblogs.com/sunchuanzhen/p/3348249.html
Copyright © 2011-2022 走看看