[英]Static Classes In Java
java中有没有类似static class
东西?
这样的课有什么意义。 静态类的所有方法都需要是static
吗?
是否需要反过来,如果一个类包含所有静态方法,该类是否也应该是静态的?
静态类有什么用?
Java 具有静态嵌套类,但听起来您正在寻找顶级静态类。 Java 无法将顶级类设为静态,但您可以像这样模拟静态类:
final
- 阻止类的扩展,因为扩展静态类没有意义private
- 防止客户端代码实例化,因为实例化静态类没有意义static
- 由于类不能被实例化,所以不能调用实例方法或访问实例字段根据上述建议的简单示例:
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
类和源代码。 请注意,它是final
并且其所有成员都是static
。 如果 Java 允许将顶级类声明为static
那么 Math 类确实是静态的。
好吧,Java 有“静态嵌套类”,但它们与 C# 的静态类完全不同,如果那是你来自的地方。 静态嵌套类只是一个没有隐式引用外部类实例的类。
静态嵌套类可以有实例方法和静态方法。
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
时会发生什么? 无需实例化class
即可访问该成员。 因此,将外部类(顶级类) static
是没有意义的。 因此是不允许的。
但是您可以将内部类设置为静态(因为它是顶级类的成员)。 然后可以在不实例化顶级类的情况下访问该类。 考虑以下示例。
public class A {
public static class B {
}
}
现在,在不同的类C
,可以访问类B
而无需创建类A
的实例。
public class C {
A.B ab = new A.B();
}
static
类也可以有non-static
成员。 只有类变得静态。
但是如果从类B
删除static
关键字,则不能在不创建A
实例的情况下直接访问它。
public class C {
A a = new A();
A.B ab = a. new B();
}
但是我们不能在non-static
内部类中有static
成员。
Java 中的类可以是静态的吗?
答案是肯定的,我们可以在java中有静态类。 在java中,我们有静态实例变量以及静态方法和静态块。 在 Java 中,类也可以是静态的。
在java中,我们不能使顶级(外部)类静态化。 只有嵌套类可以是静态的。
静态嵌套类与非静态嵌套类
1) 嵌套静态类不需要外部类的引用,但非静态嵌套类或内部类需要外部类引用。
2)内部类(或非静态嵌套类)可以访问外部类的静态和非静态成员。 静态类不能访问外部类的非静态成员。 它只能访问外部类的静态成员。
请参见此处:https ://docs.oracle.com/javase/tutorial/java/javaOO/nested.html
看到这是 Google 上“静态类 java”的最佳结果,而最佳答案不在这里,我想我会添加它。 我将 OP 的问题解释为关于 C# 中的静态类,它们在 Java 世界中被称为单例。 对于那些不知道的人,在 C# 中,“static”关键字可以应用于类声明,这意味着永远无法实例化生成的类。
摘自 Joshua Bloch 的“Effective Java - Second Edition”(被广泛认为是可用的最佳 Java 风格指南之一):
从 1.5 版开始,还有第三种实现单例的方法。 只需使用一个元素创建一个枚举类型:
// Enum singleton - the preferred approach public enum Elvis { INSTANCE; public void leaveTheBuilding() { ... } }
这种方法在功能上等同于公共字段方法,只是它更简洁,免费提供序列化机制,并提供了针对多个实例化的铁定保证,即使面对复杂的序列化或反射攻击。 虽然这种方法尚未被广泛采用,但单元素枚举类型是实现单例的最佳方式。 (强调作者的)
约书亚布洛赫(2008-05-08)。 Effective Java(Java 系列)(第 18 页)。 培生教育。
我认为实施和理由是不言自明的。
外部类不能是静态的,但嵌套/内部类可以。 这基本上可以帮助您使用嵌套/内部类而无需创建外部类的实例。
简单来说,Java 只支持将类声明为静态的,只针对内部类,而不支持顶级类。
顶级类:一个java项目可以在每个java源文件中包含多个顶级类,其中一个类以文件名命名。 在顶级类之前只允许使用三个选项或关键字,即public、abstract 和 final 。
内部类:位于顶级类内部的类称为内部类,这基本上是嵌套类的概念。 内部类可以是静态的。 使内部类静态化的想法是利用实例化内部类的对象而不实例化顶级类的对象。 这与静态方法和变量在顶级类中的工作方式完全相同。
因此 Java 支持内部类级别的静态类(在嵌套类中)
并且 Java 不支持顶级类中的静态类。
我希望这为基本理解 Java 中的静态类的问题提供了一个更简单的解决方案。
除非是内部类,否则不能在类中使用 static 关键字。 静态内部类是嵌套类,它是外部类的静态成员。 它可以在不实例化外部类的情况下使用其他静态成员进行访问。 就像静态成员一样,静态嵌套类无法访问外部类的实例变量和方法。
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允许我们对彼此有用的类进行分组,所以我们将它们分组只是为了使它们在单个关键字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"
}
}
在这里查看更多详细信息:
静态方法意味着它可以在不创建类的对象的情况下访问,与 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
}
}
java中有没有类似静态类的东西?
单身人士“就像”一个静态类。 我很惊讶还没有人提到它们。
public final class ClassSingleton {
private static ClassSingleton INSTANCE;
private String info = "Initial info class";
private ClassSingleton() {
}
public static ClassSingleton getInstance() {
if(INSTANCE == null) {
INSTANCE = new ClassSingleton();
}
return INSTANCE;
}
// getters and setters
public String getInfo(){
return info;
}
}
用法类似于:
String infoFromSingleton = ClassSingleton.getInstance().getInfo()
单例非常适合存储 ArrayLists/List/Collection Classes/etc... 如果您经常从多个区域收集、更新、复制集合并且需要这些集合同步。 或多对一。
Java 具有与类相关联的静态方法(例如 java.lang.Math 只有静态方法),但类本身不是静态的。
所有好的答案,但我没有看到对 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);
}
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.