【化神系列】Java中static与内部类

前言：

• 变量的分类：

1.根据声明的位置来划分

在方法体当中声明的变量叫做：局部变量 。

在方法体外声明的变量叫做：成员变量（全局变量）

注意：

(1)main 函数内的变量不是全局变量，而是局部变量，只不过它的生命周期和全局变量一样长而已。

(2)全局变量一定是定义在函数外部的。

• 成员变量分为：实例变量 静态变量

静态变量都用类名访问，加static的变量叫做静态变量，在类加载时初始化，静态变量储存在方法区。

实例变量的都要先new对象，然后引用访问。否则可能会出现空指针异常。

• java中三个变量分别储存在那块内存上？

局部变量在栈内存，静态变量在方法区，实例变量在堆内存。 也就是三个内存中都有变量。

一、理解static

 class Student {
    String name;
    String sex;
    int age;
    String school = "SchoolA";
    public Student(String name,String sex,int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
   public static void main(String[] args) {
        Student s1 = new Student("花花","女",3);
        Student s2 = new Student("小明","男",18);
        Student s3 = new Student("KiKi","女",5);
    }
}

即：School 与 Student类中具体的对象没有关系，只与Student这个类有关系

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的

✅介绍Java当中静态成员的特点？

类的静态成员是通过static关键字修饰的成员，主要包括静态变量、静态方法和静态代码块，具有一下一些特点：

• 在类加载的时候，就进行创建初始化或执行代码
• 他们对于一个类来说都只有一份
• 类的所有实例都可以访问到他们

二、static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性： 不属于某个具体的对象，是所有对象所共享的。

class Student {
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "Java106";//静态成员变量-->类变量
// 访问：一般通过类名.静态成员变量去访问，不推荐使用对象去进行访问
//不依赖于对象
    public Student(String jim, String 男, int i, double v) {}

    public static void main(String[] args) {
// 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
// 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
    }
}

特点：

• 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
• 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
• 类变量存储在方法区当中
• 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

哈希值：由系统随机给出，就是一个对象的地址值，是一个逻辑地址，，不是实际地址。
四者打印的哈希值一样，验证了静态成员变量只有一份。

三、static修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public ，那static修饰的成员变量如何访问？

非static成员函数可访问static成员函数/成员

静态成员一般是通过静态方法来访问的

public class Student {
    String name;
    String sex;
    int age;
    private static String school = "SchoolA";
    public Student(String name,String sex,int age){
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
    
    public static String getSchool(){
        return school;
    }
}

【静态方法的特性】

• 不属于某个具体的对象，是类方法
• 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
• 不能在静态方法中访问任何非静态成员变量

public static String getClassRoom(){
        System.out.println(this);
        return classRoom;
    } 
    
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
    public static String getClassRoom(){
        age += 1;
        return classRoom;
    } 
 // 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

• 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

• static 的使用

✅ 题一：关于以下程序代码的运行结果是

 public class HasStatic {// 1
    private static int x = 100;// 2
    public static void main(String args[]) {// 3
        HasStatic hsl = new HasStatic();// 4
        hsl.x++;// 5
        HasStatic hs2 = new HasStatic();// 6
        hs2.x++;// 7
        hsl = new HasStatic();// 8
        hsl.x++;// 9
        HasStatic.x--;// 10
        System.out.println(" x=" + x);// 11
    }
}

详解：

本题中的静态成员变量x，属于类变量，只有一份。所有对x的操作针对的都是同一份。静态成员变量的访问需要通过类名访问，这是正确的访问方式。本题中虽然使用了对象引用访问，但是不会报错，我们不建议这样访问，但不是错误，所以，不会编译报错。

故：100 +1 +1+1 -1 = 102

✅题二：如下代码的输出结果是什么？

public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}

详解：

在方法当中定义的变量是局部变量，而静态的变量属于类变量。随着类的加载而被创建，而局部变量是调用该方法的时候，才创建的。

所以，此时两种变量的性质是冲突的。Java当中不允许定义局部的静态变量，故以上代码编译失败

四、代码块

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字 ，可以分为一下几种

• 普通代码块

public class Main{
    public static void main(String[] args) {
        
        {
            //直接使用{}定义，普通方法块
            int x = 10 ;
            System.out.println("x1 = " +x);
        }
        
        int x = 100 ;
        System.out.println("x2 = " +x);
    }
}

• 构造代码块

//构造块：定义在类中的代码块(不加修饰符)。也叫实例代码块。构造代码块一般用于初始化实例成员变量。
class Stu{
    //实例成员变量
    private String name;
    private String gender;
    private int age;
    private String sex;
    private double score;
    
    public Stu() {
        System.out.println("I am Student init()!");
    }

    //实例代码块
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
    }

    public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
    }
}

class TestDdemo2 {
    public static void main(String[] args) {
        Stu stu = new Stu();
        stu.show();
    }
}

• 静态代码块

public class Stu{
    private String name;
    private int age;
    private static String classRoom;
    //实例代码块
    //初始化实例成员变量
    //创建对像时候被执行
    {
        this.name = "bit";
        this.age = 12;
        System.out.println("实例代码块");
    }
    // 静态代码块
    //初始化静态成员变量
    //在类加载的时候就被执行，与先后顺序无关
    //如果都是静态的看顺序
    //静态代码块只能执行一次
    static {
        classRoom = "bit306";
        System.out.println("静态代码块");
    }
    public Stu(){
        System.out.println("不带参数的构造方法");
    }
    public static void main(String[] args) {
        Stu s1 = new Stu();
        System.out.println("++++++++");
        Stu  s2 = new Stu();
    }
}

• 静态代码块不管生成多少个对象，其只会执行一次
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
• 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
• 实例代码块只有在创建对象时才会执行

五、内部类

内部类和外部类共用同一个java源文件，但是经过编译之后，内部类会形成单独的字节码文件

1.实例内部类

class Outclass{
    public int data1 =1;
    public int data2 =2;
    public static int data3 =3;
    /**
     * 实例内部类
     *
     * 1.如何获取实例内部类的对象？
     * Outclass.Innerclass innerclass = outclass.new Innerclass();
     * 2.实例内部类当中不能有静态的成员变量，如果非要使用，则需要用static final修饰
     * 3.在实例内部类中访问外部类中相同的成员变量   外部类.this.成员变量
     */
    class Innerclass{
        public int data1 = 1111;
        //就近原则
        public int data4 =4 ;
        int data5 =5 ;
        public static final int data6 = 10;

        public void func(){
            System.out.println("Innerclass :: func");
            System.out.println(Outclass.this.data1);
            //实例内部类中访问外部类中相同的成员变量
            System.out.println(data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }
    public void test(){
        System.out.println("Outclass :: test");
    }
    /**
    *两种创建内部类对象的方式
    */
    public static void main(String[] args) {
        Outclass.Innerclass innerclass = new Outclass().new Innerclass();
        innerclass.func();
    }
        
    public static void main1(String[] args) {
        //实例内部类对象需要在现有外部类对象的前提下才能创建
        Outclass outclass = new Outclass();
        System.out.println(outclass.data1);

        Outclass.Innerclass innerclass =outclass.new Innerclass();
    }
}

• 外部类中的任何成员都可以在实例内部类方法中直接访问
• 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
• 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
• 实例内部类对象必须在先有外部类对象前提下才能创建
• 实例内部类的非静态方法中包含了一个指向外部类对象的引用
• 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

2.静态内部类

   /**
     *静态内部类
     * 1. 如何获取静态内部类的对象？       
     *    Outclass.Innerclass innerclass = new Outclass.Innerclass();
     * 2. 静态内部类当中不能访问外部类的非静态成员，需要通过外部类对象的引用才能访问；
     *   如果非要访问
     *   Outclass outclass = new Outclass();
     *   System.out.println(outclass.data1);
     * 3.创建静态内部类对象时，不需要先创建外部类对象
     *
     **/
   static class Innerclass{
        public int data4 =4 ;
        int data5 =5 ;
        public static final int data6 = 10;
        public void func(){
            System.out.println("Innerclass :: func");
             //访问外部的非静态成员
            Outclass outclass = new Outclass();
            System.out.println(outclass.data1);
            System.out.println(outclass.data2);
            
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data6);
        }
    }

3.局部内部类（了解）

 /**
     * 局部内部类
     * 1.局部内部类：定义在方法体内部
     * 2.不能被public、static等访问限定符修饰
     */
     
     //只能在此方体的内部使用，其他位置不能使用
    public void test(){
        class Innerclass{
            public void print(){
                System.out.println("Innerclass :: print");
            }
        }
        Innerclass innerclass = new Innerclass();
        innerclass.print();
        
        System.out.println("Outclass :: test");
    }

• 局部内部类只能在所定义的方法体内部使用
• 不能被public、static等修饰符修饰
• 编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class

六、重写toString()方法

toString()方法的源码

public String toString() {
     return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

重写toString()方法

@Override//注解：检查+重写toString方法
public String toString(){
       return "[" + data1 + "," + data2 + "," + data3 + "]";
}

外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

局部内部类只能在所定义的方法体内部使用不能被public、static等修饰符修饰
编译器也有自己独立的字节码文件，命名格式：外部类名字$内部类名字.class