JavaSE基础——面向对象3：接口与内部类

JavaSE基础——面向对象3：接口与内部类

六、接口

1. 什么是接口？

在JAVA编程语言中，接口是一个抽象类型，是抽象方法的集合。

接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。类的继承只能单继承，但可以通过接口实现（伪）多继承。

• 接口代表一种能力，实现接口，则表示具备了某种功能
• 接口代表一种规范，在实现接口的时候必须遵循相应的规范，比如说重新实现方法的时候参数的要求、返回值的要求等等

接口中定义了一些抽象方法，如果类要实现该接口，则必须给出这些抽象方法的具体实现。因此说接口时一种能力。

2. 接口的特点

• 使用interface关键字声明接口
• 接口中可以定义变量，但接口中的变量会隐式地指定为public static final型变量
• 接口主要是一系列抽象方法的集合，接口中的方法会被隐式地指定为 public abstract 类型
• 接口中都是抽象方法，只有方法名，没有方法体。只能由实现接口的类来重写接口中抽象方法的具体实现
• 接口没有构造方法，不能实例化。
• 接口可以继承接口，而且还可以多继承。
• 类使用implements关键字实现接口。在类声明中Implements关键字放在class声明后面。

3. 接口的实现

3.1 接口实现示例

package com.oop_extends.www;
//声明一个接口，接口名称为Sing
interface Sing {
    //接口中可以定义变量，但接口中的变量会隐式地指定为 public static final变量，因此一般不再接口中声明变量
    int vol = 10;
    boolean isSing = true;
    //接口主要是一系列抽象方法的集合，接口中的方法会被隐式地指定为 public abstract 类型
    //因为方法都是抽象方法，因此接口里的方法也都是只有方法名，没有方法体，需要实现接口的类来提供方法的具体细节实现
    void singSong(People people);
}
//声明一个抽象类，名称为People
abstract class People {
    //声明一个抽象方法，speak
    abstract void speak();
}
class Boy extends People {
    //重写父类中的抽象方法speak
    @Override
    void speak() {
        System.out.println("男孩说话");
    }
}
//创建一个子类Singer，继承于父类People，实现接口Sing
class Singer extends People implements Sing {
    //当类要实现接口的时候，除非该类是抽象类，否则该类要重写实现接口里的所有抽象方法
    //重写接口中的singSong方法，
    @Override
    public void singSong(People people) {
        //在实现接口的抽象方法singSong时，调用父类的抽象方法speak
        this.speak();
    }
    //对于父类中的抽象方法，子类要重写给出具体实现
    @Override
    void speak() {
        System.out.println("歌手唱歌");
    }
}
public class Jiekou {
    public static void main(String[] args) {
        //实例化一个Singer类的对象
        //调用Singer类所实现的接口Sing中的singSong方法，
        //实例化一个Boy类对象，将其作为参数传递给singSong方法
        new Singer().singSong(new Boy());
        //singSong的参数类型为People，接收boy后自动转换
        //转换后执行当前类的speak方法，当前类为Singer，因此执行”歌手唱歌“
    }
}
--------------------------------------------------
运行结果：
    歌手唱歌

可以看到，编写接口的方式和类很相似。但是接口不是类。

3.2 实现接口的注意点

类实现接口需要重写接口中声明的抽象方法。但是重写接口中声明的方法时，需要注意以下规则：

• 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
• 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

在实现接口时也应注意一些规则：

• 一个类可以同时实现多个接口，将接口名依次放在implements关键字后面，类里面要重写所有接口的抽象方法。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口，这和类之间的继承比较相似。

4. 接口与类的比较

4.1 接口与一般类的区别

• 接口不能实例化对象；类（除了抽象类）可以实例化对象
• 接口没有构造方法；所有类都有构造方法，包括抽象类
• 接口中的所有方法必须是抽象方法；类中可以有抽象方法（抽象类），也可以有成员方法；
• 接口不能包含成员变量，只有`public static final型变量
• 接口不能被类继承，只能被类实现。实现接口的类要么是抽象类，要么就要重写接口内所有的抽象方法，给出其具体实现。
• 接口可以多继承，类只能单继承。但一个类可以实现不同的接口。

4.2 接口与抽象类的区别

• 抽象类中的方法可以有方法体（成员方法），就是能实现方法的具体功能，但是接口中的方法不行，接口中都是抽象方法。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是public static final类型的。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

5. 接口的继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
//实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。 
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
//Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}
//java支持多继承，因此下面语句也是合法的
public interface Hockey extends Sports, Event

6. 标记接口

6.1 标记接口是什么？

最常用的继承接口是没有包含任何方法的接口。

标记接口是没有任何方法和属性的接口。它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。

6.2 标记接口的作用

简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。主要有以下两种：

• 建立一个公共的父接口：

  正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。

• 向一个类添加数据类型：

  这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

七、内部类

内部类就是在前一个类的内部再定义一个类。比如，A类中定义了一个B类，则B类相对于A类来说称为内部类，A类相对于B类来说就是一个外部类。

使用内部类的好处在于每个内部类都能独立地继承一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。

使用内部类最大的优点就在于它能够非常好的解决多重继承的问题,使用内部类还能够为我们带来如下特性:

• 内部类可以用多个实例，每个实例都有自己的状态信息，并且与其他外围对象的信息相互独。
• 在单个外围类中，可以让多个内部类以不同的方式实现同一个接口，或者继承同一个类。
• 创建内部类对象的时刻并不依赖于外围类对象的创建。
• 内部类并没有令人迷惑的“is-a”关系，他就是一个独立的实体。
• 内部类提供了更好的封装，除了该外围类，其他类都不能访问。

内部类主要分为：

• 成员内部类
• 静态内部类
• 局部内部类
• 匿名内部类

1. 成员内部类

成员内部类比较常见，定义也比较简单，就是在一个类的内部再定义一个类。

成员内部类的对象依赖于外部类对象而存在。

package com.oop_extends.www;
//创建一个外部类Outer
public class Outer {
   //定义外部类的属性
   private int age = 99;
   String name = "automan";
    //创建一个内部类Inner
    public class Inner {
        //定义内部类的属性
        int weight =80;
        String name = "ironman";
        //定义内部类的方法
        public void show() {
            //内部类可以直接访问外部类属性，当内部类属性与外部类属性重名时，直接使用属性名，访问的是内部类的属性
            System.out.println(name);
            //若要访问外部类的同名属性，需要用 外部类名.this.同名属性名 的方式来访问
            System.out.println(Outer.this.name);
            //内部类可以直接访问外部类的私有属性
            System.out.println(age);
        }
    }
   //定义一个成员方法，使其返回一个内部类的对象
   public Inner getInnerClass() {
       return new Inner();
   }
    public static void main(String[] args) {
        //实例化一个外部类对象
        Outer outer = new Outer();
        //实例化内部类对象需要依赖于外部类的对象
        Inner inner = outer.new Inner();
        //内部类对象调用内部类的show方法
        inner.show();
        System.out.println("***********************");
        //调用外部类方法创建一个内部类对象
        Inner a = outer.getInnerClass();
        //内部类对象调用内部类方法
        a.show();
        System.out.println(a.weight);
    }
}
---------------------------------------------------
运行结果：
    ironman
    automan
    99
    ***********************
    ironman
    automan
    99
    80

• Inner 类定义在 Outer 类的内部，相当于 Outer 类的一个成员变量的位置，Inner 类可以使用任意访问控制符，如 public 、 protected 、 private 等

• 内部类对象的创建需要依赖于外部类对象。因此实例化内部类对象，需要先实例化一个外部类对象，然后通过成员访问符.来new一个内部类对象。即：内部类 对象名 = 外部类对象.new 内部类( );

• 内部类可以直接访问外部类的数据，不受访问控制符的影响。对于内部类和外部类中名称相同的数据，内部类默认访问的是自己的数据，如果要访问外部类的同名数据，应通过外部类名.this.同名数据名访问。

• 外部类不能直接访问内部类的数据，可以先创建内部类的对象，然后通过内部类的对象来访问。

• 成员内部类中不能存在任何 static 的变量和方法

  ,可以定义常量:

  • 因为非静态内部类是要依赖于外部类的实例,而静态变量和方法是不依赖于对象的,仅与类相关
  • 简而言之，在加载静态域时,根本没有外部类,所在在非静态内部类中不能定义静态域或方法,编译不通过;非静态内部类的作用域是实例级别
  • 常量是在编译器就确定的,放到所谓的常量池了

• 上述程序编译后将出现两个class文件:Outer.class,Outer$Inner.class{}

2. 静态内部类

静态内部类就是在成员内部类的声明时，加上static关键字修饰。

//创建一个外部类Outer
public class Outer {
    //定义外部类的属性
    private static int age = 99;
    static String name = "automan";
    //创建一个静态内部类Inner
    public static class Inner {
        //定义内部类的属性
        int weight =80;
        String name = "ironman";
        //定义内部类的方法
        public void show() {
            //内部类可以直接访问外部类属性，当内部类属性与外部类属性重名时，直接使用属性名，访问的是内部类的属性
            System.out.println(name);
            //若要访问外部类的同名属性，需要用 外部类名.同名属性名 的方式来访问
            System.out.println(Outer.name);
            //内部类可以直接访问外部类的私有属性
            System.out.println(age);
        }
    }
    //定义一个成员方法，使其返回一个内部类的对象
    public Inner getInnerClass() {
        return new Inner();
    }
    public static void main(String[] args) {
        //实例化一个外部类对象
        Outer outer = new Outer();
        //实例化一个静态内部类的对象
        Inner inner = new Inner();
        //内部类对象调用内部类的show方法
        inner.show();
        System.out.println("***********************");
        //调用外部类方法创建一个内部类对象
        Inner a = outer.getInnerClass();
        //内部类对象调用内部类方法
        a.show();
        System.out.println(a.weight);
    }
}
---------------------------------------------------
运行结果：
    ironman
    automan
    99
    ***********************
    ironman
    automan
    99
    80

• 静态内部类只能访问外部类的静态成员，不能访问非静态成员，但可以通过new 外部类名（）.成员名的方式访问
• 如果静态内部类成员与外部类的成员名称相同，静态内部类默认访问的是自己的数据，如果要访问外部类的同名数据，应通过外部类名.同名数据名访问。
• 创建静态内部类对象的时候不需要依赖外部类对象，可以直接使用new关键字创建

3. 局部内部类

局部内部类就是在方法里的内部类。就像是方法里面的一个局部变量一样，随着方法调用而产生，方法调用结束而消亡，而且时是不能有 public、protected、private 以及 static 修饰符的。

//局部内部类
//创建一个外部类
public class Outer {
    //定义一个show方法
    public void show() {
        //在成员方法中定义局部变量age
        final int age = 25;
        int b = 13;
        //在成员方法中定义一个内部类，即局部内部类
        class Inner {
            int c = 2;
            //局部内部类中定义方法print
            public void print() {
                //局部内部类访问外部类成员方法中的局部变量
                System.out.println("访问外部类：" + age);
                //外部类访问自身的变量
                System.out.println("访问内部类：" + c);
            }
        }
        //在外部类中实例化一个内部类对象
        Inner inner = new Inner();
        //通过实例化出来的对象访问内部类的方法
        inner.print();
    }
    public static void main(String[] args) {
        //实例化一个外部类对象
        Outer outer = new Outer();
        //外部类对象调用局部内部类的方法，因为外部类中实例化了一个内部类对象，因此可以实现对局部内部类的方法进行调用
        outer.show();
    }
}
---------------------------------------------------
运行结果：
    访问外部类：25
    访问内部类：2

• 局部内部类不能有访问修饰符
• 局部内部类仅在当前的方法内使用
• 可以直接访问该方法内的类型为final的局部变量和参数，或者已经被赋值但始终未该白你的变量，引用指向不能改变（相当于final型）
• 可以随意访问外部类的任何信息。

为何只能方法问呢方法中定义的final型的局部变量：

当方法被调用运行完毕之后，局部变量就已消亡了。但内部类对象可能还存在,直到没有被引用时才会消亡。此时就会出现一种情况，就是内部类要访问一个不存在的局部变量;使用final修饰符不仅会保持对象的引用不会改变,而且编译器还会持续维护这个对象在回调方法中的生命周期。
局部内部类并不是直接调用方法传进来的参数，而是内部类将传进来的参数通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数;防止被篡改数据,而导致内部类得到的值不一致

4. 匿名内部类

//匿名内部类
//创建一个外部类
public class Outer {
    //定义一个外部类成员方法，返回一个InnerClass接口类型的引用，该引用指向一个实现了InnerClass接口的匿名内部类，方法名称为getInnerClass，接收一个final的int参数和一个String型参数
    public InnerClass getInnerClass(final int num, String str2){
        /*
        这里的方法体内只有一条语句，就是return（****）；
        return的类型呢是一个匿名类，该匿名类没有名称（因此称为匿名），但该匿名类实现了InnerClass接口
        InnerClass接口中定义了一个getNumber()抽象方法
        该匿名类实现了InnerClass接口，类的内容为：
        {
            int number = num + 3; //即接收外部类方法所接受的num数据，将其加3后赋给匿名内部类的比那辆number
            //匿名内部类中重写了接口中的getNumber抽象方法，返回number值
            public int getNumber(){
                return number;
            }
        }
         */
        //可以说new InnerClass()实例化了一个匿名类的对象，该匿名类实现了InnerClass接口
        return new InnerClass(){
            //该内部类的操作就是将num加3赋给number
            int number = num + 3;
            //该内部类中顶一个一个getNumber放啊，返回number的值
            public int getNumber(){
                return number;
            }
        };        /* 注意：分号不能省 */
    }
    public static void main(String[] args) {
        //实例化一个外部类对象
        Outer out = new Outer();
        //定义一个InnerClass类型的引用，名称为inner，将其指向外部类对象调用getInnerClass所返回的匿名内部类
        InnerClass inner = out.getInnerClass(2, "chenssy");
        //通过这个inner这个引用，访问匿名内部类中的getNumber方法
        System.out.println(inner.getNumber());
    }
}
//声明一个接口，接口名为InnerClass
interface InnerClass {
    int getNumber();
}
---------------------------------------------------
运行结果：
    5

• 匿名内部类是直接使用 new 来生成该内部类对象的引用
• 匿名内部类只能使用一次，创建匿名类时就会实例化一个对象，但没有将对象的引用赋给任何变量。因此当该类的定义消失后，也没有办法在使用该类了。因此匿名内部类是不能被重复使用的。
• 使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口
• 匿名内部类中是不能定义构造函数的,匿名内部类中不能存在任何的静态成员变量和静态方法
• 匿名内部类不能是抽象的,它必须要实现继承的类或者实现的接口的所有抽象方法

转载