static关键字：
用于修饰成员(成员变量和成员函数)
被修饰后的成员具备一下特点：
1、随着类的加载而加载
2、优先于对象存在
3、可以被所有对象共享 ：当多个对象中有一个属性都相同时，把这个属性定位static，通过对象调用属性就可共享此属性。
4、可以直接被类名调用，不必创建对象。
使用注意：
静态方法只能访问静态成员。
静态方法中不能写this,super关键字。
mian主函数是静态的。
statice 的特点：
1、static 是修饰符，可以修饰成员和方法。
2、static修饰的成员被所有的对象所共享。
3、static优先于对象存在，因为static的成员随着类的加载就已经存在了。比如：饮水机和杯子，教室里面的饮水机随着教师的额出现而出现，而杯子是学生所特有的，教室就是类。
4、static修饰的成员多了一种调用的方式，用类名直接调用。类名.静态成员。
5、static修饰的是共享数据，对象中存储的是特有的数据。
成员变量和静态变量的区别：
1、两个变量的生命周期不同。
成员变量随着对象的创建而存在，对象的被回收而释放。
静态变量随着类加载而存在，随着类的消失而消失。
2、调用方式不同。
成员变量只能创建对象，通过对象来调用。
静态变量可以被对象调用，也可以被类名直接调用。 考虑内存方面，静态变量更优先选择被类调用，因为创建对象，需要开辟内存空间。
3、别名不同。
成员变量也称为实例变量。
静态变量称为类变量。
4、数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也称对象的特有数据。
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据
静态方法是使用事项：
1、静态方法只能访问(使用)静态成员。非静态方法既可以访问静态，又可以访问非静态。
2、静态方法中不能存在this，或super关键字。 this指代当前对象，静态成员优先与对象执行。
3、主函数是静态的。
class Person
{
String name;//成员变量，实例变量
static String country = "CN";//静态变量。类变量
public void show()
{
System.out.println(Person.country+":"+this.name);
}
}
/*
static的特点：
1，static是一个修饰符，用于修饰成员。
2，static修饰的成员被所有的对象所共享。
3，static优先于对象存在，因为static的成员随着类的加载就已经存在了。
4，static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。
5，static修饰的数据是共享数据，对象中的存储的是特有数据。
成员变量和静态变量的区别？
1，两个变量的生命周期不同。
成员变量随着对象的创建而存在，随着对象的被回收而释放。
静态变量随着类的加载而存在，随着类的消失而消失。
2，调用方式不同。
成员变量只能被对象调用。
静态变量可以被对象调用，还可以被类名调用。
3，别名不同。
成员变量也称为实例变量。
静态变量称为类变量。
4，数据存储位置不同。
成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.
静态使用的注意事项：
1，静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2，静态方法中不可以使用this或者super关键字。
3，主函数是静态的。
*/
class StaticDemo
{
int num = 4;
public static void main(String[] args)
{
// Person p = new Person();
// p.name = "小强";
// p.show();
// System.out.println(p.country);
// System.out.println(Person.country);
// Person.show();
new StaticDemo().show();
}
public void show()
{
System.out.println(num);
}
}public static void main(String[ ] args)
主函数特殊之处：
1、格式是固定的。
2、被jvm所识别和调用
public : 因为权限必须是最大的。
static : 不需要对象的，直接用主函数所属类名调用即可。
void ：主函数没有具体的返回值。
main : 函数名，不是关键字，只是JVM识别的固定的名字。
String[ ] args :这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。
/*
public static void main(String[] args)
主函数特殊之处：
1，格式是固定的。
2，被jvm所识别和调用。
public:因为权限必须是最大的。
static:不需要对象的,直接用主函数所属类名调用即可。
void：主函数没有具体的返回值。
main:函数名，不是关键字，只是一个jvm识别的固定的名字。
String[] args:这是主函数的参数列表，是一个数组类型的参数，而且元素都是字符串类型。
*/
class MainDemo
{
public static void main(String[] args) //new String[0]
{
/**/
// System.out.println(args);//[Ljava.lang.String;@c17164
System.out.println(args.length);
for(int x=0; x<args.length; x++)
System.out.println(args[x]);
}
}静态什么时候用？
1，静态变量。
当分析对象中所具备的成员变量的值都是相同的 。
这时这个成员就可以被静态修饰。
只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
2，静态函数。
函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
但是非静态需要被对象调用，而仅创建对象调用非静态的
没有访问特有数据的方法，该对象的创建是没有意义。
class Demo
{
int age ;
static int num = 9;
Demo(int age)
{
this.age = age;
}
public static void speak()
{
System.out.println(num);
}
public void show()
{
System.out.println(age);
}
}
class StaticDemo3
{
public static void main(String[] args)
{
// Demo d = new Demo(30);
// d.speak();
Demo.speak();
// System.out.println("Hello World!");
}
}
static 静态代码块
随着类的加载而执行(首先执行static静态代码块)，而且只执行一次。
作用：用于给类进行初始化。
class StaticCode
{
static int num ;
static
{
num = 10;
// num *=3;
System.out.println("hahahah");
}
StaticCode(){}
static void show()
{
System.out.println(num);
}
}
class Person
{
private String name;
{//构造代码块。可以给所有对象进行初始化的。
System.out.println("constructor code ");
// cry();
}
static
{
System.out.println("static code");
}
Person()//是给对应的对象进行针对性的初始化。
{
name = "baby";
// cry();
}
Person(String name)
{
this.name = name;
// cry();
}
public void cry()
{
System.out.println("哇哇");
}
public void speak()
{
System.out.println("name:"+name);
}
static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
static
{
// System.out.println("a");
}
public static void main(String[] args)
{
}
}构造代码块：
在创建对象的时候，给对象赋初始值。
构造代码块与构造函数的区别：
构造代码块，只要一创建对对象，就会调用执行。构造函数是针对特定的对象，进行初始化。
class StaticCode
{
static int num ;
static
{
num = 10;
// num *=3;
System.out.println("hahahah");
}
StaticCode(){}
static void show()
{
System.out.println(num);
}
}
class Person
{
private String name;
{//构造代码块。可以给所有对象进行初始化的。
System.out.println("constructor code ");
cry();
}
static
{
System.out.println("static code");
}
Person()//是给对应的对象进行针对性的初始化。
{
name = "baby";
// cry();
}
Person(String name)
{
this.name = name;
// cry();
}
public void cry()
{
System.out.println("哇哇");
}
public void speak()
{
System.out.println("name:"+name);
}
static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
static
{
// System.out.println("a");
}
public static void main(String[] args)
{
Person P1=new Person();
P1.speak();
Person p2=new Person("张三");
p2.speak();
}
}运行结果：
构造代码快总是先执行。
面试题：静态代码块、构造函数、构造代码块的执行顺序。
答案： 静态代码块——>构造代码块——>构造函数。