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

最新推荐文章于 2022-08-25 18:00:17 发布

luckykapok918

最新推荐文章于 2022-08-25 18:00:17 发布

阅读量3.1k

点赞数 1

分类专栏： java基本概念详解

本文链接：https://blog.csdn.net/luckykapok918/article/details/50556047

版权

java基本概念详解专栏收录该内容

20 篇文章 0 订阅

订阅专栏

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. 静态方法可以被继承.

程序一:

 
     Java代码   
    
 /** 
  * Copyright (c) 2011 Trusted Software and Mobile Computing(TSMC) 
  * All rights reserved. 
  * Author: Jarg Yee <yeshaoting@gmail.com> 
  * 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. 静态方法被隐藏不能被重写.

程序二:

 
     Java代码   
    
 /** 
  * Copyright (c) 2011 Trusted Software and Mobile Computing(TSMC) 
  * All rights reserved. 
  * Author: Jarg Yee <yeshaoting@gmail.com> 
  * 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方法出现差异。

luckykapok918

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java中static静态类和静态方法隐藏、重写、继承

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

扫一扫