[11]static

static ：一个成员修饰符

静态方法

先来看一个例子：

public class Person {
    private String name;
    public void sleep() {
        System.out.println("sleep");
	}
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
}

public class Demo1 {
	public static void main(String[] args) {
		Person p=new Person();
		p.sleep();
	}
}

以上我们可以关注到：

1.我们创建对象并产生实例，并进行数据的封装。是为了调用被封装的数据

2.但我们在堆内存中创建了对象，占用了内存。结果sleep()并没有用到封装的数据。

3.虽说没问题，编译能通过，思路没错。但浪费了堆内存。

所以为此，我们用static修饰符修改以上代码，达到优化效果，如下:

public class Person {
    private String name;
    public static void sleep() {
        System.out.println("sleep");
	}
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
}

public class Demo1 {
	public static void main(String[] args) {
        Person.sleep();
	}
}

用Static修饰后，用类名进行访问。

所以当一个功能并不需要访问成员变量（非静态）时，使用静态修饰符修饰方法。

所以，用对象调用这种函数没问题，但是最好用static通过类名调用。空出堆内存

静态方法使用注意事项：

1.不能访问非静态的成员。因为不是一个区域的。

1.1静态是随着类的加载而加载的

1.2静态优先于对象存在。

1.3那么静态比对象先存在，所以后续的非静态是通过对象加载才出现。所以静态无法访问非静态

但是非静态的方法，是可以访问静态成员的。

综上所述：静态的弊端就是有了局限性，但是好处就是能够通过类名调用函数。

2.静态方法中不能出现this,super关键字

因为对象后面可能被当成垃圾回收了，this和super就没有指向

既然说到了静态方法，那么有一个非常常见的静态方法可以说一下

class Demo{
    public static void main(String[] args){
        System.out.println(args);//[Ljava.lang.String;@7852e922
        System.out.println(args.length);//0
        show();
    }
    
    public static void show(){
        System.out.println("show");
    }
}

1.public ：最大权限。因为是整个程序的入口，不能用private修饰，否则会因为找不到main方法报错。

2.static  ：静态。所以一般其他方法在创建的时候，如果是不用对象调用的。就加上static，方便main直接调用

3.void    ：无返回值，虚拟机调用了main函数来运行程序，自然不需要main再返回给虚拟机值。

4.main   ：固定方法名，虚拟机编译的时候会检验是否有main方法

5.String[] args： args=arguments可以更改写法。

注释也写了，结果为"["一维数组,String代表元素类型为String的数组,@代表分隔符,7852e922为哈希值

尝试后发现数组的长度为0。

 静态变量

先说说静态变量与成员变量的区别：

1.所属不同。静态变量所属于类。而成员变量所属于对象。

所以静态变量也称类变量，成员变量也称为实例变量。

2.调用不同。静态变量可以被对象和类调用（最好多数用类），成员变量被对象调用。

3.加载时期不同。静态变量是类加载的时候就加载。成员变量是对象加载再加载。

所以静态变量要优先于成员变量。

4.内存区域不同。静态变量的在方法区（数据共享区），而成员变量在堆内存中

接下来看一个例子，来了解一下静态（代码加图）

代码：

public class Circle {
	private double radius; //圆的半径
	private static double PI=3.14; //圆周率，圆周率不是圆的属性，不需要用对象，所以用到静态。且圆周率是定值，无需更改
	
	public Circle(double radius) {
		// TODO Auto-generated constructor stub
		this.radius=radius;
	}
	
	public double getCircle() {
		return radius*radius*PI;
	}
	
	public static void show() {
		System.out.println("show run");
	}
}


public class Demo1 {
	public static void main(String[] args) {
		Circle circle = new Circle(5.0);
		double dCircle = circle.getCircle();
		Circle.show();
	}
}

解析：

1.代码从Demo开始进入，所以加载Demo类方法区（Demo类中有自己的默认构造函数），static就加载了main(),main()压栈，执行main()方法中的内容

2.因为要创建对象，就要加载对应的类。所以方法区中加载Circle类（有参构造函数，getArea()，radius），static就加载了PI，show()。然后PI进行默认初始化，显式初始化。

3.如果有static代码，static代码在加载Circle类的时候就会仅执行一次。

4.在堆内存中new一个对象，默认初始化radius，然后调用对应的构造方法

5.构造方法内先用super()调用父类的构造函数，然后radius显式初始化

6.构造代码块执行，再执行构造方法内剩余内容。

7.this代码隐藏，指向当前对象，所以,构造方法内的radius指向堆内存的radius

8.构造方法结束，弹栈。

图：