在java中是否有类似 "静态类 "的东西?
这种类的意义是什么。静态类的所有方法也需要是 "静态 "的吗?
是否需要反过来,如果一个类包含所有的静态方法,这个类也应该是静态的?
静态类有什么用?
Java有静态*嵌套的类,但听起来你好像在找一个顶层静态类。 Java没有办法让一个顶层类成为静态的,但你可以像这样模拟一个静态类。
final
- Prevents extension of the class since extension a static class makes no sense.按照上面的建议,举个简单的例子。
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;
}
}
静态类有什么用?静态类的一个好用处是定义一次性的、实用的和/或库类,在这些类中,实例化是没有意义的。
一个很好的例子是Math类,它包含一些数学常量,如PI和E,并简单地提供数学计算。
在这种情况下,要求实例化是不必要的,也是混乱的。
请看[Math
][1]类和[源代码][2]。
注意它是final
,它的所有成员都是static
。
如果Java允许顶层类被声明为static
,那么Math类确实是静态的。
[1]: https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Math.html [2]: http://hg.openjdk.java.net/jdk/jdk11/file/1ddf9a99e4ad/src/java.base/share/classes/java/lang/Math.java
有一个静态的嵌套类,这个[静态嵌套]类不需要包围类的实例,以便自己被实例化。
这些[静态嵌套的]类只能访问包围类的静态成员[因为它没有对包围类实例的任何引用......] 。
代码示例。
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();
}
}
是的,在java中是有静态嵌套类的,当你声明一个嵌套类是静态的时候,它就会自动成为一个独立的类,可以不用实例化它所属的外类。 当你声明一个嵌套类是静态的,它就会自动成为一个独立的类,可以不需要实例化它所属的外层类。
例子:
public class A
{
public static class B
{
}
}
因为class B
被声明为静态,所以你可以显式实例化为。
B b = new B();
请注意,如果class B
没有声明静态化以使其独立,那么实例对象的调用会是这样的。
A a= new A();
B b = a.new B();
当一个 "类 "中的成员被声明为 "静态 "时,会发生什么?
不需要实例化class
就可以访问成员。
因此,将外层类(顶层类)声明为static`是没有意义的。
因此它是不允许的。
但是你可以将内部类设置为static(因为它是顶层类的成员)。 那么该类可以在不实例化顶层类的情况下被访问。 请看下面的例子。
public class A {
public static class B {
}
}
现在,在另一个不同的类C
中,可以访问类B
,而不需要建立类A
的实例。
public class C {
A.B ab = new A.B();
}
静态
类也可以有非静态
成员。
只有类才是静态的。
但是如果从类B
中去掉static
关键字,不建立A
的实例就不能直接访问它。
public class C {
A a = new A();
A.B ab = a. new B();
}
但我们不能在一个 "非静态 "的内类中拥有 "静态 "成员。
**在Java中,一个类可以是静态的吗?
答案是YES,我们可以在java中拥有静态类。 在java中,我们有静态实例变量以及静态方法和静态块。 在java中,类也可以做成静态的。
在java中,我们不能让Top-level(外层)类静态化。 只有嵌套类可以是静态的。
静态嵌套类与非静态嵌套类的对比
2)内类(或非静态嵌套类)可以同时访问静态的 和外类的非静态成员。 一个静态类不能访问外类的非静态成员。 它只能访问静态的 外班的成员。
请看这里。 https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html
看到这是在谷歌上搜索"静态类java".的顶级结果,而最好的答案并不在这里,我想我应该添加。 而最好的答案并不在这里,我想我应该把它加上去。 我把OP的问题理解为关于C#中的静态类,在Java世界中被称为单子。 对于那些不知道的人来说,在 C# 中,"static" 关键字可以应用到一个类声明中,这意味着所产生的类永远不会被实例化。
摘自"Effective Java - Second Edition" Joshua Bloch所著(被广泛认为是最好的Java风格指南之一)。
>.Effective Java - Second Edition" by Joshua Bloch (被广泛认为是目前最好的Java风格指南之一):>.Effective Java - Second Edition" by Joshua Bloch (被广泛认为是目前最好的Java风格指南之一):> 从1.5版开始,有第三种方法来实现单子。 简单地用一个元素做一个枚举类型。
。
// 枚举单子--首选方法
公元猫王 {
瞬间。
public void leaveTheBuilding() { ... } }
&gt.这种方法在功能上等同于公共领域的方法,只是它更简洁,免费提供了序列化机制,并提供了防止多重实例化的铁证。 这种方法在功能上等同于公共字段方法,只是它更简洁,免费提供了序列化机制,并提供了防止多重实例化的铁定保证,即使面对复杂的序列化或反射攻击。 虽然这种方法还没有被广泛采用,但单元素枚举类型是实现单人的最佳方式(强调作者's)。
Bloch, Joshua (2008-05-08). Effective Java (Java Series) (p. 18). 18). Pearson Education.。
我认为实现和理由是很自明的。
简单来说,Java只支持声明一个类的内部类是静态的,而不支持声明顶层类。
顶层类:一个java项目的每个java源文件中可以包含多个顶层类,其中一个类以文件名命名。 顶层类前面只允许有三个选项或关键字,public、abstract和final。
内类:顶层类里面的类叫做内类,基本上就是嵌套类的概念。 内层类可以是静态。 把内类做成静态的想法,是为了利用实例化内类的对象而不需要实例化顶层类的对象的优势。 这与顶层类内部的静态方法和变量的工作方式完全一样。
因此,Java支持内层类的静态类(嵌套类中)。
而Java不支持顶层类的静态类.。
希望能给大家一个比较简单的解决方法,让大家对Java中的静态类有一个基本的了解。
使用静态类对于分组的目的来说简直是太好了。 因为Java允许我们将彼此有用的类进行分组,我们将它们分组只是为了让它们在一个关键词static下保持一致。
Java支持嵌套类,它们也可以是静态的。 这些静态类也被称为静态嵌套类。 Java静态嵌套类只能访问外类的静态成员。 静态嵌套类的行为类似于顶层类,嵌套只是为了包装方便。
让我们以java静态类为例,看看如何在java程序中使用它。
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;
}
}
}
现在让我们看看如何实例化和使用静态嵌套类。
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"
}
}
更多详情请看这里。
理解Java中的静态类|Java嵌套类][1] 。
[Java中的静态类][2]
[Java静态类。 在你的Java编程旅程中更进一步][3]
[Java嵌套和内类][4]
[1]: http://dumbitdude.com/static-class-in-java/ [2]: https://www.geeksforgeeks.org/static-class-in-java/ [3]: https://blog.udemy.com/java-static-class/ [4]: https://www.programiz.com/java-programming/nested-inner-class
静态方法意味着不需要创建一个类的对象就可以访问它,这与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
}
}
除非是内类,否则不能对一个类使用静态关键字。 静态内类是一个嵌套类,它是外类的静态成员。 它可以在不实例化外类的情况下,使用其他静态成员来访问。 就像静态成员一样,静态嵌套类不能访问外类的实例变量和方法。
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();
}
}
所有的答案都很好,但我没有看到java.util.Collections的参考资料,它的静态因子方法使用了大量的静态内类。 所以增加了同样的内容。
增加一个java.util.Collections的例子,它有多个静态内部类。 内层类对于将需要通过外层类访问的代码进行分组非常有用。
/**
* @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();}
}
下面是java.util.Collections类中的静态因子方法。
public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
return new UnmodifiableSet<>(s);
}