用外行术语来说,Java中的“静态”是什么意思?[重复]

2020/11/30 23:11 · java ·  · 0评论

在Wikipedia上,有人告诉我它的几个定义,但是作为Java的初学者,我仍然不确定它的含义。有人精通Java吗?

静态表示标记为此类的变量或方法在类级别可用。换句话说,您无需创建类的实例即可访问它。

public class Foo {
    public static void doStuff(){
        // does stuff
    }
}

因此,与其创建一个Foo实例,然后doStuff像这样调用

Foo f = new Foo();
f.doStuff();

您只需直接针对该类调用该方法,如下所示:

Foo.doStuff();

用外行的话来说,类是模具,而对象是用该模具制成的复制品。静态属于模具,可以直接访问而无需复制,因此上面的示例

在Java中,static关键字可以以几种不同的方式使用,并且在几乎所有情况下,它都是一个修饰符,这意味着它所修饰的对象无需封闭对象实例就可以使用

Java是一种面向对象的语言,默认情况下,您编写的大多数代码都需要使用该对象的实例。

public class SomeObject {
    public int someField;
    public void someMethod() { };
    public Class SomeInnerClass { };
}

为了使用someField,someMethod或SomeInnerClass,我必须首先创建SomeObject的实例

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObject anInstance = new SomeObject();
        anInstance.someField = 7;
        anInstance.someMethod();
        //Non-static inner classes are usually not created outside of the
        //class instance so you don't normally see this syntax
        SomeInnerClass blah = anInstance.new SomeInnerClass();
    }
}

如果我声明这些东西是静态的,则它们不需要封闭的实例

public class SomeObjectWithStaticStuff {
    public static int someField;
    public static void someMethod() { };
    public static Class SomeInnerClass { };
}

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someMethod();
        SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass();
        //Or you can also do this if your imports are correct
        SomeInnerClass blah2 = new SomeInnerClass();
    }
}

声明某些静态内容有几个含义。

首先,整个应用程序中只能有一个静态字段值

public class SomeOtherObject {
    public void doSomeStuff() {
        //Two objects, two different values
        SomeObject instanceOne = new SomeObject();
        SomeObject instanceTwo = new SomeObject();
        instanceOne.someField = 7;
        instanceTwo.someField = 10;
        //Static object, only ever one value
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someField = 10; //Redefines the above set
    }
}

第二个问题是静态方法和内部类无法访问封闭对象中的字段(因为没有一个)。

public class SomeObjectWithStaticStuff {
    private int nonStaticField;
    private void nonStaticMethod() { };

    public static void someStaticMethod() {
        nonStaticField = 7; //Not allowed
        this.nonStaticField = 7; //Not allowed, can never use *this* in static
        nonStaticMethod(); //Not allowed
        super.someSuperMethod(); //Not allowed, can never use *super* in static
    }

    public static class SomeStaticInnerClass {

        public void doStuff() {
            someStaticField = 7; //Not allowed
            nonStaticMethod(); //Not allowed
            someStaticMethod(); //This is ok
        }

    }
}

static关键字也可以应用于内部接口,注释和枚举。

public class SomeObject {
    public static interface SomeInterface { };
    public static @interface SomeAnnotation { };
    public static enum SomeEnum { };
}

在所有这些情况下,关键字都是多余的,并且无效。接口,注释和枚举在默认情况下是静态的,因为它们从不与内部类有关系。

这只是描述了关键字的作用。它没有描述使用关键字是否是一个坏主意。可以在其他问题中对此进行更详细的介绍,例如使用大量静态方法是否不好?

关键字static还有一些较不常用的用法。有静态导入,这些静态导入使您可以使用无限制的静态类型(包括接口,注释和未冗余标记为静态的枚举)。

//SomeStaticThing.java
public class SomeStaticThing {
    public static int StaticCounterOne = 0;
}

//SomeOtherStaticThing.java
public class SomeOtherStaticThing {
    public static int StaticCounterTwo = 0;
}

//SomeOtherClass.java
import static some.package.SomeStaticThing.*;
import some.package.SomeOtherStaticThing.*;

public class SomeOtherClass {
    public void doStuff() {
        StaticCounterOne++; //Ok
        StaticCounterTwo++; //Not ok
        SomeOtherStaticThing.StaticCounterTwo++; //Ok
    }
}

最后,有一些静态初始化程序,它们是在首次加载类时(通常在应用程序中首次实例化类之前)运行的代码块,并且(如静态方法)无法访问非静态字段或方法。

public class SomeObject {

    private static int x;

    static {
        x = 7;
    }
}

当您要应用Singleton设计模式时,使用静态属性和操作的另一个很好的例子简而言之,Singleton设计模式可确保在系统的整个生命周期中都只构造一个特定类的对象。为了确保仅构造一个对象,Singleton模式的典型实现将内部静态引用保留到单个允许的对象实例,并且使用static操作控制对该实例的访问

除了@inkedmn指出的以外,静态成员也处于类级别。因此,JVM对该类一次将所述成员加载到内存中(加载该类时)。也就是说,没有n个静态成员的实例为其所属的n个实例加载

以上几点是正确的,我想添加一些关于Static关键字的更重要的观点。

在内部,当您使用static关键字时,它将存储在永久内存(即堆内存)中,我们知道有两种类型的内存,它们是堆栈内存(临时内存)和堆内存(永久内存),因此如果您不使用静态关键字,那么它将存储在堆栈存储器中的临时存储器中(或者您可以将其称为易失性存储器)。

因此您会怀疑此权利的用途是什么????

例子:static int a = 10;(1个程序)

刚才我告诉您,如果将static关键字用于变量方法,它将被永久存储在内存中

所以我 在其他程序中用不同的值用关键字static声明了相同的变量

例子:static int a = 20;(2程式)

变量“ a”由程序1存储在堆存储器中。那时,程序2发现了相同的静态变量“ a” ,它将不再在堆存储器中再次创建“ a”变量,而不仅仅是替换值从10到20

通常,如果您不会将“ a”声明为静态变量,它将在堆栈存储器(临时存储器)中再次创建变量“ a”。

总的来说,我可以说,如果我们使用static关键字

  1.
我们可以节省内存


  2.我们可以避免重复


  3.无需创建对象即可在类名的帮助下访问static变量。

本文地址:http://java.askforanswer.com/yongwaixingshuyulaishuojavazhongdejingtaishishenmeyisizhongfu.html
文章标签: ,   ,  
版权声明:本文为原创文章,版权归 admin 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!