Java面向对象04 static、 抽象类、 接口、N种内部类

一、static

它是随着类一块加载的

public class Person {
    //2：赋初始值
    {
        //代码块（匿名代码块）
        System.out.println("匿名代码块");
    }
    //1:static只执行一次
    static {
        //静态代码块
        System.out.println("静态代码块");
    }
    //3
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("==================");
        Person person1 = new Person();

    }
}

 final断子绝孙了，不能被继承

二、抽象类

abstract，抽象类只能靠他的子类去实现，它的子类必须重写抽象类的方法，（单继承）

public abstract class Action {

    //约束 有人帮我们实现
    //abstract,抽象方法，只有方法名字，没有方法的实现
    public abstract void doSomething();

    //1.不能new这个抽象类，只能靠子类去实现它；约束！
    //2.抽象类中可以写普通方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束~


    //思考题      存在构造器吗？   存在
    //存在的意义    抽象出来  提高开发效率

//抽象类的所有方法：继承了它的子类，都必须要实现它的方法，
public class A extends Action{
    @Override
    public void doSomething() {

    }
}

三、接口

interface   定义接口的关键字     接口都需要有实现类

接口中的所有定义其实都是抽象的 public abstract（包括方法）

抽象类：extend
类 可以实现接口  implements 接口
实现了接口的类  就需要重写接口中的方法~
多继承~利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{}

实现接口的类，必须要重写接口中的方法

接口的作用：
    1.约束
    2.定义一些方法，让不同的人实现
    3.public abstract
    4.public static final
    5.接口不能被实例化~，接口中没有构造方法
    6.implements可以实现多个接口
    7.必须要重写接口中的方法

四、N种内部类

内部类就是在一个类中再定义一个类

通过外部类实例化内部类

这是一个内部类

public class Outer {

    private int id=10;
    public void out(){
        System.out.println("这是外部类的方法");

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

        //获得外部类的私有属性
        public void getId(){
            System.out.println(id);
            out();
        }

    }

这是 通过外部类实例化内部类

public static void main(String[] args) {

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

    inner.in();
    inner.getId();

这是局部内部类 

 //局部内部类
    public void method(){
        class Inner{
            public void in(){

            }
        }
    }

}
//一个Java类中可以有多个class类，但只能有一个public class
class A{

        }

 这是匿名内部类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类,不用将实例保存到变量中
        new Apple().eat();

        UserService userService = new UserService() {

            @Override
            public void hello() {

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

interface UserService{
    void hello();
}