关于静态的那些事

1. 静态属性又称为类属性，由类直接进行管理。
2. 由static这个关键字来修饰
3. 类变量可以被继承，但是不能被重写。（重写只针对于方法，不管是静态变量还是成员变量都不是被重写）
4. 扩展：
   隐藏（在一个类中，子类中的成员变量如果和父类中的成员变量同名，那么即使他们类型不一样，只要名字一样。父类中的成员变量都会被隐藏。在子类中，父类的成员变量不能被简单的用引用来访问。而是，必须从父类的引用获得父类被隐藏的成员变量。）

public class Animal {
    public static String name = "james";
    public static int num;
    public int sum;
}
-------------------------------------------------------
class Rabbit extends Animal{
    public int sum = 10;
    public static int num = 10;
    public static void main(String[] args) {
        Rabbit rabbit = new Rabbit();
        System.out.println(rabbit.name);//james   （继承过来的）
        System.out.println(rabbit.num);//10
        System.out.println(rabbit.sum);//10
        
        Animal animal = new Rabbit();             （多态）
        System.out.println(animal.name);//james   （继承过来的）
        System.out.println(animal.num);//0         （隐藏）
        System.out.println(animal.sum);//0         （隐藏）
    }
}

1. 静态方法又称为类方法，由类直接进行管理。
2. 由static这个关键字来修饰
3. 类方法可以被继承，但是不能被重写。

public class Animal {
    public static void run(){
        System.out.println("我是一只静态动物，我会跑跑跑！");
    }
    public void jump(){
        System.out.println("我是一只静态动物，我会跳跳跳！");
    }
    public static void eat(){
        System.out.println("我是一只静态动物，我会吃吃吃！");
    }
    public void sing(){
        System.out.println("我会叫！");
    }
}
------------------------------------------------------------
public class Rabbit extends Animal{
    public static void run(){
        System.out.println("我是一只静态兔子，我会跑跑跑！");
    }
    @Override
    public void jump() {
        System.out.println("我是一只兔子，我会跳跳跳！");
    }
    public void fly(){
        System.out.println("我不会飞！");
    }
    public static void main(String[] args) {
        Rabbit rabbit = new Rabbit();
        rabbit.run();//我是一只静态兔子，我会跑跑跑！
        rabbit.jump();//我是一只兔子，我会跳跳跳！
        rabbit.eat();//我是一只静态动物，我会吃吃吃！     （静态方法继承过来的）
        rabbit.sing();//我会叫！                       (继承)
        
        Animal animal = new Rabbit();                  （多态）向上转换
        animal.run();//我是一只静态动物，我会跑跑跑！      （静态方法无法重写，没有实现多态）
        animal.jump();//我是一只兔子，我会跳跳跳！        （普通方法发生了重写）
        animal.eat();//我是一只静态动物，我会吃吃吃！     （静态方法继承过来的）
        animal.sing();//我会叫！                       （父类的方法，向上类型转换可以调用）
        animal.fly();//  程序报错，需要向下类型转换
    }
}

  不能，分析如下：

• 在JDK1.8以前：
  接口里面只包含常量（public static final来修饰）和抽象方法（public abstract来修饰）
• 在JDK1.8以后：
  接口里面新增了非抽象方法（public default 来修饰）和静态方法（public static 来修饰）

public interface TestInterfaceOne {
    public static int num = 0;
    public abstract void hhh();
    public default void sing(){
        System.out.println("我在唱歌！");
    }
    public static void dance(){
        System.out.println("我在跳舞！");
    }
}
-----------------------------------------------------
class Demo implements TestInterfaceOne{
    @Override
    public void sing() {
        System.out.println("sing");
    }
    @Override
    public void hhh() {
        System.out.println("哈哈哈哈");
    }
    public static void main(String[] args) {
        Demo demo = new Demo();
        System.out.println(demo.num);//  0
        demo.sing();//  sing
        demo.dance();// 程序报错
        
        TestInterfaceOne test = new Demo();
        test.dance();// 程序报错
        test.sing();//  sing
        System.out.println(test.num);//  0
    }
}

• 结论：
  接口的实现类不能继承和重写接口中的静态方法，
  对于接口中的非静态方法是可以被继承和重写的。
  接口中的常量（也就是类变量）是可以被继承的。

静态方法是不能被重写的，在接口中不能被继承（普通类可以）。
静态变量或常量不能被重写，可以被继承。