Java继承和多态-Static关键字

1. 什么是Static 关键字?

Static 能够与变量，方法和类一起使用，称为静态变量，静态方法。如果在一个类中使用static修饰变量或者方法的话，它们可以直接通过类访问，不需要创建一个类的对象来访问成员。

实例：

package com.java.JavaStatic;
/**
 * Understand Java Static
 * @author Jeff
 * @date 2016/03/17
 * http://www.weixueyuan.net/view/6003.html
 */

public class demo01 {
//定义静态变量a
public static int a=1;

//定义变量b
int b=2;

//创建静态方法 sum()
public static int sum (int x,int y) {
return x+y;
}

public static void main (String[] args) {
//通过类访问变量a
System.out.println("a= "+demo01.a);

//实例化对象myDemo访问变量b
demo01 myDemo =new demo01();
System.out.println("b= "+myDemo.b);

//通过类访问方法sum
System.out.println("x+y: "+sum(3,5));
}
}

结果：
a= 1
b= 2
x+y: 8

2. Static 内存分配

静态变量属于类，不属于任何独立的对象，所以无需创建类的实例就可以访问静态变量。之所以会产生这样的结果，是因为编译器只为整个类创建了一个静态变量的副本，也就是只分配一个内存空间，虽然有多个实例，但这些实例共享该内存。实例变量则不同，每创建一个对象，都会分配一次内存空间，不同变量的内存相互独立，互不影响，改变 a 对象的实例变量不会影响 b 对象。

实例：

package com.java.JavaStatic;

/**
 * Static内存分配
 * @author Jeff
 * 2016/4/3
 * http://www.weixueyuan.net/view/6003.html
 */

public class demo02 {
    static int i;
    int j;

    public static void main(String[] args) {
        demo02 obj1 = new demo02();
        obj1.i = 10;
        obj1.j = 20;
        demo02 obj2 = new demo02();
        System.out.println("obj1.i=" + obj1.i + ", obj1.j=" + obj1.j);
        System.out.println("obj2.i=" + obj2.i + ", obj2.j=" + obj2.j);
    }
}

结果：
obj1.i=10, obj1.j=20
obj2.i=10, obj2.j=0

3. 什么情况使用静态方法和静态变量

• 需要通过类访问静态方法和静态变量
• 需要在静态方法中访问静态变量
• 静态方法的类型不是对象型

3. 关于静态变量和静态方法的总结：

• 结论1.构造方法不允许声明为 static 的；
• 结论2.1.静态方法只能访问静态变量
• 结论2.2.静态方法不能访问实例变量
• 结论3.1.静态方法只能够调用静态方法；
• 结论3.2.静态方法不能够调用非静态方法；
• 结论4.静态方法中不存在当前对象，因而不能使用 this,当然也不能使用 super
• 结论5.局部变量不能使用static修饰
• 结论6.1.静态方法能被静态方法重载
• 结论6.2.静态方法能被非静态方法重载
• 结论7.1 静态方法,可以声明object类型,一般不推荐使用静态方法,因为不能通过类访问
• 结论7.2 非静态方法,可以声明object类型,一般推荐使用,因为可以使用实例访问
• 结论8. 静态方法只能在静态类中使用
• 结论9.1.静态方法不能被非静态方法覆盖
• 结论9.2 静态方法能被静态方法覆盖
• 结论10 静态方法直接通过类访问
• 结论11 如访问控制权限允许，静态变量和静态方法也可以通过对象来访问，但是不被推荐
• 结论12 静态方法且类型对象,不能通过类访问

实例：

package com.java.JavaStatic;

/**
 * 静态方法和静态方法总结
 * @author Jeff
 * 2016/04/03
 */

public class demo03 {

public static int a=1;
int b=2;

//结论1.构造方法不允许声明为 static 的；
//                public static demo03 ()
//                {
//                        System.out.println("我是构造方法");
//                }

public int sum (int x,int y) {
return x+y;
}

//静态方法sum2, int类型

public static int sum2 (int x,int y) {
//结论2.1.静态方法只能访问静态变量
a=3;
x=x+a;

//结论2.2.静态方法不能访问实例变量；
//b=3;

//结论3.1.静态方法只能够调用静态方法；
demo03.sum3(1, 2);

//结论3.2.静态方法不能够调用非静态方法；
//demo03.sum(1,2);

//结论4.静态方法中不存在当前对象，因而不能使用 this,当然也不能使用 super
//this.sum3(1, 2);

return x+y;
}

//静态方法sum3,int类型
public static int sum3 (int x,int y) {
//结论5.局部变量不能使用static修饰
//static int c;
return x+y;
}

//结论6.1.静态方法能被静态方法重载
public static int sum3 (int x) {
return x;
}

//结论6.2.静态方法能被非静态方法重载
public int sum3 (int x, int y, int z) {
return x+y+z;
}
//结论7.1 静态方法,可以声明object类型,一般不推荐使用静态方法,因为不能通过类访问
public static demo03 object () {
demo03 d=new demo03();
d.b=3;
return d;
}

//结论7.2 非静态方法,可以声明object类型,一般推荐使用,因为可以使用实例访问
public demo03 object2 () {
demo03 d=new demo03();
d.b=3;
return d;
}

//结论8. 静态方法只能在静态类中使用
public static class superClass {
public static int getAge (int age) {
return age;
}

public static String getName (String name) {
return name;
}
}

public static class childClass extends superClass {

//结论9.1.静态方法不能被非静态方法覆盖
//                        public String getName (String name) {
//                                return name;
//                        }

//结论9.2 静态方法能被静态方法覆盖
public static String getName (String name) {
return name;
}
}
public static void main (String[] args) {
//结论10 静态方法直接通过类访问
System.out.println("x+y: "+demo03.sum2(3,5));

//结论11 如访问控制权限允许，静态变量和静态方法也可以通过对象来访问，但是不被推荐
demo03 de=new demo03();
de.sum2(1,2);
de.a=4;

//结论12 静态方法且类型对象,不能通过类访问
//demo03.object;
}
}

4.静态导入

对于使用频繁的静态变量和静态方法，可以将其静态导入.
实例：

package com.java.JavaStatic;

//1.通过 import static java.lang.System.*; 将其导入，下次直接调用 out.println() 就可以了
import static java.lang.System.*;

//2.导入类中的Math.random
import static java.lang.Math.random;

/**
 * 静态导入. 对于使用频繁的静态变量和静态方法，可以将其静态导入
 * @author Jeff
 * @date:2016/4/4
 * http://www.weixueyuan.net/view/6003.html
 */

public class demo04 {
    public static void main(String[] args) {
        //输出语句 System.out.println(); 中的 out 就是 System 类的静态变量，
        out.println("产生的一个随机数：" + random());
    }
}