Java面向对象（三）---接口、抽象类、内部类

接口

1、what？

一个抽象类中的所有方法都是抽象方法，那么则称为Java的接口

• 自己无法写方法
• 专业的约束，实现约束和实现的定义，面向接口编程
• 接口本质就是契约，制定好之后大家都要遵守
• 声明接口的关键字是interface,而声明类的关键字是class

2、how?

• 接口里的所有定义都是抽象的，接口都需要实现类
• 用implements关键字实现接口（抽象类用extends实现继承）
• 用接口实现多继承(可以同时实现多个接口，实现多个接口之间要用逗号隔开)

public interface UseService {
    //接口里的所有定义都是抽象的，接口都需要实现类
    public abstract void run();//public abstract 都可以省略

}
public interface TimeService {
    void timer();
}
public class UserServiceImpl implements UseService,TimeService {
//一定要重写接口里面的方法
    @Override
    public void run() {

    }

    @Override
    public void timer() {

    }
}

• 接口里面定义常量，系统会自动默认称量添加的方法

• public interface UseService {
  //接口里面定义常量，系统会自动默认称量添加的方法
      public static final int age =90;
  }
  

• 接口之间可以通过extends关键字实现继承，并且一个接口可以同时继承多个接口，接口之间用逗号隔开

public interface TimeService extends UseService {
    void timer();
}

• 一个类在继承一个类的同时还可以实现接口，extends关键字必须位于implements关键字之前

class A extends B implements C{//先继承后实现
   ···
}

3、meaning

• 约束
• 定义一些方法，让不同的人实现
• 方法都是public abstract
• 常量都是public static final
• 接口不能直接被实例化，接口中没有构造方法
• Implements 接口可以实现多个接口
• 实现的时候必须要重写接口的方法

抽象类

1、what?

必须要用abstract关键字修饰，并且在定义方法时不需要实现方法体

public  abstract  class Action {
    //抽象方法
    public abstract  void something();
}
public class A extends Action{
//子类继承抽象类的时候，必须要重写抽象类里面的发法
    @Override
    public void something() {
        System.out.println("我在想你呀臭猪");
    }
}

抽象方法不需要实现方法体，只是一个大的框架，只需要提供名字就可以了

但是当子类继承抽象类的时候，必须要重写抽象类里面的发法，否则会报错

前面所提及过Java不提供多继承只允许单继承，但是接口可以实现多继承

2、特点

1. 不能new一个对象，只是提供一个约束，只有方法的名字，没有方法实现
2. 一旦一个类里面有抽象方法，这个类一定要是抽象类，但是抽象类里面可以写不同的方法
3. 但是抽象类可以实现构造器

3、意义

抽象出来，提高开发效率

内部类

注意：一个Java文件中只能由一个public类，但是可以有多个class

1、what

内部类就是在一个类中在定义一个类，比如在A类中再定义一个B类，那么B类相对于A类来说就是内部类，而A类对于B类来说就是外部类

2、classification

①成员内部类

• 在一个类里面再创建一个内部类

public class Outer {
    private int id;
    public void out(){
        System.out.println("外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类");
        }
    }
}

• 实现内部类的方法时要外部类实例化内部类才能调用内部类的方法

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.out();
        //通过外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.in();
    }
}

• 内部类可以直接访问外部类的变量（私有属性也可以访问）

   public void gerID(){
              System.out.println(id);
          }
  

• 内部类可以直接访问外部类的方法，不用创建外部类的对象(调用外部类的方法：外部类类名.this.外部类方法的名字)

Outer.this.out();//调用外部类的方法：外部类类名.this.外部类方法的名字
        }

②静态内部类

静态内部类无法直接访问非静态类的属性

③局部内部类

局部内部类可以直接访问外部类的所有成员和方法，但是局部类中的方法和变量只能在创建局部内部类的方法中进行访问

例如在方法里面的则是局部变量，同理方法里面的类则是局部类，同时再内部类的方法里的类叫做局部内部类

public class Outer{
    int id=0000;
   public void method(){
       class S{
           //称为局部内部类
  
       }
   }
}

④匿名内部类

没有名字的初始化，不用将实例保存再在变量中

 public static void main(String[] args) {
        new Outer().out();//匿名内部类
    }