Home / Questions / 49967
Accepted
Anónimo
Asked: 2020-02-17 13:17:10 +0800 CST 2020-02-17 13:17:10 +0800 CST

静态和最终有什么区别？

  • 772

我已经搜索了互联网，但对我来说这些保留字的含义以及它们在类中的功能并不是很清楚：

  • 静止的
  • 最后
java

6 Answers

  1. Best Answer

    使用保留字static时，必须在类头中声明常量。

    如果我们试图将它合并到一个方法中，我们会得到一个错误。

    此示例无法编译：

    import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        static final double PI = 3.1416;
    }
}

    但这一个是的：

    class Ideone
{
    static final double PI = 3.1416;

    public static void main (String[] args) throws java.lang.Exception
    {
        System.out.println(Ideone.PI);
    }
}

    这就是为什么在方法main中，因为这是一个类方法并且它包含static在它的声明中，我们不能声明类常量。

    但是final，是的，它既可以在方法内部使用，也可以在方法内部使用main。

    示例： final double PI = 3.1416;它在方法内有效。

    它还可final double PI = 3.1416;用于访问您知道一旦用值声明/初始化后理论上无法修改的数据。

    class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        final double PI = 3.1416;
    }
}

    可以调用静态成员而无需创建它的实例，例如当您使用new MiClase...时miClase.a。现在您可以制作 MyClass.a 而无需使用或创建它的实例。

    class MiClass{

  static int a; // Puedes acceder sin crear una instancia por ejemplo MiClass.a 
  final double PI = 3.1416

}

    通过创建一个static可以调用它的类，也就是说，您可以使用它的方法，而不必创建它的实例，例如当您使用new MiClase...时miClase.miMetodo();。现在您MiClaseEstatica.miMetodo();无需使用或创建它的实例即可。

    Java 无法创建静态顶级类，您可以执行以下操作：

    public final class MiClaseEstatica {
    static public int sumar (int a, int b){
        return a + b;
    }
}
//...
System.out.println(MiClaseEstatica.sumar(3, 2));

    这里我们使用静态调用而不需要创建实例来访问，例如，类的方法。

    它将保存如下内容：

    public MiClase miClase = new MiClase();
System.out.println(MiClase.sumar(3, 2));

    您可能有兴趣阅读此问题/答案

    内部类可以声明为静态的。

    将为这些内部类中的每一个创建一个.class 。

    public class Obj {

    private int data1;
    private String data2;

    public Obj(int data1, String data2) {
        this.data1 = data1;
        this.data2 = data2;
    }

    private static class ObjComp implements Comparator<Obj> {

        @Override
        public int compare(Obj obj1, Obj obj2) {
            return obj2.data1 - obj1.data1;
        }

    }
}

    您还可以将代码块创建为静态代码块，以便在加载类时执行它们。

    如果没有明确声明它们通常被称为（静态初始化块）JIT（即时）编译器将所有静态字段组合在一个块中并在类加载期间执行它们。

    public class Obj {

    private static int data1;

    static {
        data1 = 10;
    }

    初始化块可以用静态方法替换，如下例所示：

    public class Obj {

    private static int data1 = inicializacionDeCampo();

    private static int inicializacionDeCampo() {
        return 10;
    }
}

    您可以将此初始化逻辑应用于类变量static，而无需将其包含在您的类构造函数中。

    static 允许访问方法和类变量，而无需实例化相关类的对象，它通常用于例如创建实用程序类。Java 有几个，例如：

    所以成员static属于类而不是特定实例，这是更快理解以下内容的关键：

    即使创建了数千个该类的实例，也只会存在一个字段static，即使“不存在”它的实例也会发现更多。

    因此该字段将由所有实例共享。

    如果稍微分析一下，这对于上述内容以及应用于静态方法时都非常有意义。当说它们不能引用实例的成员时，因为如果是这样，当它们都共享相同的静态字段或方法时，它指的是哪个实例。

    这与通过特定实例访问不同。

    例子：

    public class Obj {

    private static boolean data3;
    private boolean data4Instancia;

    public static void main(String[] args) {


        data3 = true; //un método estático accediendo al campo estático

        Obj instancia = new Obj();

        instancia.data4Instancia = true; //un método estático acceda a un campo no estático de una instancia especifica, aquí le decimos de alguna manera oye esta es la instancia a la que quiero acceder.

    }

    所有这些都是有道理的，因为非静态的值、字段、方法取决于类实例的创建。

    当说只有一个静态字段时，它是对的，但根据解释它的级别，它可能更有效或更无效，例如它可以是Class Loader每个或线程一个(thread)，在其他情况下，我只提到它，以便可以以某种方式找到它，以防你想更深入地了解它。

    https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html

    • 30

  2. static和修饰符final有完全不同的上下文。

    静止的

    修饰语static暗示某些东西是在一般上下文中定义的，而不是在对象上下文中。如果没有这个修饰符，变量、类或字段总是存在于特定对象实例的上下文中。

    • 定义的字段static是全局变量。
    • 定义的方法static是全局函数。
    • 声明的内部类static像普通类一样工作，它们可以从包含类的外部调用，并且（显然）它们对包含类的被调用对象的变量和方法没有相同的访问权限。

    最后

    Final 通常意味着不可变。主要有两个用途：

    • 声明为final的变量不能被覆盖。这并不意味着分配给最终变量的对象不能在其字段或方法中修改，它只是意味着从该变量到同一对象的引用永远不会改变。

    • 例如，它是一个定义为 final 的类，因此不可能声明一个- Java 不允许这样做。同样，声明为 final 的方法不能被 @Override 覆盖。 StringMegaString extends String

    的常见用途static

    • 常量（与 结合final）：

      public static final int RESULT_CANCELED=0;

    • 单例（只应在一个实例中使用的对象）：

      public static final SecureRandom sr = SecureRandom();

    • 全局变量：

      private static int numLusers=0;

    • 全局方法：

      public static Luser newInstance(){ numLusers++; return new Luser(); }

    • 公共内部类

      public class Almacenamiento{

   public static class AlmacenamientoCreateHelper{
      ...
 }
 ...
}

    但是如果声明的内部类static不能直接访问外部类的方法和字段，那么声明这样的内部类有什么好处呢？

    这是一个组织问题，对此可能有多种观点。我个人更喜欢按包对类进行分组来组织它们，但是有一个明显的优势：如果我保留高度依赖于其代码的类，将它们保存在同一个文件中有助于通过组合来自不同版本的类来避免错误，如果我使用.java包含外部和内部类的那个，我总是可以确定我有兼容的版本。

    的常见用途final

    • 常量（与 结合static）

      public static final String AUTHORITY="com.snolde.app";

    • 并发上下文中使用的“值对象”字段。

      public class LuserVO{
    public final String uname;
    public final int uid;
    public final Token authToken;
    public LuserVO(String uname, int uid, Token auth);
}

    • 用于匿名类的局部变量：

      final Socket sock = server.accept();
Task t = new Task(new Runnable(){
    @Override
    public void run(){
        InputStream is = sock.getInputstream();
        ...
    }
});

    • 不应扩展的最终类：

       public final class AuthToken{
     ...
     public boolean hasPrivilege(int pId);
 }


 // No es posible de crear una clase como esa para pasarlo a un método que acepta AuthToken:
 WeonAuthToken extends AuthToken{
     @Override
     public boolean hasPrivilege(int pId){ return true; }
 }

    • 不应被覆盖的方法：

       protected final void onAgregado(Contexto contexto, Node padre){
     // aqui tengo código que esta llamado por otra clase de mi biblioteca
     // que es importante para el funcionamiento, y quiero evitar
     // cambios en el flujo. Después ofrezco un gancho para código
     // extendido.
 }

 protected abstract void onDespuesAgregado(Contexto contexto, Node padre);
    • 21

  3. static 关键字可用于 4 种场景：

    • 静态变量
    • 静态方法
    • 静态代码块。
    • 静态嵌套类

    我们先来看看静态变量和静态方法。

    静态变量

    • 它是属于类而不属于对象（实例）的变量。
    • Las variables estáticas se inicializan sólo una vez, al inicio de la ejecución. Estas variables se inicializarán primero, antes de la inicialización de cualquier variable de instancia
    • Una sola copia para ser compartida por todas las instancias de la clase
    • Una variable estática se puede acceder directamente por el nombre de la clase y no necesita ningún objeto
    • Sintaxis: Class.variable

    Método estático

    Es un método que pertenece a la clase y no al objeto (instancia) Un método estático sólo puede acceder a los datos estáticos. No puede acceder a datos no estáticos (variables de instancia) a menos que tenga / cree una instancia de la clase. Un método estático puede llamar a otros métodos estáticos y no puede llamar a un método no estático de él a menos que tenga / crea una instancia de la clase. Un método estático puede ser accedido directamente por el nombre de la clase y no necesita ningún objeto Sintaxis: Class.methodName () Un método estático no puede referirse a este o super palabras clave en cualquier caso

    Clase estática

    • Java también tiene "clases anidadas estáticas", Una clase anidada estática es una que no implica implícitamente una referencia a una instancia de la clase externa.

    • Las clases anidadas estáticas pueden tener métodos de instancia y métodos estáticos.

    No hay tal cosa como una clase estática de nivel superior en Java.

    La palabra clave final se utiliza en varios contextos diferentes para definir una entidad que no se puede cambiar posteriormente.

    • Una clase final no puede ser subclasificada. Esto se hace por razones de seguridad y eficiencia. Por consiguiente, muchas de las clases de biblioteca estándar de Java son final, por ejemplo java.lang.System y java.lang.String. Todos los métodos de una clase final son implícitamente final.

    • Un método declarado como final no puede ser sobreescrito por subclases. Esto se utiliza para evitar un comportamiento inesperado de una subclase que altera un método que puede ser crucial para la función o la consistencia de la clase.

    • Una variable final sólo se puede inicializar una vez, ya sea a través de un inicializador o una declaración de asignación. No necesita ser inicializado en el punto de la declaración: esto se llama una variable final en blanco (blank final). Una variable de instancia final en blanco de una clase debe asignarse definitivamente al final de cada constructor de la clase en la que se declara; De manera similar, una variable estática final en blanco debe asignarse definitivamente en un inicializador estático de la clase en la que se declara; De lo contrario, se producirá un error de tiempo de compilación en ambos casos.

    Existe una respuesta en SO realizada por @Ashish

    • 10

  4. 有时他们使某些关键字的定义变得复杂，我会尽量简单。

    静止的 ：

    为该类创建一个属性或方法，使其适合该类，这意味着，如果您有 Dog 类，并且您有一个属性，那么color = "negro"您使用该类创建的所有狗对象都将来自color = negro将值更改为color = "azul"，现在您使用黑色创建的所有狗对象都将变为蓝色，因为它是特定于类的。

    Perro.color = "negro";//修改了Dog类的public static String属性

    Perro perro1 = new Perro();
Perro perro2= new Perro();
// se crearon 2 perro con atributo color = "negro"
System.out.println(perro1.color); //imprime "negro"
System.out.println(perro2.color); //imprime "negro"

Perro.color = "azul"; // se modifica el atributo static
System.out.println(perro1.color); //imprime "azul"

System.out.println(perro2.color); //imprime "azul"

    更改是由于它是类（物种）的属性而不是对象的属性，如果更改类的属性，则该类的所有对象都“受影响”

    在methods中：它允许你直接调用方法而不需要创建一个对象。同样的狗，如果它有一个方法correr()并且它不是静态的，你只能这样调用它

    Perro perro = new Perro();
perro.correr();// <- lo llamas desde el objeto perro creado.

    如果是static，则不需要创建对象，只需从类中调用

    Perro.correr() //<-- se llama desde la propia clase porque es static, propia de la clase

    最后

    变量类型Final比较简单，它们只是使属性或者用这个词定义的东西不能被修改。它是它的最终值，它多用于你要声明CONSTANTS，永远不会改变的值。

    注意：变量static使很多事情变得更容易，因为当您使用该值创建元素时，它们只能从类中轻松访问。“final”属性只允许您确保元素是不可变的，它不能被修改。“静态最终”属性允许两者，只能从您的类从任何地方访问，并且是不可变的。

    public static final double VALOR_PI = 3.1415926; 

// por convención las contantes deben ir todas en mayusculas, esto quiere decir, todas los atributos del tipo "final"
    • 4

  5. 常量声明如下：

    public static final String CONSTANTE = "VALOR";

    static -> 表示它可以在 Class 级别访问，并且不需要使用它的实例。

    final -> 表示一旦声明的值不能更改。

    例子

    public class Clase1
{
   public static final String CONSTANTE = "VALOR";
}

    public class Clase2 {

public static void main (String[]agr)
{
    System.out.println(Clase1.CONSTANTE);
}

}
    • 3

  6. Los static no se necesita instanciar la clase... osea = new Clase() para llamarlos, es simplemente llamar el método por ejemplo: clase.metodoStatic(); ,sin requerir la instancia Clase clase = new Clase(), dentro de estos solo puedes usar mas métodos estáticos, ninguno de instancia.

    La clase Final significa que no pueden tener herencia.

    Y esa es toda la diferencia, lo demás es pura paja... información de mas.

    Espero pode ayudarte, saludos.

    • 3