Java面向对象05：接口和内部类

接口的定义

与抽象类相比，接口不能定义普通方法，没有构造方法，只有抽象方法和常量，用来进行规范的约束，类可以实现多个接口，变相等于实现了多继承

面向对象的精髓，是对对象的抽象，最能体现这一点的就是接口

约束和实现分离：面向接口编程

//关键字interface，定义接口
public interface Hello {
    //接口中方法默认就是public abstract，故无需再写
    void add();
    void delete();
    void update();
    void query();
    
    //接口中只能定义常量，默认是public static final
    int a = 1;
}

interface World {
    void other();
}

class simple implements Hello, World {  //关键字implements，让类实现接口。可以同时实现多个接口，变相等于多继承
    //类实现接口，必须重写接口的（抽象）方法
    @Override
    public void add() {
    }
    
    @Override
    public void delete() {
    }
    
    @Override
    public void update() {
    }
    
    @Override
    public void query() {
    }
    
    @Override
    public void other() {
    }
}

内部类

一个类的内部定义了另一个类

成员内部类

相当于类的成员变量，但必须先实例化才能使用，因此不能定义静态方法和变量

public class Hello {
    public static void main(String[] args) {
        Outer o = new Outer();
        //其他类调用时，要先实例化外部类，再实例化内部类
        Outer.Inner i = o.new Inner();
        i.inner();
    }
}

class Outer{
    private int id = 1;
    private void pri(){}
    public void outer(){
        System.out.println("这是外部类");
    }
    
    //定义成员内部类
    public class Inner{  
        //成员内部类不能定义静态属性和方法，因为成员内部类必须先实例化才能使用，而类和静态方法在加载时还没有创建对象
        public void inner(){
            //成员内部类可以直接调用外部类的私有属性和方法
            System.out.println(id);  
            pri();
            System.out.println("这是内部类");
        }
    }
    
    //外部类的非静态方法可以直接实例化内部类
    public void test(){
        Inner inner = new Inner();
    }
}

静态内部类

静态内部类就是加上static修饰符，其无法访问外部类的私有属性和方法，也不能直接访问非静态属性和方法（可以实例化对象访问）

局部内部类

局部内部类就是在方法中定义的类，作用域仅限于该方法

匿名内部类

如果接口的实现类（或者是父类的子类）只需要使用唯一的一次，这种情况下就可以省略该子类的定义，改用匿名内部类来定义

匿名内部类没有名字，只能通过其父类或者接口名来new对象，因此前提条件是必须存在继承或实现的关系

public class Hello {
    public static void main(String[] args) {
        //继承类时，可以重写父类的方法
        new C() {

            @Override
            public void f() {
                System.out.println("匿名内部类继承");
            }
        }.f();

        //实现接口时，必须要重写其所有（抽象）方法
        new I() {

            @Override
            public void i() {
                System.out.println("匿名内部类实现接口");
            }
        }.i();

        //普通类继承的写法
        // 相比较而言，匿名内部类省略了定义Son类，一步实现继承、重写，调用
        Son son = new Son();
        son.f();
        
        //如果需要重写多个方法，那必须要将匿名内部类的定义赋值给父类或者接口的对象，因为匿名内部类调用一次方法后就找不到了
        C obj = new C() {

            @Override
            public void f() {
                System.out.println("匿名内部类继承");
            }
        };
        
        obj.f();
    }
}

class C {
    public void f(){
        System.out.println();
    }
}

interface I {
    void i();
}

class Son extends C{
    public void f(){
        System.out.println("普通类继承");
    }
}