Static、抽象类、接口、内部类

Static关键字详解

静态方法里不能调用非静态方法（因为静态方法和类一起加载）

public class Static_metod {
    {
        System.out.println("匿名代码块"); //在构造方法执行之前执行
    }
    static {
        System.out.println("静态代码块"); //和类一起加载,并且只执行一次
    }
    public Static_metod(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Static_metod static_metod = new Static_metod();
    }
}

小结：
1.匿名代码块可以用来赋初始值

2.Static只执行一次，而匿名代码块和构造方法只要对象一创建就会执行

3.被final关键字修饰的类，不能被其它类继承

抽象类

被abstract关键字修饰的类，叫做抽象类

抽象方法：被abstract关键字修饰的方法，并且抽象方法只有方法名，没有方法体

注：抽象类的子类必须实现父类的所有方法（除非子类也是抽象类，就不必须事先父类的所有方法）

Java的类继承通过extends实现，并且Java的类只有单继承，接口可以多继承

抽象类的特点：

1.抽象类是一种约束（规范），不能通过new实例化，只能靠子类去实现它
2.抽象类中可以有普通方法
3.抽象方法必须在抽象类中

抽象类存在构造器

抽象类存在的意义：抽象类可以提高开发效率，将一些公共的类抽象出来

接口(interface)

普通类：只有具体的实现

抽象类：既有具体的实现也有规范（抽象方法）

接口：只有规范，自己无法写方法，约束和实现分离：更多的是面向接口编程

=====================================================

可以利用接口实现多继承

一个类可以通过implements关键字，实现多个接口，多个接口通过逗号隔开

public interface Operate {
    //定义的所有属性都是常量public static final
    String name="望穿先生";
    
    //接口中所有定义的方法都是抽象的，定义的时候可以省略 public abstract
    public int add();
    void delete();
    void update();
    void query();
}

public interface Insert {
    void insert();
}

//抽象类通过 extends继承
//类通过 implements 实现接口

//实现了接口的类就必须实现接口中的方法
//接口可以多继承，多个接口通过逗号隔开
public class OperateImple implements Operate,Insert{
    @Override
    public int add() {
        return 0;
    }

    @Override
    public void delete() {

    }

    @Override
    public void update() {

    }

    @Override
    public void query() {

    }

    @Override
    public void insert() {

    }
}

接口小结：

1.接口是一种约束

2.可以通过接口定义一些方法，让不同的人实现

3.接口中的方法都是抽象的默认通过 public abstract 修饰

4.接口中属性都是常量默认通过 public static final 修饰

5.接口不能被实例化，因为接口没有构造方法

6.通过implements可以实现多个接口，并且一个类实现接口必须实现接口里面的所有方法

内部类

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

注：static内部类不能访问外部类中的非static的属性，因为被static修饰的内部类在外部类加载的时候就被定义了，而外部类中的非static属性还没有被定义，多以无法访问到。

//外部类
public class Outer {
    private int age=21;
    public void out(){
        System.out.println("外部类的方法！");
    }
    //内部类
    public class iner{
        public void in(){
            System.out.println("内部类的方法！");
        }
        //内部类可以使用外部类的私有属性
        public void getage(){
            System.out.println(age);
        }
    }
}

//mian方法中调用内部类
public class Application {
    public static void main(String[] args) {
        //实例化一个外部类
        Outer outer = new Outer();

        //通过外部类实例化一个内部类
        Outer.iner iner = outer.new iner();
        iner.getage();
    }
}

一个Java类中可以有多个class类，但是只能有一个public类

public class Demo {
    
}

//也称作内部类
class Demo2{
    
}
class Demo3{
    
}