Java继承和多态-Static关键字

Posted 2020-07-03 每天进步一点点

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. 关于静态变量和静态方法的总结：

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