JAVA学习笔记--接口

一、抽象类和抽象方法

　　在谈论接口之前，我们先了解一下抽象类和抽象方法。我们知道，在继承结构中，越往下继承，类会变得越来越明确和具体，而往上回溯，越往上，类会变得越抽象和通用。我们有时候可能会需要这样一个类，它只是表示了一个接口，但并没有具体的实现，这就是一个抽象类。

　　抽象方法只有方法声明而没有方法体，也就是说用户并不知道这个方法是如何实现的。抽象方法的声明用到了 abstract 关键字，声明方法如下：

　　abstract void f();　　　　　　　　// 声明一个抽象方法

　　包含抽象方法的类叫做抽象类。如果一个类包含一个或多个抽象方法，那么该类必须被限定为抽象的。抽象类也用关键字abstract进行说明。

1）抽象类看起来和普通类相像，但是抽象类不能用new操作符创建它的实例；抽象类中抽象方法只有定义而没有实现，它的实现由子类提供；

2）抽象类可以被继承，但是其导出类必须为基类中所有的抽象方法提供方法定义，如果不这样做，那么导出类也将被强制限定为抽象类；

3）抽象类中可以没有抽象方法，这样的抽象类通常被用作基类型；

4）抽象类的构造方法定义为protected，这个构造方法在其子类的构造方法中被调用；

5）即使父类是具体的，其子类也可以是抽象的；

6）不能用new操作符创建一个抽象类的实例，但是抽象类可以用作一种数据类型被new调用。

 下面是一个简单的抽象类的例子：

package com.tongye.abstraction;

abstract class chouxiang{
    abstract void f();        // 抽象方法
}

class chouxiang1 extends chouxiang{
    void f(){
        System.out.println("抽象");
    }
}

public class Abstraction {
    public static void main(String[] args){
        chouxiang1 abstraction = new chouxiang1();
        abstraction.f();
    }
}

 

二、接口

 　　接口 interface 关键字使抽象的概念更向前迈了一步。abstract关键字允许人们在类中创建一个或多个没有任何定义的方法，即提供了接口部分，但是没有提供具体实现，其实现是由类的继承者来创建的。 interface 关键字产生一个完全抽象的类，它根本没有任何具体实现。

1）接口允许创建者确定方法名、参数列表和返回类型，但是没有任何方法体；接口只提供了形式，而未提供任何具体实现；

2）要创建一个接口，需要用interface关键字来代替class关键字。可以在interface前面添加public关键字（仅限于该接口在与其同名的文件中被定义）；如果不声明，则它只包含包访问权限，只能在一个包内可用；

3）接口可以包含域，但这些域隐式地是 static 和 final 的；

4）可以用implements关键字来表明一个类实现了某个特定接口，即： class A implements B{} ;

下面是一个简单的应用接口的例子：

package com.tongye.interfaces;

import java.util.Random;

public interface StudentMessages {
    Random rand = new Random(47);
    int age = rand.nextInt(20);        // 接口中的数据域
    void studentName();                // 接口中的方法，只有方法名而没有方法体
    void studentAge();
    void studentGrade();
}


package com.tongye.interfaces;

/* 类StudMessage1只实现了StudentMessages接口的部分方法，因而是抽象类 */
abstract class StudMessage1 implements StudentMessages {
    
    private String Stu_Name = "tongye";
    private int Stu_Age = age;
    private char Stu_Grade;
    
    /* 这是接口中方法的实现 */
    @Override
    public void studentName() {
        getName();
    }

    @Override
    public void studentAge() {
        System.out.println(Stu_Age);
    }
    
    /* 这是新类自带的方法 */
    public void getName(){
        System.out.println("my name is" + Stu_Name);
    }
}

/* StudMessage2继承自StudMessage1，并实现了StudentMessages接口中的部分方法 */
class StudMessage2 extends StudMessage1{
    @Override
    public void studentGrade() {
        System.out.println("1301");
    }
}

public class Student {
    public static void main(String[] args){
        StudMessage2 stud = new StudMessage2();
        stud.studentName();
        stud.studentAge();
        stud.studentGrade();
    }
}

　　接口一个很重要的作用就是，可以实现类似C++中的多重继承功能。我们知道，JAVA是不支持多重继承的，但是通过使用接口，我们可以实现类似功能，用来表示“一个x是一个a和一个b以及一个c”。一个类可以继承任意多个接口，这需要将所有的接口都置于implements关键字之后并用逗号隔开；可以将这个类向上转型为每个接口，因为每一个接口都是一个独立的类型。下面这个程序演示了一下接口的这个功能：

/********/
package com.tongye.interfaces;

public interface People {
    void isPeople();
}

/********/
package com.tongye.interfaces;

public interface Juniors {
    void isJuniors();
}

/********/
package com.tongye.interfaces;

public interface Chinese {
    void isChinese();
}

/********/
package com.tongye.interfaces;

class students implements People,Chinese,Juniors{
    @Override
    public void isPeople(){
        System.out.println("The student is a people");
    }

    @Override
    public void isJuniors() {
        System.out.println("The student is a junior");
    }

    @Override
    public void isChinese() {
        System.out.println("The student is a Chinese");
    }
}

public class Student{
    public static void people(People a){    // 接口作为一种数据类型传递给方法
        a.isPeople();
    }
    public static void junior(Juniors a){
        a.isJuniors();
    }
    public static void chinese(Chinese a){
        a.isChinese();
    }
    
    public static void main(String[] args){
        students stud = new students();
        people(stud);     // stud被向上转型为People类型
        junior(stud);     // stud被向上转型为Juniors类型
        chinese(stud);    // stud被向上转型为Chinese类型
    }
}

从这个程序中可以看出，类students既是People又是Juniors又是Chinese，在main方法中调用方法people、junior、chinese时，stud分别被向上转型为People、Juniors和Chinese，这大大提升了代码的灵活性。