JAVA 面向对象09-接口、N种内部类

接口

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

接口：只有规范，自己无法写方法，也成为“专业的约束”。定义一组规则，体现“如果你是…，则必须能…”。

接口的本质是契约，精髓是对对象的抽象。

声明接口的关键字为：interface。关键字：implements为实现。

接口的作用：
（1）约束；
（2）定义一些方法，让不同的类去实现；
（3）定义的方法默认修饰为：public abstract；
（4）定义的属性默认修饰为：public abstract final(常量)；
（5）接口不能被new实例化，且接口中无构造方法；
（6）类可以implements实现多个接口，但必须重写实现的接口中的方法。

接口TimeService：

public interface TimeService {
    void timer();
}

类UserServiceImpl：

//interface 接口：只有定义，需要实现类
public interface UserService {

    //接口中所有定义的属性默认都是public abstract final
    int A = 99;

    //接口中所有定义的方法默认都是public abstract
    void run(String name);
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

接口UserService：

//接口UserService的实现类：implements 接口1，接口2
//实现多个接口--->相当于多继承
//实现接口的类，需要重写接口的所有方法
public class UserServiceImpl implements UserService,TimeService{
    //重写接口的所有方法
    @Override
    public void run(String name) {

    }

    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

N种内部类

**内部类：**在一个类的内部定义一个类，比如在A类中定义一个B类，则B类相当于A类为内部类，则A类相当于B类为外部类。

1. 内部成员类：public class 类名，内部成员类可以获得外部类的私有属性；
2. 静态内部类：public static class 类名，静态内部类可以获得外部类的静态私有属性；
3. 局部内部类：该类位于方法体内；
4. 匿名内部类
   - 匿名对象：new 类名得到对象，但没有将实例化的对象放在变量中，没有名字的对象所以为匿名对象。
   - 匿名内部类：new 接口{//重写接口内的方法}；返回的为以接口同名的对象，但如果没有将其保存在变量中，没有名字的类为匿名类。

Outer： 内部成员类、 静态内部类、局部内部类

public class Outer {
    //非静态属性
    private int id1 = 10;
    //静态属性
    private static int id2 = 10;

    public void out(){
        System.out.println("这是外部类的out方法");
    }
    //成员内部类
    public class Inner1{

        public void in(){
            System.out.println("这是内部类的in方法");
        }

        //内部类可以获得外部类的私有属性
        public void getID(){
            System.out.println(id1);
        }
    }
    //静态内部类
    public static class Inner2{

        public void in(){
            System.out.println("这是内部类的in方法");
        }

        //内部类可以获得外部类的静态私有属性
        public void getID(){
        //报错,因为先实例化static，即先实例化Inner2类，再实例化非静态的属性id1
//            System.out.println(id1);
            System.out.println(id2);
        }
    }
    //局部内部类：类写在方法体中
    public void method(){

        class Inner3{

        }
    }

}

main方法

public static void main(String[] args) {

        //new
        Outer outer = new Outer();
        //通过外部类来实例化内部类
        Outer.Inner1 inner = outer.new Inner1();
        inner.in();
        inner.getID();
    }

Test：匿名对象、new接口为匿名内部类

public class Test {
    public static void main(String[] args) {
        //new Apple()为匿名对象
        //没有名字初始化类，没有将实例化的对象保存在变量中
        new Apple().eat();

        //new接口，需要重写接口中的方法，会返回一个UserService对象，如果不将其保存在变量值，它也是一个匿名类
        UserService userService = new UserService(){
            @Override
            public void hello() {
                System.out.println("匿名类");

            }
        };
        userService.hello();

    }
}
//Apple类
class Apple{

    public void eat(){
        System.out.println("eat");
    }
}
//UserService接口
interface UserService{
    void hello();
}