Day10-static，类 ， 接口

static

类变量

public class Main{
    public static int a = 10;
    public String name = "chenchenchen"
    public static void main(String[] args){
        System.out.println(Main.a);
        System.out.println(Main.name);//错误，name不是类变量
        Main s = new Main();
        System.out.println(s.a);	  //正确
    }
}  

静态代码块

public class Main{
    {
        System.out.println("匿名代码块");
    }
    static{
        System.out.println("静态代码块");
    }
    public Main(){
        System.out.println("构造器");
    }
    public static void main(String[] args){
        Main main1 = new Main();
        //输出 静态代码块 匿名代码块 构造器
        Main main2 = new Main();
        //输出  匿名代码块 构造器  
        //静态代码块只随类加载一次
    }
}  

抽象类

一种约束

1. 不能被实例化，只能被继承，由子类来实现
2. 抽象方法必须在抽象类中，抽象类中可以有普通方法
3. java中抽象类更利于代码的维护和重用，对比较重要的东西进行限制，也是一种保护
4. 抽象类也有构造方法，只是不能实例化而已

接口

抽象类的抽象，一种专业级别的约束，实现了多继承

1. 用interface来定义，用implement来实现
2. 接口中的方法 默认为 public abstract
3. 接口中一般不定义常量，如果有 默认为 public static final
4. 接口中的方法必须被实现
5. 将定义与实现分离开来

public interface Student{
    void add(String name);
}
public class Main implement{
    public void add(String name){	//必须重写接口中的方法
        
    }
    public static void main(String[] args){
    }
}

匿名类

public class Main{
    public static void main(String[] args){
        new A.say();	//不将实例保存到对象中
        new B(){
            public void haha(){
                
            }
        }
    }
}
public  class A{
    public void say(){
        System.out.println("hi");
    }
}
public interface B{
    void haha();
}

内部类

public class Main{
    public static void main(String[] args){
        A.B s = new A().new B();
        s.in();	//内部类最重要特点，可以调用外部类的私有属性
    }
}
public class A{
    private int id = 10;
    public void say(){
        System.out.println("hi");
    }
    class B{
        public void in(){
            System.out.println("in");
            System.out.println(id);
        }
    }
}