动力节点——static关键字（十）

一，static引入

引出static关键字的主要使用目的：

被static修饰的成员变量是被所有对象共享。

eg：

class  Person{

        private  String  name;

        private  int  age;

        private  static  String  country;//国籍

        public  Person(){

          

        }

        public  Person(String  name,int  age){

                this.name=name;

                this.age=age;

        }

        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  getCountry(){

                return  country;

        }

        public  void  setCountry(String  country){

                this.country=country;

        }

}

public  class  StaticDemo{

        public  static  void  main(String[]  args){

                Person  p1=new  Person("小明"，20);

                Person  p2=new  Person("小张"，25)；

                Person  p3=new  Person("小强"，28);

                

                //指定三个人的国籍

                p1.setCountry("中国");

                p2.setCountry("中国");

                p3.setCountry("中国");

                p2.setCountry("美国");

                System.out.println("小明的国籍："+p1.setCountry());        //中国            美国

                System.out.println("小张的国籍："+p2.setCountry());        //中国            美国

                System.out.println("小强的国籍："+p3.setCountry());        //中国            美国

                /*

                国籍country加了static后，全部变美国

                如果还按照过去对象成员变量的处理方式，成员变量在每个对象的内存空间中各有一份；

                绝对不可能改变一个对象，能影响到同一个类的其它对象。

                一定是所有对象共享了国籍这个成员变量的唯一的一份内存空间。

                所以这个国籍的属性一定不是属于任何对象的。

                所以这个国籍的属性是属于类的。

                */

        }

}

二，static修饰的成员变量

static对成员变量的影响：

1，被static修饰的成员变量是被类的所有对象共享的。

2，被static修饰的成员变量不是属于对象的，是属于类。

3，静态成员变量调用方式：

第一种：对象名称 . 静态成员变量名称；

第二种：类名称 . 静态成员变量名称；（重要   常用）

4，静态成员变量是存储在方法区的静态信息描述区。

5，静态成员变量是随着类的加载而创建的。

class  T1{

        static  int  a；

}

public  class  StaticDemo2{

        public  static  void  main(String[]  args){

                //访问静态成员变量的第一种方法，使用对象调用

                //T1  tt=new  T1();

                //tt.a=10;

                //System.out.println("a="+tt.a);

                

                //访问静态成员变量的第二种方式；赋值

                T1.a=10；//被static修饰的成员变量属于类的

                System.out.println("a="+a);

        }

}

三，static修饰成员方法

1，静态成员方法属于类的

2，静态成员方法随着类的加载而创建的

3，静态成员方法的调用方法

第一种：对象名称 . 静态方法名称（）；

第二种：类名称 . 静态方法名称（参数值）；    （重要     常用）

calss  T2{

        public  static  void  test(){

                System.out.println("test类的静态成员方法")；

        }

}

public  class  StaticDemo3{

        public  static  void  main(String[]  args){

                //第一种调用T2类的静态成员方法

                T2  tt=new  T2();

                //tt.test();

    

            //第二种调用T2类的静态成员方法

            T2.test();   

        }

}

四，静态成员方法的内存图解

calss  T3{

        int  a=10;//非静态

        static  int  a=20;//静态

        public  void  test1(){

                System.out.println("T3类的普通成员方法")；

        }

        public  static  void  test2(){

                System.out.println("T3类的静态成员方法");

        }

}

public  class  StaticDemo4{

        public  static  void  main(String[]  args){

                T3  tt=new  T3();

                System.out.println("a="+tt.a);

                System.out.println("a="+T3.a)

        }

}

五，静态和非静态成员之间的调用关系

1，非静态：调用静态或者非静态都可以编译通过。

2，静态：只能调用静态，不能调用非静态。

3，为什么静态不能调用非静态？

静态成员方法和非静态成员方法在执行时都会在栈内存开辟空间。

但是非静态成员方法中通过this关键字执行本对象。

静态成员方法中是没有this关键字的（静态成员方法是属于类的，this属于对象 但是没有对象的情况；所以静态成员方法中没有this关键字）。

所以静态成员方法中是不能通过this调用非静态方法。

4，为什么静态可以调用静态？

静态都属于类的，都可以从方法区的类的描述信息的静态标记中找到需要的静态成员并调用。

5，为什么非静态可以调用静态？

非静态成员方法中可以使用this指向本对象，再通过本对象的静态标记找到类的信息区，找到相应的待调用静态成员。

class  T4{

        int  a=10;//非静态成员变量

        static  int  b=20;//静态成员变量

        public  void  test1(){

                System.out.println("普通成员方法test1");

        }

        public  static  void  test2(){

                System.out.println("静态成员方法test2");

        }

        

        //测试非静态调用静态

        public  void  test3(){

                System.out.println("a="+a);//非静态调用非静态成员变量

                System.out.println("b="+b);//非静态调用静态成员变量

                test1();//非静态调用非静态成员方法

                test2();非静态调用静态成员方法

        }

        

        //测试静态调用非静态

        public  static  void  test4(){

                System.out.println("a="+a);//静态不能调用非静态成员变量

                System.out.println("b="+b);//静态能调用静态成员变量

                test1();静态不能调用非静态成员方法

                test2();静态能调用静态成员方法

        } 

}

public  class  StaticDemo5{

        public  static  void  main(String[]  args){

                T4  tt=new  T4();

                tt.test1();

                T4.test2();

                tt.test3();

                T4.test4();

        }

}

六，静态（static）特点：

1，一个类的所有静态成员都属于类的，可以没有对象而存在。

2，在一个类中static关键字常见的可修饰成员是？

类是不可以被static修饰的；构造方法不能被static修饰的。

static可以修饰成员变量、成员方法、内部类。

3，被static修饰成员的调用语法：

静态成员变量：类名称 . 静态成员变量名称；

静态成员方法：类名称 . 静态成员方法名称（参数值）；

4，所有静态成员都是随着类的加载而创建或执行。

5，静态和非静态的调用规则：

非静态可以调用静态也可以调用非静态。

静态只能调用静态，不能调用非静态。

6，静态方法中是没有this和super的。

七，一个对象的创建步骤：

加载

        把class文件加载入内存

        为静态成员变量开辟空间，并默认初始化

        为静态成员变量显示初始化

        为静态成员方法开辟空间

        为普通成员方法开辟空间

创建

        为对象开辟空间

        为普通成员变量开辟空间，并默认初始化

        为普通成员变量显示初始化

        为this和super开辟空间

        执行构造方法

使用

一，static引入

引出static关键字的主要使用目的：

被static修饰的成员变量是被所有对象共享。

eg：

class  Person{

        private  String  name;

        private  int  age;

        private  static  String  country;//国籍

        public  Person(){

          

        }

        public  Person(String  name,int  age){

                this.name=name;

                this.age=age;

        }

        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  getCountry(){

                return  country;

        }

        public  void  setCountry(String  country){

                this.country=country;

        }

}

public  class  StaticDemo{

        public  static  void  main(String[]  args){

                Person  p1=new  Person("小明"，20);

                Person  p2=new  Person("小张"，25)；

                Person  p3=new  Person("小强"，28);

                

                //指定三个人的国籍

                p1.setCountry("中国");

                p2.setCountry("中国");

                p3.setCountry("中国");

                p2.setCountry("美国");

                System.out.println("小明的国籍："+p1.setCountry());        //中国            美国

                System.out.println("小张的国籍："+p2.setCountry());        //中国            美国

                System.out.println("小强的国籍："+p3.setCountry());        //中国            美国

                /*

                国籍country加了static后，全部变美国

                如果还按照过去对象成员变量的处理方式，成员变量在每个对象的内存空间中各有一份；

                绝对不可能改变一个对象，能影响到同一个类的其它对象。

                一定是所有对象共享了国籍这个成员变量的唯一的一份内存空间。

                所以这个国籍的属性一定不是属于任何对象的。

                所以这个国籍的属性是属于类的。

                */

        }

}

二，static修饰的成员变量

static对成员变量的影响：

1，被static修饰的成员变量是被类的所有对象共享的。

2，被static修饰的成员变量不是属于对象的，是属于类。

3，静态成员变量调用方式：

第一种：对象名称 . 静态成员变量名称；

第二种：类名称 . 静态成员变量名称；（重要   常用）

4，静态成员变量是存储在方法区的静态信息描述区。

5，静态成员变量是随着类的加载而创建的。

class  T1{

        static  int  a；

}

public  class  StaticDemo2{

        public  static  void  main(String[]  args){

                //访问静态成员变量的第一种方法，使用对象调用

                //T1  tt=new  T1();

                //tt.a=10;

                //System.out.println("a="+tt.a);

                

                //访问静态成员变量的第二种方式；赋值

                T1.a=10；//被static修饰的成员变量属于类的

                System.out.println("a="+a);

        }

}

三，static修饰成员方法

1，静态成员方法属于类的

2，静态成员方法随着类的加载而创建的

3，静态成员方法的调用方法

第一种：对象名称 . 静态方法名称（）；

第二种：类名称 . 静态方法名称（参数值）；    （重要     常用）

calss  T2{

        public  static  void  test(){

                System.out.println("test类的静态成员方法")；

        }

}

public  class  StaticDemo3{

        public  static  void  main(String[]  args){

                //第一种调用T2类的静态成员方法

                T2  tt=new  T2();

                //tt.test();

    

            //第二种调用T2类的静态成员方法

            T2.test();   

        }

}

四，静态成员方法的内存图解

calss  T3{

        int  a=10;//非静态

        static  int  a=20;//静态

        public  void  test1(){

                System.out.println("T3类的普通成员方法")；

        }

        public  static  void  test2(){

                System.out.println("T3类的静态成员方法");

        }

}

public  class  StaticDemo4{

        public  static  void  main(String[]  args){

                T3  tt=new  T3();

                System.out.println("a="+tt.a);

                System.out.println("a="+T3.a)

        }

}

五，静态和非静态成员之间的调用关系

1，非静态：调用静态或者非静态都可以编译通过。

2，静态：只能调用静态，不能调用非静态。

3，为什么静态不能调用非静态？

静态成员方法和非静态成员方法在执行时都会在栈内存开辟空间。

但是非静态成员方法中通过this关键字执行本对象。

静态成员方法中是没有this关键字的（静态成员方法是属于类的，this属于对象 但是没有对象的情况；所以静态成员方法中没有this关键字）。

所以静态成员方法中是不能通过this调用非静态方法。

4，为什么静态可以调用静态？

静态都属于类的，都可以从方法区的类的描述信息的静态标记中找到需要的静态成员并调用。

5，为什么非静态可以调用静态？

非静态成员方法中可以使用this指向本对象，再通过本对象的静态标记找到类的信息区，找到相应的待调用静态成员。

class  T4{

        int  a=10;//非静态成员变量

        static  int  b=20;//静态成员变量

        public  void  test1(){

                System.out.println("普通成员方法test1");

        }

        public  static  void  test2(){

                System.out.println("静态成员方法test2");

        }

        

        //测试非静态调用静态

        public  void  test3(){

                System.out.println("a="+a);//非静态调用非静态成员变量

                System.out.println("b="+b);//非静态调用静态成员变量

                test1();//非静态调用非静态成员方法

                test2();非静态调用静态成员方法

        }

        

        //测试静态调用非静态

        public  static  void  test4(){

                System.out.println("a="+a);//静态不能调用非静态成员变量

                System.out.println("b="+b);//静态能调用静态成员变量

                test1();静态不能调用非静态成员方法

                test2();静态能调用静态成员方法

        } 

}

public  class  StaticDemo5{

        public  static  void  main(String[]  args){

                T4  tt=new  T4();

                tt.test1();

                T4.test2();

                tt.test3();

                T4.test4();

        }

}

六，静态（static）特点：

1，一个类的所有静态成员都属于类的，可以没有对象而存在。

2，在一个类中static关键字常见的可修饰成员是？

类是不可以被static修饰的；构造方法不能被static修饰的。

static可以修饰成员变量、成员方法、内部类。

3，被static修饰成员的调用语法：

静态成员变量：类名称 . 静态成员变量名称；

静态成员方法：类名称 . 静态成员方法名称（参数值）；

4，所有静态成员都是随着类的加载而创建或执行。

5，静态和非静态的调用规则：

非静态可以调用静态也可以调用非静态。

静态只能调用静态，不能调用非静态。

6，静态方法中是没有this和super的。

七，一个对象的创建步骤：

加载

        把class文件加载入内存

        为静态成员变量开辟空间，并默认初始化

        为静态成员变量显示初始化

        为静态成员方法开辟空间

        为普通成员方法开辟空间

创建

        为对象开辟空间

        为普通成员变量开辟空间，并默认初始化

        为普通成员变量显示初始化

        为this和super开辟空间

        执行构造方法

使用