java static关键字

/*
static关键字
被static关键字修饰的变量被所有对象所共享；
被static修饰的数据，在对象之前存在
被static修饰的数据通过类名直接调用 Person.country

static关键字用于修饰成员，对象中存储的是特有数据
static优先于对象存在，static随着类的加载就已经存在了
static修饰的成员多了一种调用方式，就可以直接被类名调用

成员变量与静态变量的区别
1.两个对象的生命周期不同
  成员变量随着对象的创建而存在，随着对象的回收而被释放
  静态变量随着类的加载而存在，随着类的消失而消失
2.调用方式不同，
  成员变量只能被对象调用
  静态变量可以被对象调用，也可以被类名调用
  
3.别名不同
  成员变量成为实例变量
  静态变量称为类变量
  
4.存储位置不同
  成员变量：存在于对象的堆区
  静态变量：方法区/数据区/对象的共享区
*/

class Person
{
    //实例变量，成员变量
    static String name;
    
    //静态成员变量
    static String country="CN";
    
    /*
    静态方法只能够访问静态成员，非静态访问不了
    非静态即可以访问静态成员，也可以访问非静态成员
    静态方法中不可以使用this,super关键字
    主函数是静态的
    静态方法在对象之前存在，如果访问非静态必须要通过对象
    
    */
    public static void show()
    {
        System.out.println(country+":"+name);
    }

}

public class StaticDemo
{
    public static void main()
    {
        //类类型变量
        Person p=new Person();
        p.name="小强";
        p.show();
    }
    
    
}

 

 

 

/*
public static void main(String[] args)

主函数特殊之处
1.格式固定
2.被jvm所识别调用

public 因为权限必须要是最大的
static 调用主函数不需要对象，直接用主函数所属类名调用
void 主函数没有返回值
main 函数名，不是关键字
String[] args 一组参数

*/

class MainDemo
{
    public static void main(String[] args)
    {
        System.out.println("mian1111");
        
    }
    //存在，但是虚拟机不调用
    public static void main(int[] a)
    {  
        System.out.println("main2222");
    } 
}

 

/*
static静态变量内存布局

什么时候用
1.静态变量
  当所有对象中数据都相同时，这个数据可以被静态修饰。
  只要数据在对象中是不同的，对象需要成为特有数据，必须存储在对象neibu
  定义成静态的属性，生命周期最长

2.静态函数
  考虑的主要因素，需不需要访问对象中的特有数据
  简单点说：该功能是否需要访问对象的特有数据。如果需要，定义成非静态
  如果不需要，定义成为静态；

*/

class Person
{
    private String name;
    private int age;
    static String country="china";
    
    public Person(String name,int age)
    {
        this.name=name;
        this.age=age;
    }
    
    public void show()
    {
        System.out.println(Person.country+":"+this.name);
    }
    
    public static void methon()
    {
        System.out.println(Person.country);
    }
}

class StaticDemo2
{
    public static void main(String[] args)
    {
        Person.methon();
        Person p=new Person();
        p.show();
    }
    
    
}

 

代码加载速度：

静态代码块-》构造代码块-》构造函数

/*
静态代码块
随着类的加载而执行，而且只执行一次，
作用：给类初始化
*/
/*
输出结果：
hahaha
show run
*/

class StaticCode
{
    static
    {
        //给类初始化
        System.out.println("hahaha");
    }
    void show()
    {
        System.out.println("show run");
    }
    
}

class StaticCodeDemo
{
    public static void main(String[] args)
    {
        new StaticCode().show();        
    }
    
}

/*
构造代码块
*/
*/
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 p = null;
//        p.speak();

//        Person.show();
//        Person p1 = new Person();
//        p1.speak();
//        Person p2 = new Person("旺财");
//        p2.speak();
//        new Person();
        

//        new StaticCode().show();
//        new StaticCode().show();
//        StaticCode.show();
//        System.out.println("b");
    }
}