static表示静态，是Java中的一个修饰符，可以修饰成员方法和成员变量。

一、静态变量: 被static修饰的成员变量

1.特点：
1）被该类所有的对象共享。
2）不属于对象，属于类。
3）随着类的加载而加载的，优先于对象出现的。
JDK8以前，静态区在方法区里；JDK8以后，静态区（静态存储位置）在堆内存中。
在静态区里存着这个类所有的静态变量。

2.调用方式：
1）类名调用（推荐）
2）对象名调用

二、静态方法：被static修饰的成员方法

1.特点：
1）多用在测试类和工具类中

Javabean类：用来描述一类事物的类。例如Student，Teacher，Dog，Cat等。
测试类：用来检查其他类是否书写正确，带有main方法的类，是程序的入口。
工具类：不是用来描述一类事物的，而是帮我们做一些事情的类。类名见名知意；私有化构造方法；方法定义为静态。

2）Javabean类中很少会用

2.调用方式：
1）类名调用（推荐）
2）对象名调用

3.练习：
1）练习1：
定义数组工具类

需求：在实际开发中，经常会遇到一些数组使用的工具类。
请按照如下要求编写一个数组的工具类：ArrayUtil

提供一个工具类方法printArr，用于返回整数数组的内容。
返回的字符串格式如：[10, 20, 50, 34, 100]（只考虑一维的整数数组）
提供一个工具方法getAverage，用于返回平均分。（只考虑一维的浮点型数组）
定义一个测试类Test，调用该工具类的工具方法，并返回结果。

public class ArrayUtil {
    //私有化构造方法
    //目的：不让外界创建其对象
    private ArrayUtil() {
    }

    //为方便调用需要定义静态方法
    public static String printArr(int[] arr) {
        StringBuilder sb = new StringBuilder();
        sb.append("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                sb.append(arr[i]);
            } else {
                sb.append(arr[i]).append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    public static double getAverage(double[] arr) {
        double sum = 0;
        for (int i = 0; i < arr.length; i++) {
            sum = sum + arr[i];
        }
        return sum / arr.length;
    }
}

public class Test {
    public static void main(String[] args) {
        //测试工具类中的两个方法是否正确
        int[] arr1 = {1, 2, 3, 4, 5};
        String str = ArrayUtil.printArr(arr1);
        System.out.println(str);//[1,2,3,4,5]

        double[] arr2 = {1.5, 6.8, 3.5, 7.2};
        double average = ArrayUtil.getAverage(arr2);
        System.out.println(average);//4.75
    }
}

2）练习2：
定义学生工具类

需求：定义一个集合，用于存储3个学生对象。
学生类的属性为：name, age, gender
定义一个工具类，用于获取集合中最大学生的年龄

public class Student {
    private String name;
    private int age;
    private String gender;

    public Student() {
    }

    public Student(String name, int age, String gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }

    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 String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }
}

import java.util.ArrayList;

public class StudentUtil {
    private StudentUtil() {
    }

    //静态方法
    public static int getMaxAge(ArrayList<Student> list) {
        //1.定义一个参照物
        int max = list.get(0).getAge();
        //2.循环遍历集合
        for (int i = 0; i < list.size(); i++) {
            int tempAge = list.get(i).getAge();
            if (tempAge > max) {
                max = tempAge;
            }
        }
        return max;
    }
}

import java.util.ArrayList;

public class StudentTest {
    public static void main(String[] args) {
        //1.创建一个集合用来存储学生对象
        ArrayList<Student> list = new ArrayList<>();
        //2.创建3个学生对象
        Student s1 = new Student("云苓", 23, "女");
        Student s2 = new Student("黎川", 28, "女");
        Student s3 = new Student("岑溪", 29, "男");
        //3.把学生对象添加到集合中
        list.add(s1);
        list.add(s2);
        list.add(s3);
        //4.调用工具类
        int maxAge = StudentUtil.getMaxAge(list);
        System.out.println(maxAge);//29
    }
}

4.单例设计模式：多线程

三、static的注意事项

1.静态方法只能访问静态变量和静态方法。
2.非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量（实例变量）和非静态的成员方法。
3.静态方法中没有this关键字（非静态方法的this表示当前方法调用者的地址值，this是由虚拟机赋值的）。
4.静态和共享有关；非静态和对象有关。

四、重新认识main方法：

1.public：被JVM调用，访问权限足够大。
2.static：被JVM调用，不用创建对象，直接类名访问。因为main方法是静态的，所以测试类中其他方法也需要是静态的。
3.void：被JVM调用，不需要给JVM返回值。
4.main：一个通用的名称，虽然不是关键字，但是被JVM识别。
5.String[] args：以前用于接收键盘录入数据的，现在没用。（Idea Edit Configuration设置参数）