（七）Java面向对象（下）抽象类，接口，N种内部类----狂神说Java

抽象类

注意：

• 不能new抽象类，只能靠子类去实现它：约束
• 抽象类里面可以有普通方法
• 抽象方法必须在抽象类中，只有一个抽象方法，也必须在抽象类中
• abstract抽象方法，只有方法名字，没有方法的实现；
• 继承了抽象类的子类，必须实现父类的所有抽象方法。
• 抽象类只能单继承，（接口可以多继承）。、

思考：存在构造器么？存在的意义？
例子：

package oop.demo09;
//abstract 抽象类：是一个类，单继承  （接口可以多继承）
public abstract  class Action
{
    //约束，有人帮我们实现
    // abstract 只有方法名，没有方法的实现
    public abstract void doSomething();
}

package oop.demo09;
//抽象类的所有方法，继承了他的子类，都必须要实现它的抽象方法
public class A extends Action{
    @Override  //需要重写，如果不重写，那么这个子类也定义为抽象类
    public void doSomething() {

    }
}

接口

注意：

• 接口是一个约束
• 定义一些方法，让不同的人实现，例如10个人对一个接口就有不同的实现
• 接口中的方法默认为：public abstract
• 接口中的常量默认为（但是一般不这么用）：public static final
• 接口不能被实例化，因为接口中没有构造方法
• implements可以实现多个接口( 类C implements 接口A,接口B)
• 必须要实现接口中的方法
  例子：

package oop.demo10;

public interface A {
    //常量，默认public  static  final int AGE = 88;
    int AGE1 =88;

    //接口中的所有定义都默认： 抽象的public
    public abstract void add();
    void  add1();
}

package oop.demo10;

public interface B {
    void timer();
}

package oop.demo10;
//一个类可以实现多个接口（多继承），使用implements
//实现接口的类需要实现接口中的方法
public class C implements A,B {
    @Override
    public void add() {

    }

    @Override
    public void add1() {

    }

    @Override
    public void timer() {

    }
}

内部类

外部类，内部类（在类中定义一个类）例子：

• 可以通过外部类来实例化内部类
• 内部类可以获得外部类的私有属性id
• 静态内部类：加static
• 局部内部类，在方法中的类
• 一个java类文件中可以有多个class类，但是只能有一个public class类

package oop.demo11;

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

    // 内部类
    public class Inner{
        public void in(){
            System.out.println("内部类的方法");
        }

        //内部类可以获得外部类的私有属性id
        public void getID(){
            System.out.println("获取外部类的私有属性："+id);
        }
    }

    //在方法中的类，局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }
}
//一个java类文件中可以有多个class类，但是只能有一个public class类
class A{
    public  void main(String[] args) {
        System.out.println();
    }
}

测试：

package oop.demo11;

public class Application {
    public static void main(String[] args) {

        //new 外部类
        Outer outer = new Outer();
        outer.out();

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

匿名内部类：没有名字初始化类或者没有名字初始化接口（必须进行方法的重写）

package oop.demo11;

public class Application1 {
    public static void main(String[] args) {

        // 没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();

        // 必须重写
        UserService userService = new UserService(){
            @Override
            public void hello() {

            }
        };
        new UserService(){  //没有名字使用接口，里面方法必须重写
            @Override
            public void hello() {

            }
        };
    }
}

class Apple{
    public void eat(){
        System.out.println("eat");
    }
}

//接口：
interface UserService{
    void hello();
}