✨作者：@小孙的代码分享

✨专栏：《Java SE》

✨送给各位的一句话：空杯心态才能学到新知

✨希望大家看完博客可以有所收获，别忘了，点赞+评论！

🐾 1. static 成员

🐱‍💻 1.1 static的作用

大家先来定义一个学生类

/**
 * @author Sun
 * @version 2021.2
 * @date 2022/5/15 8:46
 */
public class Student {
    public String name;
    public String gender;
    public int age;
    public double score;

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
    public void PrintStudent(){
        System.out.println(name + " " + gender + " " + age + " " + score);
    }

    public static void main(String[] args) {
        Student student1 = new Student("孙宇航","男",20,4.0);
        Student student2 = new Student("金雷","男",21,3.9);
        Student student3 = new Student("杨腾宇","男",19,2.9);
        student1.PrintStudent();
        student2.PrintStudent();
        student3.PrintStudent();
    }
}

在Student类中定义的成员变量，每个对象中都会包含一份实例变量，因为new了三个Student对象，所以此时就有三份实例变量。

如果说三名学生都是一个专业的，我们可以加一个静态的成员变量，来实现所有对象的共享。

🐱‍💻 1.2 static修饰成员变量

static修饰的成员变量，叫做静态成员变量。（实现所有对象共享）

访问static修饰的成员变量有两种方式：

🐱‍👓一：对象.属性(不建议)

🐱‍👓二：类名.属性（建议）

注意： 类变量存储在方法区中；生命周期和类一样。

下面看一下整体代码：

/**
 * @author Sun
 * @version 2021.2
 * @date 2022/5/15 8:46
 */
public class Student {
    //普通成员变量
    public String name;
    public String gender;
    public int age;
    public double score;
    //静态成员变量，不属于对象，实现共享
    public static String department="计算机";

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }
    public void PrintStudent(){
        System.out.println(name + " " + gender + " " + age + " " + score+department);
    }

    public static void main(String[] args) {
        
        Student student1 = new Student("孙宇航","男",20,4.0);
        Student student2 = new Student("金雷","男",21,3.9);
        Student student3 = new Student("杨腾宇","男",19,2.9);
        //通过类名引用
        student1.PrintStudent();
        student2.PrintStudent();
        student3.PrintStudent();
        //不建议
        System.out.println(student1.department);
        System.out.println(student2.department);
        System.out.println(student3.department);
        //建议
        System.out.println(Student.department);
    }
}

🐱‍💻 1.3 static修饰成员方法

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

如何访问静态方法？

因为静态方法是类方法，所以可以直接访问

拓展：如何在静态方法中访问非静态的成员变量？

🐱‍👓一：在静态方法中new一个对象，然后再调用

🐱‍👓二：给静态方法传一个参数（建议）

🐱‍🚀总结：

🐱‍🚀静态方法是类方法，不属于具体的哪个对象；

🐱‍🚀静态方法中，不能直接访问非静态变量；

🐱‍🚀静态方法中，也不能调用非静态方法。

🐾 2.代码块

使用{}定义的一段代码就交代码块，根据代码块定义的位置和关键字，把代码块分成了四种： 🐱‍🚀普通代码块，🐱‍🚀构造代码块，🐱‍🚀静态代码块，🐱‍🚀同步代码块（后边了解）。

🐱‍💻2.1 普通代码块

定义在方法中的代码块，叫做 普通代码块

public static void main(String[] args) {
        {
            int a=10;
            System.out.println("a1="+a);
        }
        int a=200;
        System.out.println("a2="+a);
    }

🐱‍💻2.2 实例代码块（构造代码块）

定义在类中的代码块；用于初始化实例成员变量。

🐱‍💻2.3 静态代码块

使用static定义的代码块；用于初始化静态成员变量。

class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;
    
    static {
        classRoom="ruangong2001";
        System.out.println("static");
    }

    public Student(){
        System.out.println("I am Student!");
    }
}

🐱‍🚀注意：

🐱‍🚀静态代码块不管生成几个对象，只执行一次；

🐱‍🚀静态成员变量是类的属性，因此JVM加载类是开辟空间进行初始化；

🐱‍🚀实例代码块只有在创建对象是才会执行。

执行顺序：

静态代码块优先，实例代码块紧随其后，最后才是构造方法。

🐾 3. 理解内部类

class OuterClass {   
    class InnerClass {
    }
}

什么是内部类？将一个类定义在另一个类或者另一个方法的内部。如上代码，InnerClass{}是内部类，OuterClass就是外部类{}。内部类和外部类共用一个Java源文件，经过编译后，内部类会形成单独的字节码文件。

🐱‍💻 3.1 内部类的分类

内部类可分为4中，今天我们先了解前两种：

🐱‍🚀实例内部类

🐱‍🚀静态内部类

🐱‍🚀本地内部类

🐱‍🚀匿名内部类

🐱‍💻 3.2 实例内部类

实例内部类就是没有static修饰的成员内部类

class OuterClass {
    public int data1=111;
    private int data2=2;
    public static int data3=3;

    /**
     * 实例内部类
     * 1.实例内部类中不能定义静态成员变量
     * 2.实例内部类中不能定义静态成员方法
     * 外部类类名.内部类  变量=外部类引用.new 内部类();
     * OuterClass.InnerClass innerClass=out.new InnerClass();
     */
    class InnerClass {
        public int data1=1;
        public int data4=4;
        private int data5=5;
       //public static int data=6;
        public InnerClass(){
            System.out.println("实例内部类的构造方法");
        }
        public void innerFunc(){
            System.out.println("实例内部类的普通方法");
            
            System.out.println(data1);
            System.out.println(data2);
            System.out.println(data3);
            
        }

    }
}
public class Test {
    public static void main(String[] args) {
        OuterClass out=new OuterClass();
        OuterClass.InnerClass innerClass=out.new InnerClass()；
    }
}

1.在实例内部类中可以直接访问外部类中任意访问限定修饰的成员。

🐱‍🚀如果外部类和实例内部类具有相同名称的成员时，先访问谁，

🐱‍🚀如果要访问外部类同名成员时，如何访问？

🐱‍🚀如果是同名的静态成员呢，如何访问？

答：同名时，优先访问的是内部类中的；要访问外部类同名成员时，外部类类名.this.同名成员名称

2. 实例内部类中，不能直接定义静态的成员变量，如果必须定义，这个静态成员变量就必须被final修饰。

3.实例化实例内部类

//外部类类名.内部类  变量=外部类引用.new 内部类();
OuterClass.InnerClass innerClass=out.new InnerClass();
//外部类类名.内部类  变量=new 外部类().new 内部类();
OuterClass.InnerClass innerClass=new OuterClass().new InnerClass();

🐱‍💻 3.3 静态内部类

被static修饰的内部成员类称为静态内部类。

package innerdemo;

/**
 * @author Sun
 * @version 2021.2
 * @date 2022/5/15 12:35
 */
class OuterClass1{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    static class InnerClass{
        public int data4 =4;
        private int data5= 5;
        public static int data6 =6;

        public InnerClass(){
            System.out.println("静态内部类的构造方法！");
        }
        public void test(){
            System.out.println("test方法执行了！");

            System.out.println(data4);
            System.out.println(data3);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
}
public class TestDemo {
    public static void main(String[] args) {
        OuterClass1.InnerClass innerClass = new OuterClass1.InnerClass();
        innerClass.test();
    }
}

🐱‍🚀注意：

🐱‍🚀在静态内部类中只能访问外部类的静态成员

🐱‍🚀创建今天内部类对象时，不需要先创建外部类对象

1.如何拿到今天内部类中的对象？

外部类类名.内部类类名变量 = new 外部类类名.内部类类名。

2.怎样才能访问外部类中的非静态成员？

直接引用对象

通过参数引用

🐱‍💻 3.4 本地内部类

定义在外部类的方法体或者{}中，本地内部类只能在其定义的位置使用。

package innerdemo;

/**
 * @author Sun
 * @version 2021.2
 * @date 2022/5/15 12:46
 */
public class TestDemo01 {
    public static void func() {
        class X {
            public void test() {
                System.out.println("本地内部类！");
            }
        }
        X x=new X();
        x.test();
    }
    public static void main(String[] args) {
        func();
    }
}

🐾 4.打印对象

package innerdemo;

/**
 * @author Sun
 * @version 2021.2
 * @date 2022/5/15 12:48
 */
class Student {
    public String name;
    public int age;
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class TestDemo02 {
    public static void main(String[] args) {
        Student student=new Student();
        System.out.println(student);
    }
}

学会使用idea，敲代码更方便。