问题
Is there anything like static class in java?
What is the meaning of such a class. Do all the methods of the static class need to be static too?
Is it required the other way round, that if a class contains all the static methods, shall the class be static too?
What are static classes good for?
回答1:
Java has static nested classes but it sounds like you're looking for a top-level static class. Java has no way of making a top-level class static but you can simulate a static class like this:
- Declare your class
final- Prevents extension of the class since extending a static class makes no sense - Make the constructor
private- Prevents instantiation by client code as it makes no sense to instantiate a static class - Make all the members and functions of the class
static- Since the class cannot be instantiated no instance methods can be called or instance fields accessed - Note that the compiler will not prevent you from declaring an instance (non-static) member. The issue will only show up if you attempt to call the instance member
Simple example per suggestions from above:
public class TestMyStaticClass {
public static void main(String []args){
MyStaticClass.setMyStaticMember(5);
System.out.println("Static value: " + MyStaticClass.getMyStaticMember());
System.out.println("Value squared: " + MyStaticClass.squareMyStaticMember());
// MyStaticClass x = new MyStaticClass(); // results in compile time error
}
}
// A top-level Java class mimicking static class behavior
public final class MyStaticClass {
private MyStaticClass () { // private constructor
myStaticMember = 1;
}
private static int myStaticMember;
public static void setMyStaticMember(int val) {
myStaticMember = val;
}
public static int getMyStaticMember() {
return myStaticMember;
}
public static int squareMyStaticMember() {
return myStaticMember * myStaticMember;
}
}
What good are static classes? A good use of a static class is in defining one-off, utility and/or library classes where instantiation would not make sense. A great example is the Math class that contains some mathematical constants such as PI and E and simply provides mathematical calculations. Requiring instantiation in such a case would be unnecessary and confusing. See the Math class and source code. Notice that it is final and all of its members are static. If Java allowed top-level classes to be declared static then the Math class would indeed be static.
回答2:
Well, Java has "static nested classes", but they're not at all the same as C#'s static classes, if that's where you were coming from. A static nested class is just one which doesn't implicitly have a reference to an instance of the outer class.
Static nested classes can have instance methods and static methods.
There's no such thing as a top-level static class in Java.
回答3:
There is a static nested class, this [static nested] class does not need an instance of the enclosing class in order to be instantiated itself.
These classes [static nested ones] can access only the static members of the enclosing class [since it does not have any reference to instances of the enclosing class...]
code sample:
public class Test {
class A { }
static class B { }
public static void main(String[] args) {
/*will fail - compilation error, you need an instance of Test to instantiate A*/
A a = new A();
/*will compile successfully, not instance of Test is needed to instantiate B */
B b = new B();
}
}
回答4:
Yes there is a static nested class in java. When you declare a nested class static, it automatically becomes a stand alone class which can be instantiated without having to instantiate the outer class it belongs to.
Example:
public class A
{
public static class B
{
}
}
Because class B is declared static you can explicitly instantiate as:
B b = new B();
Note if class B wasn't declared static to make it stand alone, an instance object call would've looked like this:
A a= new A();
B b = a.new B();
回答5:
What's happening when a members inside a class is declared as static..? That members can be accessed without instantiating the class. Therefore making outer class(top level class) static has no meaning. Therefore it is not allowed.
But you can set inner classes as static (As it is a member of the top level class). Then that class can be accessed without instantiating the top level class. Consider the following example.
public class A {
public static class B {
}
}
Now, inside a different class C, class B can be accessed without making an instance of class A.
public class C {
A.B ab = new A.B();
}
static classes can have non-static members too. Only the class gets static.
But if the static keyword is removed from class B, it cannot be accessed directly without making an instance of A.
public class C {
A a = new A();
A.B ab = a. new B();
}
But we cannot have static members inside a non-static inner class.
回答6:
Seeing as this is the top result on Google for "static class java" and the best answer isn't here I figured I'd add it. I'm interpreting OP's question as concerning static classes in C#, which are known as singletons in the Java world. For those unaware, in C# the "static" keyword can be applied to a class declaration which means the resulting class can never be instantiated.
Excerpt from "Effective Java - Second Edition" by Joshua Bloch (widely considered to be one of the best Java style guides available):
As of release 1.5, there is a third approach to implementing singletons. Simply make an enum type with one element:
// Enum singleton - the preferred approach public enum Elvis { INSTANCE; public void leaveTheBuilding() { ... } }This approach is functionally equivalent to the public field approach, except that it is more concise, provides the serialization machinery for free , and provides an ironclad guarantee against multiple instantiation, even in the face of sophisticated serialization or reflection attacks. While this approach has yet to be widely adopted, a single-element enum type is the best way to implement a singleton. (emphasis author's)
Bloch, Joshua (2008-05-08). Effective Java (Java Series) (p. 18). Pearson Education.
I think the implementation and justification are pretty self explanatory.
回答7:
Can a class be static in Java ?
The answer is YES, we can have static class in java. In java, we have static instance variables as well as static methods and also static block. Classes can also be made static in Java.
In java, we can’t make Top-level (outer) class static. Only nested classes can be static.
static nested class vs non-static nested class
1) Nested static class doesn’t need a reference of Outer class, but Non-static nested class or Inner class requires Outer class reference.
2) Inner class(or non-static nested class) can access both static and non-static members of Outer class. A static class cannot access non-static members of the Outer class. It can access only static members of Outer class.
see here: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html
回答8:
Outer classes cannot be static, but nested/inner classes can be. That basically helps you to use the nested/inner class without creating an instance of the outer class.
回答9:
In simple terms, Java supports the declaration of a class to be static only for the inner classes but not for the top level classes.
top level classes: A java project can contain more than one top level classes in each java source file, one of the classes being named after the file name. There are only three options or keywords allowed in front of the top level classes, public, abstract and final.
Inner classes: classes that are inside of a top level class are called inner classes, which is basically the concept of nested classes. Inner classes can be static. The idea making the inner classes static, is to take the advantage of instantiating the objects of inner classes without instantiating the object of the top level class. This is exactly the same way as the static methods and variables work inside of a top level class.
Hence Java Supports Static Classes at Inner Class Level (in nested classes)
And Java Does Not Support Static Classes at Top Level Classes.
I hope this gives a simpler solution to the question for basic understanding of the static classes in Java.
回答10:
Using static classes is simply great for grouping purposes. Because Java allows us to group classes that are useful to each other, we group them just to keep them together under a single keyword static.
Java supports nested classes and they can be static. These static classes are also called static nested classes. Java static nested class can access only static members of the outer class. Static nested class behaves similar to top-level class and is nested for only packaging convenience.
Let’s look at the example of java static class and see how it can be used in java program.
public class OuterClass {
private static String name = "Mohammad";
// static nested class
static class StaticNestedClass {
private int a;
public int getA() {
return this.a;
}
public String getName() {
return name;
}
}
}
Now let’s see how to instantiate and use static nested class.
public class StaticNestedClassTest {
public static void main(String[] args) {
//creating instance of static nested class
OuterClass.StaticNestedClass nested = new OuterClass.StaticNestedClass();
//accessing outer class static member
System.out.println(nested.getName()); // Printing "Mohammad"
}
}
See more details here :
Understanding Static Class in Java | Java Nested Class
Static class in Java
Java Static Class: A step further in your Java programming journey
Java Nested and Inner Class
回答11:
A static method means that it can be accessed without creating an object of the class, unlike public:
public class MyClass {
// Static method
static void myStaticMethod() {
System.out.println("Static methods can be called without creating objects");
}
// Public method
public void myPublicMethod() {
System.out.println("Public methods must be called by creating objects");
}
// Main method
public static void main(String[ ] args) {
myStaticMethod(); // Call the static method
// myPublicMethod(); This would output an error
MyClass myObj = new MyClass(); // Create an object of MyClass
myObj.myPublicMethod(); // Call the public method
}
}
回答12:
Java has static methods that are associated with classes (e.g. java.lang.Math has only static methods), but the class itself is not static.
回答13:
You cannot use the static keyword with a class unless it is an inner class. A static inner class is a nested class which is a static member of the outer class. It can be accessed without instantiating the outer class, using other static members. Just like static members, a static nested class does not have access to the instance variables and methods of the outer class.
public class Outer {
static class Nested_Demo {
public void my_method() {
System.out.println("This is my nested class");
}
}
public static void main(String args[]) {
Outer.Nested_Demo nested = new Outer.Nested_Demo();
nested.my_method();
}
}
回答14:
All good answers, but I did not saw a reference to java.util.Collections which uses tons of static inner class for their static factor methods. So adding the same.
Adding an example from java.util.Collections which has multiple static inner class. Inner classes are useful to group code which needs to be accessed via outer class.
/**
* @serial include
*/
static class UnmodifiableSet<E> extends UnmodifiableCollection<E>
implements Set<E>, Serializable {
private static final long serialVersionUID = -9215047833775013803L;
UnmodifiableSet(Set<? extends E> s) {super(s);}
public boolean equals(Object o) {return o == this || c.equals(o);}
public int hashCode() {return c.hashCode();}
}
Here is the static factor method in the java.util.Collections class
public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
return new UnmodifiableSet<>(s);
}
来源：https://stackoverflow.com/questions/7486012/static-classes-in-java