接口和内部类

一.接口

1.语法

interface 接口名{
    没有构造方法，不能创建对象；
    只能定义：公开静态常量、公开抽象方法
}
​
接口名.属性;
接口名.方法;

接口和相当于特殊的抽象类，定义方式、组成部分与抽象类相似。

2.接口与抽象类的异同

• 相同

可编译成字节码文件

不能创建对象

可以作为引用类型

具备OBJECT类中定义的方法

• 不同

所有属性都是公开静态常量，隐式使用public static final修饰

所有方法都是公开抽象方法，隐式使用public abstract修饰

没有构造方法、动态代码块、静态代码块

3.接口的规范

• 任何类在实现接口时，都必须实现接口中的所有抽象方法，否则就是抽象类

• 实现接口中的抽象方法时，访问修饰符必须是public

4.常见的关系

• 类与类

  • 单继承

  • extends 父类名称

• 类与接口

  • 多实现

  • implements 接口1，接口2，...

• 接口与接口

  • 多继承

  • extends 父类接口1，父类接口2，...

5.常量接口

• 将多个常用于表示状态或者固定值的变量，以静态常量的形式定义在接口中统一管理。

二.内部类

定义：

在类的内部再定义一个类

特点：

• 编译之后可以生产独立的字节码文件

• 可以直接访问外部类的私有成员，且不破坏封装

• 可以为外部类提供必要的内部功能组件

1.成员内部类

在创建一个内部类时，必须依赖外部对象

//外部类
class Outer {
    private String name = "张三";
    private int age = 18;
​
    class Inner{
        private String address = "beijing";
        private String pnone = "110";
        private String name = "李四";
​
        public void show(){
            //访问外部变量
            //内部类的属性和外部类的属性名字相同，访问外部类的属性需要添加 外部类名.this.属性名
            System.out.println(Outer.this.name);
​
            System.out.println(age);
            //内部
            System.out.println(name);
            System.out.println(address);
            System.out.println(pnone);
        }
    }
}
​
public class TestOuter {
    public static void main(String[] args) {
       /* //1.先创建外部类对象
        Outer outer = new Outer();
        //2.创建内部类
        Outer.Inner inner = outer.new Inner();
        inner.show();*/
​
        Outer.Inner inner = new Outer().new Inner();
        inner.show();
    }
}

2.静态内部类

不依赖外部类对象，可以直接创建或者通过类名访问，可声明静态成员

调用外部类的语句的语法

Outer.Inner inner = new Outer.Innwe();
Outer.Inner.show();

class Outer {
    private String name = "张三";
    private int age = 18;
​
    //静态内部类，级别和外部类相同
    static class Inner{
        private String address = "上海";
        private String pnone = "111";
​
        private static int count = 1000;
​
        public void show(){
            //调用外部类的属性
            Outer outer = new Outer();
            System.out.println(outer.age);
            System.out.println(outer.name);
            //调用静态内部类的属性和方法 直接调用
            System.out.println(address);
            //调用静态内部类的静态属性
            System.out.println(Inner.count);
        }
    }
}
​
public class TestOuter {
    public static void main(String[] args) {
        //直接创建静态内部类对象
        Outer.Inner inner = new Outer.Inner();
        //调用
        inner.show();
    }
}

3.局部内部类

定义在外部类的方法中，作用范围仅限于当前方法

class Outer{
    private String name = "外部类";
    public void show(){
        //这就叫做局部内部类
        class Inner{
            String name = "内部";
            int age = 15;
            public void show2(){
                //调用内部类中的属性
                System.out.println(this.name);
                //调用外部属性
                System.out.println(Outer.this.name);
            }
        }
    }
}

4.匿名内部类

1.没有类名的局部内部类 可以把它看作一个局部内部类，一切特征跟局部内部类相同

2.必须继承一个父类或者实现一个接口

3.需要配合某一个类或者某一个接口来使用

• 优点：减少代码

• 缺点；可读性差

public class AnonymouseInnerClass {
    public static void main(String[] args) {
        //接口
        Usb usb = new Usb() {
            @Override
            public void service() {
​
            }
        };
        //抽象类  实现的那个类就叫匿名内部类
        TrafficTools trafficTools = new TrafficTools() {
            @Override
            public void transport() {
​
            }
        };
    }
​
}
interface Usb{
    void service();
}
​
abstract class TrafficTools{
    public abstract void transport();
}
​