static、代码块、内部类

1. static

在Java中被static修饰的成员，称之为静态成员，也可以称为类成员，它是所有对象共享的。

1.1 static修饰成员变量

• 不属于某个具体的对象，是类的属性，所有的对象共享

• 随类的加载而创建，随类的消失而销毁

• 静态变量储存在方法区中，如果new类型引用类型创建一个对象，此时堆中会存放静态变量的地址，而对象本身存放在堆中

• 可以通过对象调用，也可以通过类名调用。

public class Test {
    public static int test=1;
​
    public static void main(String[] args) {
        //静态成员变量可以直接通过类名访问
        System.out.println(Test.test);
        //也可以通过新建的对象，在其中访问
        Test test1=new Test();
        System.out.println(test1.test);
    }
}

1.2 static修饰成员方法

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。

• 是类方法，不属于某个对象

• 和静态变量一样，可以通过对象调用，也可以通过类名.静态方法名称调用

• 不能在静态方法中访问任何非静态成员变量

  • 无法从静态上下文中引用非静态变量this

  • 无法从静态上下文中引用非静态

  • 无法调用非静态方法，因为非静态方法调用的需要使用this，而静态方法不能调用this

2. 代码块

使用{}定义的一段代码称为代码块

2.1 普通代码块

定义在方法中的代码块

public class Test{
     public static void main(String[] args) {
         {
             int a=1;
             System.out.println(a);
         }
    }
}

2.2 构造代码块

构造块：定义在类中的代码块。也叫实例代码块，一般用来初始成员变量

 public int a;
 {
     this.a=1;
 }

【注意】：先执行构造代码块，在执行构造方法

2.3 静态代码块

一般用来初始化静态成员变量

private static int a;
static{
    a=10;
}

• 静态代码块只会执行一次

• 静态成员变量是类的属性

3.内部类

定义在类的里面，是内部类

3.1 实例内部类

public class Out {
    int a=10;
    private int b=20;
    int c=10;
    class In{
        int c=20;
        //访问外部类
        //可以访问任意限定符修饰的外部类
        public void test(){
            System.out.println(a);
            System.out.println(b);
            //外部类和内部类都有相同的变量，优先访问内部类自己的
            System.out.println(c);
            //想要访问外部类的话，需要进行外部类.this.成员变量
            System.out.println(Out.this.c);
        }
    }
​
    public static void main(String[] args) {
        Out o=new Out();
        Out.In i=o.new In();
        i.test();
    }
}

• 外部类的任意成员，都可以在实例内部类中访问

• 需要先创建外部类，才能创建内部类

• 外部类不能直接访问内部类，需要先创建内部类的对象

3.2静态内部类

• 静态内部类可以访问外部类的静态成员

• 不能访问外部类中的非静态成员和方法

• 访问静态内部类可以直接创建外部类访问，也可以直接创建静态的内部类（不需要创建外部类，在创建内部类）

public class Out {
    static int a=10;
    int b=0;
    public static void method(){
        System.out.println(a);
    }
    public void method1(){
        System.out.println(b);
    }
    static class In{
        public static void a(){
            System.out.println(a);
            //不能访问外部非静态类的成员
            //System.out.println(b);
            method();
            //也不能访问外部非静态的方法
            //method1();
        }
    }
     public static void main(String[] args) {
        //可以创建一个外部类访问内部的静态类
        Out o=new Out();
        Out.In.a();
        //也可以直接创建静态内部类
        Out.In i=new Out.In();
        i.a();
    }
}