Java——static关键字

1.6 static关键字

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

 

 

1.6.1 什么是static

静态的，可以用来修饰属性、方法、*代码块（或初始化块）、*内部类

1.6.2 static修饰属性（类变量）

static修饰的变量叫做静态变量。

①由类创建的所有的对象，都共用这一个属性

②当其中一个对象对此属性进行修改，会导致其他对象对此属性的一个调用。vs 实例变量（非static修饰的属性，各个对象各自拥有一套副本）

③类变量随着类的加载而加载的，而且独一份

④静态的变量可以直接通过“类.类变量”的形式来调用

⑤类变量的加载是要早于对象。所以当有对象以后，可以“对象.类变量”使用。但是"类.实例变量"是不行的。

⑥类变量存在于静态域中。

public class StaticTest04{

       public static void main(String[] args){

              Animal a1 = new Animal("AAA",10);

              Animal a2 = new Animal("BBB",11);

              //如何访问(类名.)

              System.out.println(Animal.type);

              //也可以使用 引用.

              System.out.println(a1.type);

              Animal a3 = null;

              System.out.println(a3.type); //静态变量底层访问的时候一定使用的  类名. 和对象无关，不会出现空指针异常。

       }

}

//抽象现实世界中的“陆生”动物

class Animal{

       //Field

       //成员变量(一个对象一份.)

       //成员变量在创建对象的时候初始化，并且存储在堆中的每一个对象中。

       String name;

       int age;

       //静态变量，被存储在方法区.

       //所有的java对象共享这一份。

       //所以静态变量是类级别的，使用“类名.”的方式访问.

       static String type = "陆生";

       //Constructor

       Animal(String name,int age){

              this.name = name;

              this.age = age;

       }

}

 

 

 

 

【补充】

变量分类：①局部变量②成员变量(实例变量，非静态变量) ③静态变量(方法区)

成员变量：创建java对象的时候初始化。

静态变量：在类加载阶段赋值，并且只赋值一次。

什么时候变量声明成静态变量？

如果这个属性所有的对象都有，并且这个属性的值是相同的，则该属性声明成静态的属性。

1.6.3 static修饰方法（类方法）

static修饰的方法叫做静态方法。

①随着类的加载而加载，在内存中也是独一份

②可以直接通过“类.类方法”的方式调用

③内部可以调用静态的属性或静态的方法，而不能调用非静态的属性或方法。反之，非静态的方法是可以调用静态的属性或静态的方法

④静态的方法内是不可以有this或super关键字的！

注意：静态的结构(static的属性、方法、代码块、内部类)的生命周期要早于非静态的结构，同时被回收也要晚于非静态的结构。一般情况下工具类中的方法大部分都是静态方法。静态方法不用创建对象也能直接访问该方法。

public class StaticTest03{

       //成员方法

    //成员方法必须使用“引用.”调用

       public void m1(){  }

       //静态方法

    //可以使用“类名.”方式调用.也可以用“引用.”，即使用的是“引用.”，底层还是用的“类名.”

    //静态方法中不能直接访问非静态数据.

    //静态方法中不能使用this

       public static void m2(){

              System.out.println("m2....");

       }

       //入口

       public static void main(String[] args){

              StaticTest03 st = new StaticTest03();

              st.m1();

              m2();

           //静态的方法按照正规的方式访问：“类名.”

       //静态的方法也能用“引用.”访问

              st.m2(); //编译阶段检查出st是StaticTest03类型，编译通过，运行的时候，仍然使用 "StaticTest03."的方式访问。//该方法执行不需要对象。

 

              //空的引用去访问成员的时候会出现空指针异常。

       //m2方法不是“成员”而是静态的。

       //所以即使引用是空的，也不会报空指针异常。

              StaticTest03 s = null;

              s.m2();

       }

}

1.6.4 static定义静态语句块

public class StaticTest01{

       //静态语句块

       static{

              System.out.println("1");

       }

       static{

              System.out.println("2");

       }

       static{

              System.out.println("3");

       }

       static{

              System.out.println("4");

       }

       //入口

       public static void main(String[] args){

              System.out.println("main execute!  1");

              System.out.println("main execute!  2");

       }

}

1.6.5 static定义实例语句块

每一次调用构造方法之前会执行一次。实例语句块执行顺序也是自上而下。

 

public class StaticTest02{

       //静态语句块

       static{

              System.out.println("A");

       }

       //实例语句块

       {

              System.out.println("1");

       }

       {

              System.out.println("2");

       }

       {

              System.out.println("3");

       }

       //构造方法

       StaticTest02(){

              System.out.println("StaticTest02无参数的构造执行！");

       }

       //入口

       public static void main(String[] args){

              //调用构造方法

              new StaticTest02();

              new StaticTest02();

              new StaticTest02();

       }

}

1.6.6 关于代码的顺序

public class StaticTest05{

       //编译通过

       static int i = 100;

       static{

              System.out.println(i);

       }

       //非法向前引用

       /*

       static{

              System.out.println(i);

       }

       static int i = 100;

       */}

       类{

              //可以通过“类名.”，也可以通过“引用.”，即使使用“引用.”底层也是“类名.”

              //1.静态变量

              //2.静态方法

              //必须对象存在才可以访问，采用“引用.”

              //3.成员变量

              //4.成员方法

              //创建对象,给成员变量赋值

              //5.构造方法

//类加载时只执行一次。

              //6.静态语句块

              //构造方法没调用之前执行一次。

              //7.实例语句块

              //用在成员方法和构造方法中。

              //8.this

       }

       空指针异常：空引用访问成员

 

 

补充：

1.JavaBean

JavaBean是一种Java语言写成的可重用组件。

所谓javaBean，是指符合如下标准的Java类：

①类是公共的

②有一个无参的公共的构造器

③有属性，且有对应的get、set方法

④用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包，并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能，而不用关心任何改变。

举例：

public class TestJavaBean{

      private String name;  //属性一般定义为private

      private int age;

      public  TestJavaBean(){}

      public int getAge(){

             return age;

      }

      public void setAge(int age){

             this.age = age;

      }

      public String getName(){

            return name;

      }

      public void setName(String name){

            this.name = name;

}

2.UML类图