Static；匿名代码块；静态代码块；抽象类；接口；内部类

Static

加上static之后就是从属于这个类，其他人用不了，只有本类才能用
public class Student{

private static int age；
private double score；

public static void main(String[] args){

Student s1 = new Student();
//因为是静态变量，在该类中可以直接使用 类.静态变量 来使用，这是通过类来的
//用 类.score 就会出错，因为score不是静态的，只能通过new出的对象来调用
System.out.println(Student.age);

//这是通过new出来的对象来调用变量，所以age和score都可以通过对象来调用
System.out.println(s1.age);
System.out.println(s1.score);

//用static修饰的方法的用法和上述属性也一样
在main方法中调用其他类的方法，如果有static，则只需要用 类.方法() ,
如果没有static，则需要new出对象来，再用 对象.方法() 来调用

}

匿名代码块

public class Person{
{
//匿名代码块，创建对象的时候运行，且在构造器之前，可以赋初始值
}
static{
//static 静态代码块，可以加载一些初始化的数据，和类一起加载，且永久执行一次。
}
}

---

public class Person{
{
System.out.println(“匿名代码块”)；
}
static{
System.out.println(“静态代码块”)；
}
public Person（）{
System.out.println(“构造方法”)
}
public static void main (String[] args){
Person p1 = new Person();
System.out.println("=====")
Person p2 = new Person();
}}

//输出：
静态代码块
匿名代码块
构造方法

========

匿名代码块
构造方法

抽象类 abstract 需要被extends单继承(而接口可以多继承)

在一个类上使用abstract关键字就会变成抽象类
在一个方法上使用abstract就会变成抽象方法，只有方法名字，没有方法的实现（不写内容）
如：
public abstract class Action{
public abstract void run（）；
}
继承了抽象类的子类，必须要实现抽象类（父类）中的抽象方法（在子类中补充上述的run（）方法，自己没做，让儿子来实现，当然儿子也可以在方法上加个abstract，让孙子来实现）
public class A extends Action{
@Override
public void run(){
}}
特点：抽象的抽象：约束

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

接口 使用interface，不用class关键字

普通类：只有具体实现
抽象类：集体事先和规范（抽象方法）都有
接口：只有规范！自己无法写方法~专业的约束！ 约束和实现分离：面向接口编程。它定义了一组规则，体现了现实世界中“如果你是。。。你就必须能。。。”接口的本质就是契约。

//interface定义的关键字，接口都需要有实现类
//接口中的所有定义都默认为是抽象的，是public abstract，可以不用写public abstract
//接口中定义的属性都是默认为常量，默认为是public static final ，可以不写（很少用）

public interface UserService{
int a=22；//默认为是public static final int a = 22；
void add（String name）；
void delete（String name）
}

public interface TimeService{
void timer（）；
}

//implements ：UserService的实现类，和抽象类的extends类似，但它是多继承
//实现了接口的类，就必须重写接口中的方法

public class UserServiceImpl implments UserService，TimeServide{
@Override
public void add（String name）{
}
@Override
public void delete（String name）{
}

@Override
public void timer（）{
}

}

作用：

1. 约束
2. 定义一些方法，让不同的人来实现（比如有10个员工，让他们完成共同的工作，实现一个接口，但有十种不同的实现方式）
3. 方法都默认为public abstract
4. 属性都是静态常量都默认为public abstract final
5. 接口不能被实例化，接口中没有构造方法（因为接口都不是类）
6. 用implements可以实现多个接口
7. 实现接口必须要重写接口中的方法

内部类

内部类可以访问static，但是static的内部类不能访问外部的非static属性，如：Inner这个类如果加了static则无法访问外部类中的out（）方法
内部类可以获得外部类的私有属性，私有方法.

public class Application {
    public static void main(String[] args) {
        Outer outer = new Outer();
        Outer.Inner inner = outer.new Inner();
        inner.privateid();
    }
}

public class Outer {
    private int id=10;
    public void out(){
        System.out.println("这是外部类");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类");
        }
        //内部类可以访问static，但是static的内部类不能访问外部的非static属性，如：Inner这个类如果加了static则无法访问外部类中的out（）方法
        public void privateid (){
            //内部类可以获得外部类的私有属性，私有方法，下面直接输出id，不用get()
            System.out.println(id);
        }
    }
}

一个java类中可以有多个class类，但只能有一个public class（并列的）
public class Outer{
}
class A{

}

方法中也可以写类
public class Outer{
//局部内部类：
public void method（）{
class Inner{
public void in（）{}
}}}

匿名内部类：没有名字初始化类，不用将实例保存到变量中,还能用类中的方法

public class Application {
    public static void main(String[] args) {
        new Apple().eat();
    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}