1.静态

在类中，使用 static 修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量，常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。

静态成员不依赖于类的特定实例，被类的所有实例共享，就是说 static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java 虚拟机就可以根据类名找到它们。

其作用是：在同一个类的对象中共享数据。

1.1.静态变量

●静态变量（或称为类变量），指被 static 修饰的成员变量。
●静态变量可以被类的所有实例共享，因此静态变量可以作为实例之间的共享数据增加实例之间的交互性。
●静态变量被分配在方法区中，常驻内存，永不回收。静态变量只有一份。相当于c语言的全局变量。
●如果类的所有实例都包含一个相同的常量属性，则可以把这个属性定义为静态常量类型，从而节省内存空间。例如，在类中定义一个静态常量 PI。

public static double PI = 3.14159256;

特点：
1.运行时，Java 虚拟机只为静态变量分配一次内存，在加载类的过程中完成静态变量的内存分配。
2.在类的内部，可以在任何方法内直接访问静态变量。
3.在其他类中，可以通过类名访问该类中的静态变量。

public class Practice {
    static int age = 2;                        //使用static关键词声明静态方法
    public static void main(String[] args) {
        System.out.println(Practice.age);      //直接用类名访问静态变量
        Practice practice=new Practice();      //创建类的对象
        System.out.println(practice.age);      //使用对象名访问静态变量
        practice.age=3;                        //使用对象名修改静态变量
        System.out.println(practice.age);      //使用对象名访问静态变量,发现静态变量的值已被修改
    }
}

运行结果：
2
2
3

1.2.静态方法

●静态方法（或称为类方法），指被 static 修饰的成员方法。

特点：
1.静态方法不需要通过它所属的类的任何实例就可以被调用
2.静态方法中不能使用 this 关键字和 super 关键字。
3.不能直接访问所属类的实例变量和实例方法。
4.可以直接访问所属类的静态变量和静态方法。

直接调用对应的方法即可：

public class Practice {
    public static void print() {
        System.out.println("静态方法");   //使用static关键词声明静态方法
    }
    public static void main(String[] args) {
        Practice.print();                //直接使用类名调用静态方法
        Practice practice=new Practice();//创建类的对象
        practice.print();                //使用对象名调用静态方法，不推荐使用
    }
}

运行结果：
静态方法
静态方法

1.3.静态块

●静态代码块指 Java 类中的 static{ } 代码块，主要用于初始化类，为类的静态变量赋初始值，提升程序性能。

特点：
1.类名首次出现时，先为静态变量分配内存，然后调用静态块，静态块可以为静态变量初始化及其他作用。
2.静态块只在类名首次出现时调用一次，以后再也不调用了。

public class Practice {
    static int age;// 声明静态变量age
    static {
        age=3;     //静态块，在首次类名出现时调用，为静态变量age初始化
    }
    public static void main(String[] args) {
        System.out.println(Practice.age); //类名访问静态变量，发现已被赋值
    }
}

2.实例（instance）

实例也叫对象，就是new出来的堆的内存空间，实例是每个对象专有的，每new一次就分配一次内存

2.1.实例变量

●指没有被 static 修饰的成员变量。

特点：
1.每创建一个实例，Java 虚拟机就会为实例变量分配一次内存。
2.在类的内部，可以在非静态方法中直接访问实例变量。
3.在本类的静态方法或其他类中则需要通过类的实例对象进行访问。

public class Practice {
    int age; //声明实例变量age
    public Practice(int age) {   //构造方法，为age初始化
        this.age = age;
    }
    public static void main(String[] args) {
        Practice age=new Practice(2);  //创建实例，并初始化
        System.out.println(age.age);       //用对象名访问实例变量age，已被赋值2
    }
}

输出结果:
2

2.2.实例方法：

●实例方法，指没有被 static 修饰的成员方法。

特点：
在实例方法中可以直接访问所属类的静态变量、静态方法、实例变量和实例方法。

public class Practice {
    static int age = 2;  //声明静态变量age
    String name = "实例变量"; //声明实例变量name

    public static void staticPrint() {  //声明静态方法staticPrint()
        System.out.println("静态方法");
    }
    public void print() {    //声明实例方法print()
        Practice practice = new Practice();
        System.out.println(age);  //访问静态变量
        System.out.println(name); //访问实例变量
        practice.staticPrint();   //调用practice.staticPrint()方法
    }
    public static void main(String[] args) {
        Practice practice = new Practice();
        practice.print(); //调用实例方法print
    }
}

运行结果：
2
实例变量
静态方法

3.注意

3.1.如果静态成员变量在同一个类里， “类名.变量名” 或者 “变量名” 即可访问（可以省略类名）；

public class Practice {
    static int age=2;  //申明静态变量age
    public static void main(String[] args) {
        System.out.println(age);    //用“变量名”直接访问静态变量
        System.out.println(Practice.age);  //用 “类名.变量名”直接访问静态变量
    }
}

运行结果：
2
2

3.2.静态方法不能直接访问所属类的实例变量。

public class Practice {
    int age;  //实例变量
    public static void main(String[] args) {  //静态方法
        age = 2;  //报错
    }
}

正确写法：

public class Practice {
    int age;   //实例变量
    public static void main(String[] args) {   //静态方法
        new Practice().age = 2;
    }
}

3.3.静态方法不能直接调用所属类的实例方法。

public class Practice {
    public void sayHello(){   //实例方法 

    }

    public static void sayHi(){  //静态方法
        sayHello();   //报错
    }
}

正确写法：

public class Practice {
    public void sayHello(){   //实例方法 
        this.sayHi(null);
    }

    public static void sayHi(Practice practice){   //静态方法
        practice.sayHello();
    }

3.4.静态方法中不能使用 this 关键字。

public class Practice {
    int age;
    public static void main(String[] args) {
        new Practice().age = 2;
    }
    public static void sayHi(){

    }
    public static void sayHello(){
        this.sayHi();   //报错
    }
}

4.静态（static）与实例（instance）的区别：

1、调用方式：

在外部调用静态方法时，可以使用 类名.方法名 的方式，也可以使用 对象.方法名 的方式，而实例方法只有后面这种方式。也就是说，调用静态方法可以无需创建对象 。

2、访问类成员是否存在限制：

静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），不允许访问实例成员（即实例成员变量和实例方法），而实例方法不存在这个限制。

3.分配内存：

实例变量是在new类时在堆中分配内存的，并且new一次就分配一次内存，静态变量被分配在方法区中，常驻内存，永不回收，静态变量只有一份。