0506static【重点】

static【重点】

【重点】

1.【没有对象】 【没有对象】 【没有对象】
2.static 修饰的是一个资源共享类型的变量
3.静态成员变量的基本使用规范
    static修饰的成员变量只能通过静态方式访问
    静态成员变量的访问【尽可能使用】类名进行访问
    静态方式修饰的成员变量不论通过哪种方式修改操作数据，都会影响到所有使用的位置
    没有对象！！！可以通过类名直接访问静态成员变量和静态成员方法，不受有无对象限制
4.static修饰的成员方法
    static修饰的成员方法不能访问类内非静态成员变量
    static修饰的成员方法俺不能访问类内非静态成员方法
    static修饰的成员方法可以访问类内其他静态成员方法和其他静态成员变量
5.静态成员方法可以当成工具类使用
6.Arrays工具类
    String toString(任意类型数组);
        返回整个数组的字符串描述方式
    sort(int[] arr);
        排序算法，int类型
        快速排序！！！Quick Sort 性能特别好，占用空间特别大
    int binarySearch(int[] arr, int find);
        二分法查找，找到对应的元素，返回值大于等于0，没有找到返回负数
        【要求】
            当前查询使用的数组必须是升序排序完成的数组   
7.代码块
    只要【使用new + 构造方法创建当前类对象】，就一定会执行构造代码块中的内容
    类文件加载，静态代码块中的内容一定会执行，有且只执行一次！！！
    类文件的加载是当前代码中的确需要当前类，才会进行加载。
8.面试题

1. static概述

static关键字可以修饰方法！！！
static关键字可以修饰成员变量！！！
​
【没有对象】

2. static修饰成员变量【重点】

2.1 生活中的案例

共享单车！！！
    北京是咱们的首都！！！
    在你成为北漂之前，共享单车在北京已经存在了！！！
    在结束北漂生活之后，共享单车是不是还在北京??? 还在！！！
    
    共享单车的归属权是谁???
        美团单车。哈喽单车。
    共享单车和你有关吗???
        只有使用权！！！可以付款租赁使用！！！
    
    共享单车坏掉了，是否会影响你的使用???
        会
    共享单车是否占用了你的空间???
        不会，不占用私人空间
    共享单车是否存在于一个公共区域内???
        是
​
生活案例总结:
    1. 共享单车归属权与你无关！
    2. 共享单车占用的是公共区域！
    3. 共享单车出现问题会影响所有人！
    
    【static修饰成员变量是一个共享资源认知】

2.2 代码中对于static修饰静态成员变量的需求

定义一个Person类
    成员变量：
        姓名，年龄，国籍
class Person {
    private String name;
    private int age;
    private String country;
    
    // 完成对应的Constructor，Setter and Getter
}
​
需求:
    创建三个Person类对象，国籍都是 中华人民共和国
代码:
    Person p1 = new Person("骚磊", 16, "中华人民共和国");
    Person p2 = new Person("骚杰", 26, "中华人民共和国");
    Person p3 = new Person("茂林", 36, "中华人民共和国");

2.3 代码演示static修饰成员变量基本使用

/*
 * 【警告】
 *      The static field Person.country should be accessed in a static way
 *      在Person类内的static修饰成员变量country 应该通过静态方式访问
 * 【处理警告方式】
 *      使用Person类名操作静态成员变量
 * 
 * 【数据共享性】
 *      静态成员变量不管通过哪一种方式修改操作数据，都会影响到所有使用的位置
 * 
 * 【没有对象】
 *      1. 在对象未创建的情况下，静态成员变量可以通过类名直接调用
 *      2. 在对象被销毁的情况下，静态成员变量依然可以通过类名直接调用
 */
class Person {
    private String name;
    private int age;
    public static String country = "中华人民共和国";
​
    public Person() {
    }
​
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
}
​
public class Demo1 {
    public static void main(String[] args) {
        // 静态成员变量在没有创建对象的情况，可以通过类名使用
        System.out.println("Person.country: " + Person.country);
        
        // 匿名对象作为方法的参数
        test(new Person());
        
        // 54行代码执行完毕，是否还存在Person类的对象? 没有对象！！！
        System.out.println("Person.country: " + Person.country);
    }
    
    public static void test(Person person) {
        System.out.println(person);
    }
}

2.4 总结和问题

总结：
    1. 静态成员变量推荐使用的方式是通过类名直接调用，不推荐使用类对象来进行操作，IDE工具中会存在一定的警告提示，与对象无关！！！【没有对象】
    2. 静态成员变量不管通过哪一种方式修改，都会影响到所有的使用者，这是一个【共享资源】
    3. 静态成员变量在类对象创建之前可以使用，类对象销毁之后依然可以使用，【生存期完全不同】，所有说静态成员变量和类对象无关，【没有对象】
    
问题:
    1. 为什么和对象无关?
    2. 什么是没有对象?
    3. 生存周期怎么理解?

2.5 问题解答

2.5.1 内存角度分析【重点】

类对象:
    占用内存空间是内存的【堆区】
    人
        私人空间
​
静态成员变量:
    占用内存空间是内存的【数据区】
    在北京布置的共享单车
        不会占用私人空间，在一个公共区域！！！
    
    类对象和静态成员变量占用的内存空间不属于同一个区域。如果没有引用指向操作，是不存在任何关系。
    从内存角度来分析，【没有关系】
    
    【引用操作】你可以理解成租赁关系！！

2.5.2 从代码加载过程分析【抽象，重点】

public static void main(String[] args) {                        
    // 静态成员变量在没有创建对象的情况，可以通过类名使用         
    System.out.println("Person.country: " + Person.country);    
                                                                
    // 匿名对象作为方法的参数
    test(new Person());                                         
                                                                
    // 54行代码执行完毕，是否还存在Person类的对象? 没有对象！！！  
    System.out.println("Person.country: " + Person.country);    
}                                                               

分析:
    1. 在类对象创建之前，静态成员变量已经可以使用，已经准备完毕！！！
    2. 在类对象销毁之后，静态成员变量依旧可以使用，依然存在！！！
​
生活案例:
    1. 在你去北京之前，共享单车已经存在了
    2. 在你离开北京以后，共享单车依然存在
​
代码加载原理性过程:
    1. .java文件，会通过Java编译器(javac.exe)编译生成对应的.class字节码文件(二进制文件。文件中包含了所有的.java文件内容)
    2. 在程序的加载过程中，.class字节码文件会加载到内存的【方法区】，同时会按照基本的顺序结构【从上至下，从左至右】完成.class字节码文件的加载过程
    3. 在加载过程中，static修饰的内容会在准备就绪，可以执行，可以使用。
    
    以上操作过程过程中，是否和类对象有关???
        整个类文件加载过程中，是完成不依赖对象的创建，所有从加载过程中可以分析得
        出，类对象和静态成员变量无关。【没有对象】
​
​
资源销毁过程:
    1. Java中存在的类对象，是通过该JVM中的垃圾回收机制销毁对象，回收内存。
    2. 静态成员变量是在整个程序退出之后，当前代码中不存在任何一块内存被类对象占用。JVM才会释放.class文件占用的【方法区】空间，与之同时，销毁静态成员变量占用的【数据区】空间
    
    以上操作可以得出，静态成员变量生存周期是远远大于类对象的。早于类对象出现，晚于类对象销毁。类对象和静态成员变量没有关系。【没有对象】

2.6 关于static修饰静态成员变量总结

1. static修饰静态成员变量是一个【共享资源】，但是需要明确当前代码中的确需要对应的共享资源之后，才可以使用static修饰，而且static修饰的方式只是共享资源解决案例的一种。
    例如:
        姓名，年龄，家庭住址...[以上数据不能使用静态]
​
2. static修饰静态成员变量，推荐使用类名调用，因为【没有对象】
3. static修饰的静态成员变量，一处修改，处处受影响，因为【共享资源】
4. static修饰的静态成员变量，在类对象创建之前出现，在类对象销毁之后销毁，生存周期不同，所有【没有对象】
​
【没有对象】
PSFP private static final Person 

3. static修饰成员方法【重点】

3.1 比葫芦画瓢 main方法

public static void main(String[] args) {
    
}
​
main方法就是一个静态方法。
    JVM运行main方法的时候是不需要依赖于任何的对象操作
    静态方法的运行是不依赖于类对象！！！

3.2 static修饰静态成员方法案例

/*
 * 【警告】
 *      The static method testStatic() from the type Car should be accessed in a static way
 *      在Car类static修饰的静态成员方法testStatic() 应该通过静态方法访问
 * 【建议】
 *      static修饰的方法全部采用类名访问！！！
 * 
 * 【错误】
 *      Cannot make a static reference to the non-static field name
 *      在静态成员方法中，不能使用一个静态的引用指向一个非静态成员变量。
 *      在静态成员方法中，不能使用非静态成员变量
 *  
 * 【错误】
 *      Cannot make a static reference to the non-static method test() from the type Car
 *      在一个静态成员方法中，不能使用一个静态引用去操作Car类内的非静态成员方法test();
 *      在静态成员方法中，不能使用非静态成员方法
 * 
 * 【错误】
 *      Cannot use this in a static context
 *      不能在static修饰的静态内容中，使用this关键字
 * 
 * 【可以使用】
 *      静态成员方法中可以使用类内的其他静态成员变量，和其他静态成员方法。
 *      【难兄难弟】
 */
class Car {
    // 非静态成员变量
    public String name;
    
    // 静态成员变量
    public static String color = "白色";
    
    public Car() {}
    
    // 非静态成员方法
    public void test() {
        System.out.println("Car类【非静态成员方法】");
    }
    
    // 静态成员方法
    public static void testStatic() {
        // name = "A4L";
        // test();
        // this.name = "ATSL";
        color = "黑色";
        test2();
        System.out.println("Car类【静态成员方法】");
    }
    
    public static void test2() {
        System.out.println("12321321");
    }
}
​
public class Demo1 {
    public static void main(String[] args) {
        Car car = new Car();
        
        // 通过类对象操作非静态成员变量
        car.name = "领克05";
        
        Car.color = "黑色";
        
        car.test();
        
        // 推荐使用类名调用静态成员方法
        Car.testStatic();
    }
}

3.3 static修饰静态成员方法总结和问题

总结
    1. 静态成员方法不推荐使用类对象调用，而是推荐使用类名直接调用，因为【没有对象】
    2. 静态成员方法中不能够使用类内非静态成员变量 【没有对象】
    3. 静态成员方法中不能够使用类内非静态成员方法 【没有对象】
    4. 静态成员方法中不能够使用this关键字 【没有对象】
    5. 静态成员方法可以使用类内的其他静态成员变量和静态成员方法 【难兄难弟】
​
问题：
    1. 为什么是没有对象???
    2. 为什么静态成员方法可以使用其他静态资源

3.4 问题解答

3.4.1 从静态方法的调用方式来解释

    静态成员方法，我们推荐是采用类名直接调用的！！！当然可以使用类对象调用，只不过会存在警告！！！而且这个警告是非常重要的！！！
    IDE工具都在提示你 (静态成员方法，静态成员变量)与对象无关
    
    静态成员方法和对象无关，那也就是说所有和对象有关的内容就不要使用了！！！
    静态成员方法推荐使用类名调用，那么也就是说调用过程中是没有对象的，所有需要使用对象来操作的非静态成员变量，非静态成员方法都是无法直接在静态方法中使用的。

3.4.2 从加载时间和销毁时间来解释

发现:
    1. 在代码中创建对象之前，静态成员方法已经可以通过类名直接调用，而且是明确可以执行的状态。
    2. 对象销毁之后，依然可以通过类名直接调用静态成员方法
​
代码加载过程的分析:
    1. .java文件通过编译之后，生成对应的.class字节码文件。字节码文件中包含了Java文件的所有内容
    2. Java程序需要运行的时候，首先会加载对应的资源(.class字节码文件)到内存的【方法区】
    3. 加载.class文件的过程中，static修饰的静态成员方法会准备就绪！！！所有运行需要的内容，条件全部OK，可以直接通过类名调用。
    
    整个过程和类对象无关！！！完全是摆脱类对象存在的！！！
​
销毁过程：
    1. 程序运行结束退出之前，会销毁所有的类对象
    2. 所有的类对象销毁之后，对于资源没有任何的需求，资源销毁，内存释放，这时静态成员方法使用空间，才会被销毁。

3.5 静态成员方法的作用

最重要的作用
    工具类！！！
    静态成员方法是完全不依赖成员变量，也不能使用非静态成员方法和非静态成员变量。所有使用的数据，都是外来数据。
    静态成员方法可以摆脱类对象约束，通过类名直接调用。
    好处：
        1. 节约内存。简化逻辑
            不需要创建对象，不需要申请对象空间，也不需要销毁对象空间。
        2. 复用度更高！！！
            摆脱对象的限制，更加自由。
​
今天需要学习的工具类
    Arrays数组工具类

3.5.1 Arrays工具类

需要了解的方法:
    String toString(任意类型数组);
        返回整个数组的字符串描述方式
        int[] arr = {1, 3, 5, 7, 9};
        ==> [1, 3, 5, 7, 9] 
        数组内容使用[]包含，然后元素直接使用 ,+空格 隔开 字符串展示 
        
    sort(int[] arr);
        排序算法，int类型
        快速排序！！！Quick Sort 性能特别好，占用空间特别大
        
    int binarySearch(int[] arr, int find);
        二分法查找，找到对应的元素，返回值大于等于0，没有找到返回负数
        【要求】
            当前查询使用的数组必须是升序排序完成的数组

3.5.2 Arrays工具类使用

import java.util.Arrays;
​
/**
 * Arrays工具类使用演示
 * 
 * 通过Arrays类名直接调用方法，Arrays工具类内的所有方法都是static修饰的
 * 静态成员方法。
 * @author Anonymous
 *
 */
public class Demo2 {
    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 2, 4, 6, 8, 10};
        
        // 将数组转换成字符串形式展示
        String str = Arrays.toString(array);
        System.out.println(str);
        
        // 数组内容排序，默认升序
        Arrays.sort(array);
        System.out.println(Arrays.toString(array));
        
        // 找出指定元素在数组中下标位置，不保证找的元素是第几个！
        int index = Arrays.binarySearch(array, 0);
        System.out.println(index);
        
        System.out.println(array[5]);
    }
}

4. 代码块

代码就是 
    {}包含内容
    主要有:
        方法体代码块，分支结构，循环结构

4.1 构造代码块

功能:
    初始化当前类所有的类对象，只要【使用new + 构造方法创建当前类对象】，就一定会执行构造代码块中的内容
​
格式:
    在class大括号以内，成员变量之后，构造方法之前
    // 构造代码块
    {
    
    }

4.2 静态代码块

功能:
    类文件加载，静态代码块中的内容一定会执行，有且只执行一次！！！
    类文件的加载是当前代码中的确需要当前类，才会进行加载。
​
格式：
    在class大括号以内，成员变量之后，构造方法之前
    // 静态代码块
    static {
    
    }
​
用途:
    一般会使用类文件加载操作过程，完成一定的自动化操作。
    程序的配置，数据的加载，驱动的使用，资源的处理....
    JDBC
​
补充：
    非静态成员变量，非静态成员方法，this关键字都无法在静态代码块中使用。

4.3 面试题【重点】

class Demo {
    static Demo demo1 = new Demo();
    static Demo demo2 = new Demo();
    
    {
        System.out.println("构造代码块");   
    }
    
    static {
        System.out.println("静态代码块");  
    }
    
    public Demo() {
        System.out.println("构造方法");  
    }
    
    public static void main(String[] args) {
        Demo demo1 = new Demo();
    }
}
/*
问:
    代码执行流程!!!
*/

static面试题