Java中static静态类和静态方法隐藏、重写、继承

Java静态类

  在Java世界里，经常被提到静态这个概念，static作为静态成员变量和成员函数的修饰符，意味着它为该类的所有实例所共享，也就是说当某个类的实例修改了该静态成员变量，其修改值为该类的其它所有实例所见。最近一个项目里频繁用到static修饰的内部类，再读了一下《Effective Java》才明白为什么会用static来修饰一个内部类也就是本文的中心——静态类。

  如果一个类要被声明为static的，只有一种情况，就是静态内部类。如果在外部类声明为static，程序会编译都不会过。在一番调查后个人总结出了3点关于内部类和静态内部类（俗称：内嵌类）

1.静态内部类跟静态方法一样，只能访问静态的成员变量和方法，不能访问非静态的方法和属性，但是普通内部类可以访问任意外部类的成员变量和方法

 

2.静态内部类可以声明普通成员变量和方法，而普通内部类不能声明static成员变量和方法。

 

3.静态内部类可以单独初始化: 

Inner i = new Outer.Inner();

 普通内部类初始化：

Outer o = new Outer();
Inner i = o.new Inner();

 

  静态内部类使用场景一般是当外部类需要使用内部类，而内部类无需外部类资源，并且内部类可以单独创建的时候会考虑采用静态内部类的设计，在知道如何初始化静态内部类，在《Effective Java》第二章所描述的静态内部类builder阐述了如何使用静态内部类：

public class Outer {
    private String name;
    private int age;

    public static class Builder {
        private String name;
        private int age;

        public Builder(int age) {
            this.age = age;
        }

        public Builder withName(String name) {
            this.name = name;
            return this;
        }

        public Builder withAge(int age) {
            this.age = age;
            return this;
        }

        public Outer build() {
            return new Outer(this);
        }
    }

    private Outer(Builder b) {
        this.age = b.age;
        this.name = b.name;
    }
}

静态内部类调用外部类的构造函数，来构造外部类，由于静态内部类可以被单独初始化说有在外部就有以下实现：

public Outer getOuter()
{
    Outer outer = new Outer.Builder(2).withName("Yang Liu").build();
    return outer;
}

 

对于静态类总结是：1.如果类的构造器或静态工厂中有多个参数，设计这样类时，最好使用Builder模式，特别是当大多数参数都是可选的时候。

                               2.如果现在不能确定参数的个数，最好一开始就使用构建器即Builder模式。

Java静态方法隐藏、重写、继承

静态方法可以通过二种形式来调用,一种是类名加方法名,另一种是类引用加方法名.

上述程序中通过第二种方式来调用静态方法,其实质是检查引用的类型来调用静态方法(即类名加方法名的方式).

静态成员(方法和属性)属于类而不是属于对象,静态方法,静态属性,动态属性早在编译期就已经确定(弱弱地说,相关地址数据存储在虚拟机的方法区类数据中).

-------------------------------------------------------------------------

1. 静态方法可以被继承.

程序一:

 /**
  * Copyright (c) 2011 Trusted Software and Mobile Computing(TSMC)
  * All rights reserved.
  * Author: Jarg Yee <[email protected]>
  * http://jarg.iteye.com/
  */
 import static java.lang.System.out;

 /**
   * 静态方法可以被继承 测试程序 - 父类
   */
 class SuperClass
 {
     /** static method in the super class. */
     public static void display()
     {
         out.println("in the super class.");
     }
 }


 /*
  * 静态方法可以被继承 测试程序 - 子类
  */
 public class SubClass extends SuperClass
 {
     /** for debugging. */
     public static void main(String[] args)
     {
         SubClass sub = new SubClass();
         sub.display();  // 调用子类继承父类的静态方法
     }
 }

 

---------- 运行Java ----------

in the super class.

输出完成 (耗时 0 秒) - 正常终止

根据输出结果: in the super class.可知:

sub.display(); 调用子类继承了父类的静态方法.

由此可见: 子类可以继承父类的静态方法.

2. 静态方法被隐藏不能被重写.

程序二:

 /**
  * Copyright (c) 2011 Trusted Software and Mobile Computing(TSMC)
  * All rights reserved.
  * Author: Jarg Yee <[email protected]>
  * http://jarg.iteye.com/
  */
 import static java.lang.System.out;

 /**
   * 静态方法被隐藏不能被重写 测试程序 - 父类
   */
 class SuperClass
 {
     /** static method in the super class. */
     public static void display()
     {
         out.println("in the super class.");
     }
 }


 /*
  * 静态方法被隐藏不能被重写 测试程序 - 子类
  */
 public class SubClass extends SuperClass
 {
     /** for debugging. */
     public static void main(String[] args)
     {
         SubClass sub = new SubClass();      // 上转型对象
         sub.display();  // 调用子类自己的静态方法

         SuperClass sup = new SubClass();    // 子类对象
         sup.display();  // 用被隐藏的父类静态方法
     }

     /** static method in the super class. */
     public static void display()
     {
         out.println("in the sub class.");
     }
 }

 

---------- 运行Java ----------

in the sub class.

in the super class.

输出完成 (耗时 0 秒) - 正常终止

对于动态方法,上转型对象调用的将会是子类中重写父类的动态方法.

而对于此处的静态方法,父类子类中都含有静态方法display()的情况,上转型对象却调用的父类的静态方法display(),而非子类中定义的静态方法display().

由此可见: 子类并没有重写父类的静态方法,而是将父类的静态方法隐藏,隐藏的父类方法可以通过父类类名在子类中被调用.

当子类中重写的方法也是静态的时候,其实质是将父类的静态方法隐藏,而并非是将其重写.(摘自: Java SE 6.0编程指南 P142)

隐藏和重写的区别在于:

隐藏是根据引用的类型来进行调用.

重写是根据对象的类型来进行调用.

(摘自: Java SE 6.0编程指南 P143)

3. 动态方法不能覆盖静态方法

上述程序二,如果去掉子类方法display()的static修饰,则会报如下错误:

---------- 编译Java ----------

C:\Documents and Settings\Administrator\桌面\test\SubClass.java:38: SubClass 中的 display() 无法覆盖 SuperClass 中的 display()；被覆盖的方法为 static

public void display()

            ^

1 错误

输出完成 (耗时 1 秒) - 正常终止

说明: 子类中的动态方法display()无法覆盖父类中的静态方法display().

4. 静态方法不能覆盖动态方法

上述程序二,如果去掉父类方法display()的static修饰,则会报如下错误:

---------- 编译Java ----------

C:\Documents and Settings\Administrator\桌面\test\SubClass.java:38: SubClass 中的 display() 无法覆盖 SuperClass 中的 display()；覆盖的方法为静态

public static void display()

                   ^

1 错误

输出完成 (耗时 1 秒) - 正常终止

说明: 子类中的静态方法display()无法覆盖父类中的动态方法display().

疑惑:

动态方法不能覆盖静态方法.

这是否意味着加了static修饰的子类动态方法display()(即静态方法)是在对父类的静态方法display()进行覆盖呢?

Static方法继承后调用问题补充

1、static方法在编译时就和类绑定，static方法的调用由类决定

public class Inheritance {
 public static void main(String[] args) {
  new Base().method();
  new Sub().method();
  ((Base) new Sub()).method();
  ((Sub)(Base) new Sub()).method();
 }
}

class Base {
 static void method() {
  System.out.println("Base's method");
 }
}

class Sub extends Base {
 static void method() {
  System.out.println("Sub's method");
 }
}

输出结果：

Base's method
Sub's method
Base's method
Sub's method

2、子类保存了对父类static方法的引用

OOP的重要思想就是继承。如果父类有这个方法，不管是static或非static类型的，子类都拥有。至于子类能否调用该方法，要看这个方法所处的是private、public、protected。

将以上代码中的

// static void method() {
//  System.out.println("Sub's method");
// }

注释掉

输出结果：

Base's method
Base's method
Base's method
Base's method

3、子类不能重写父类中声明为final的方法，这点与方法static静态与否无关

静态方法也存在重写的问题。方法的signature（确定方法的唯一性）为rerurn method( type argument)。static的作用是在编译时就将方法与类绑定，与继承无关。

将1中的代码的Base类中static void method() 改为static final void method() ，编译时报错。即使同时将Sub中的 static void method() 改为 void method()也同样编译出错 。

4、static方法和非static方法在调用时有差异

向上转型后调用的静态和被重写的非静态方法时结果出现差异，表明：

   1. 静态方法在类向上转型后，实际调用的是父类的同名静态方法，因为调用的类实际是父类，同理如果向下转型后调用的类就是子类的同名静态方法（向下转型时，涉及到父类是否可以转为子类的问题，已经转换后调用方法是否成功）；

   2.而非静态方法在类向上转型后，实际调用的还是子类的同名非静态方法，向下转也是调用的子类的同名非静态方法。

public class Inheritance {
 public static void main(String[] args) {
  ((Base) new Sub()).method();//调用Base的静态方法
  ((Sub) (Base) new Sub()).method();   // 此处实例中定义的Base类实际引用的是一个new Sub（）的子类，因此可以转Sub子类
  ((Base) new Sub()).method2();//调用Sub的非静态方法
  ((Sub) (Base) new Sub()).method2();  // 此处实例中定义的Base类实际引用的是一个new Sub（）的子类，因此可以转为Sub子类
 }
}

class Base {
 static void method() {
  System.out.println("Base's method");
 }

 void method2() {
  System.out.println("Base's method2");
 }
}

class Sub extends Base {
 static void method() {
  System.out.println("Sub's method");
 }

 void method2() {
  System.out.println("Sub's method2");
 }
}

输出结果：

Base's method
Sub's method
Sub's method2
Sub's method2

 

个人结论：继承就意味着子类拥有父类所有属性和方法(构造方法除外)。static方法同样能被继承，只是在某些情况下(比如类向上转型时)调用时与非static方法出现差异。