2019-03-06 Java Interface

Java static

• static 特点

1. static是一个修饰符，用于修饰成员。
2. static修饰的成员被所有的对象所共享。
3. static修饰的数据是共享数据，对象中的存储的是特有数据。
4. static优先于对象存在，因为static的成员随着类的加载就已经存在了。
5. static修饰的成员多了一种调用方式，就可以直接被类名所调用 。类名.静态成员 。

• 何时使用静态变量

1. 对象中所具备的成员变量的值都是相同的 ，这时这个成员就可以被静态修饰。
2. 只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
3. 如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。

• 何时使用静态函数

1. 函数是否用静态修饰就参考一点，该函数功能是否有访问到对象中的特有数据。
2. 简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
3. 如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
4. 但是非静态需要被对象调用，而仅创建对象调用非静态的
5. 没有访问特有数据的方法，该对象的创建是没有意义。

• 成员变量和静态变量的区别？

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

• 静态使用的注意事项：

1. 静态方法只能访问静态成员。(非静态既可以访问静态，又可以访问非静态)
2. 静态方法中不可以使用this或者super关键字。
3. 主函数是静态的。

---

• static 代码分析 01

1. 静态代码块。
   随着类的加载而执行。而且只执行一次。
   作用：用于给类进行初始化。

public class A_test {
      static int num ;
      static
      {
            num = 10;
            System.out.println("hahahah");
      }
      
      public static void main(String args[]) {
            show();
      }
      
      static {
            System.out.println("hihi");
      }
      
      {
            System.out.println("12345");
      }
      
      static void show()
      {
            System.out.println(num);
      }
}

output:

hahahah
hihi
10

2. 构造代码块。可以给所有对象进行初始化的。

class PersonTest
{
      private String name;
      
      {//构造代码块。可以给所有对象进行初始化的。
            System.out.println("constructor code 001");
      }
      
      static
      {
            System.out.println("static code 001");
      }
      
      {//构造代码块。可以给所有对象进行初始化的。
            System.out.println("constructor code 002");
      }
      
      static
      {
            System.out.println("static code 002");
      }
      
      PersonTest()//是给对应的对象进行针对性的初始化。
      {
            name = "baby";
            cry();
      }
      PersonTest(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 StaticCodeTest
{
      static int num ;
      static
      {
            num = 10;
            System.out.println("StaticCodeTest 001");
      }
      StaticCodeTest(){}
      static void show()
      {
            System.out.println(num);
      }
}

1) test01

public class AJavaTest{
      public static void main(String args[]) {
            PersonTest.show();
      }
}

OUTPUT:

static code 001
static code 002
show run

2) test02

public class AJavaTest{
      public static void main(String args[]) {
            PersonTest p1 = new PersonTest();
            p1.speak();
      }
}

OUTPUT:

static code 001
static code 002
constructor code 001
constructor code 002
哇哇
name:baby

执行顺序： 初始化静态模块代码 -> 初始化代码块 -> 初始化对象 -> 调用函数

3) test03

public class AJavaTest{
      public static void main(String args[]) {
            PersonTest p2 = new PersonTest("旺财");
            p2.speak();
      }
}

OUTPUT:

static code 001
static code 002
constructor code 001
constructor code 002
哇哇
name:旺财

4) test04

public class AJavaTest{
      public static void main(String args[]) {
            new PersonTest();
      }
}

OUTPUT:

static code 001
static code 002
constructor code 001
constructor code 002
哇哇

执行顺序：同test01

class StaticCodeTest
{
      static int num ;
      static
      {
            num = 10;
            System.out.println("StaticCodeTest 001");
      }
      StaticCodeTest(){}
      static void show()
      {
            System.out.println(num);
      }
}

5) test05

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

OUTPUT:

StaticCodeTest 001
10
10

解析： static类型作为类成员变量，只初始化一次。

• static 代码分析 02

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();
      }
}

报错：The static method speak() from the type Demo should be accessed in a static way
分析： 访问的变量是非静态的，因此有误。

• 子父类负载静态方法

class Fu1
{
      public static  void show()
      {
            System.out.println("fu show run");
      }
}
class  Zi1 extends Fu1
{
      public static void show()
      {
            System.out.println("Zi show run");
      }
}
class ExtendsDemo3
{
      public static void main(String[] args)
      {
            Zi1 z = new Zi1();
            z.show();
      }
}

OUTPUT:

Zi show run

注： 静态只能覆盖静态，或被静态覆盖。