继承中的static

首先可以明确的是static，在内存中多个对象共享同一块内存，static变量和方法不存在继承，static没有多态的概念。如下实例：

public class StaticTest {

    public static void main(String[] args) {
        Son.staticMed();
        System.out.println(Son.staticStr);
        System.out.println(Son.STATICFINALSTR);
        new Son().staticMed();
        System.out.println(new Son().staticStr);
        System.out.println(new Son().STATICFINALSTR);

        Par.staticMed();
        System.out.println(Par.staticStr);
        System.out.println(Par.STATICFINALSTR);
        new Par().staticMed();
        System.out.println(new Par().staticStr);
        System.out.println(new Par().STATICFINALSTR);

    }
        /*结果显示：
        sonMed
        sonStr
        sonFinalStr
        sonMed
        sonStr
        sonFinalStr
        parMed
        parStr
        parFinalStr
        parMed
        parStr
        parFinalStr*/
}

class Par{
    public static String staticStr = "parStr";
    public static final String STATICFINALSTR = "parFinalStr";
    public static void staticMed() {
        System.out.println("parMed");
    }

    public void getStaticStr(){
        System.out.println(staticStr);
    }
}

class Son extends Par{
    public static String staticStr = "sonStr";
    public static final String STATICFINALSTR = "sonFinalStr";
    public static void staticMed() {
        System.out.println("sonMed");
    }
}

此时有个疑问就来了，父类中没有static修饰，子类中static会出现什么样的结果呢？看下面这个例子：

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;


public class StaticTest {

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
        Par par1 = new Son();
        Son son1 = new Son();
        System.out.println(par1.staticStr1);
        System.out.println(son1.staticStr1);
        System.out.println(par1.staticStr2);
        System.out.println(son1.staticStr2);


        Field fields[]=son1.getClass().getDeclaredFields();
        for(Field field: fields) {
            System.out.println(Modifier.toString(field.getModifiers())
                    + " " + field.getName() + ":" + field.get(son1).toString());
        }
        Field parFields[]=son1.getClass().getSuperclass().getDeclaredFields();
        for(Field field: parFields) {
            System.out.println(Modifier.toString(field.getModifiers()) 
                    + " " + field.getName() + ":" + field.get(son1).toString());
        }
        /*结果显示：
        parStr1
        sonStr1
        parStr2
        sonStr2
        public static staticStr1:sonStr1
        public staticStr2:sonStr2
        public staticStr1:parStr1
        public static staticStr2:parStr2*/

    }
}

class Par{
    public String staticStr1 = "parStr1";
    public static String staticStr2 = "parStr2";
    public void staticMed1() {
        System.out.println("parMed1");
    }

}

class Son extends Par{
    public static String staticStr1 = "sonStr1";
    public String staticStr2 = "sonStr2";
//  public static void staticMed1() {  //错误显示，这个的原因编程思想中有讲过，晚些过来修正
//      System.out.println("sonMed1");
//  }
}

**结论：**static 不参与继承、多态。
父类中没有static,子类中static，则子类继承了父类中的变量（称呼为继承变量），且自己还有一个static变量（自身变量），Java并没有提供在类外部获取继承变量的方法，但可以在子类内部通过super获得或直接利用反射。

工作中有个业务场景:子类中的static变量需要在父类中做共性操作，可以用如下实现。

public class StaticTest {

    public static void main(String[] args) {
        Par par1 = new Son();
        System.out.println(par1.getStr());
        par1.changeStr("change");
        System.out.println(par1.getStr());
    }
}

class Par{
    private String staticStr1 = "parStr1";
    public Par(){
        String str = getStr();
        //获取str后的操作
        //changeStr("change");
    }

    public void changeStr(String str) {
        setStr(str);
    }
    public String getStr() {
        return staticStr1;
    }

    public void setStr(String str){
        staticStr1 = str;
    }

}

class Son extends Par{
    public static String staticStr1 = "sonStr1";

    public String getStr() {
        return staticStr1;
    }

    public void setStr(String str){
        staticStr1 = str;
    }
}