В чем разница между статическим и окончательным?

При использовании зарезервированного слова 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 их несколько, например:

• java.lang.String
• java.lang.Math

Таким образом, члены 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

Модификаторы staticи finalимеют совершенно разные контексты.

статический

Модификатор staticподразумевает, что что-то определено в общем контексте, а не в контексте объекта. Без этого модификатора переменные, классы или поля всегда существуют в контексте экземпляра определенного объекта.

• Определенные поля staticявляются глобальными переменными.
• Определенные методы staticявляются глобальными функциями.
• Объявленные внутренние классы staticработают как обычные классы, их можно вызывать извне содержащего класса и (очевидно) у них нет такого же доступа к переменным и методам вызываемых объектов содержащего класса.

окончательный

Final вообще означает неизменяемый. Есть два основных варианта использования:

• Переменные, объявленные как final , не могут быть перезаписаны. Это не означает, что объект, присвоенный переменной final, не может быть изменен в его полях или с помощью его методов, это просто означает, что ссылка из этой переменной на этот же объект никогда не изменится.

• Классы, объявленные как final , не могут использоваться в качестве суперклассов. Stringнапример, это класс, определенный как final, поэтому объявить его невозможно MegaString extends String— Java не позволяет этого. Точно так же методы, объявленные как final, не могут быть переопределены с помощью @Override.

Обычное использование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);
  

Ключевое слово static можно использовать в 4 сценариях:

• Статические переменные
• Статические методы
• Статические блоки кода.
• Статический вложенный класс

Давайте сначала посмотрим на статические переменные и статические методы.

Статическая переменная

• Это переменная, принадлежащая классу, а не объекту (экземпляру).
• Статические переменные инициализируются только один раз, в начале выполнения. Эти переменные будут инициализированы первыми, перед инициализацией любых переменных экземпляра.
• Единая копия, используемая всеми экземплярами класса
• Доступ к статической переменной можно получить непосредственно по имени класса и не требует никакого объекта.
• Синтаксис: Class.variable

статический метод

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.

• Статические вложенные классы могут иметь методы экземпляра и статические методы.

В Java нет такого понятия, как статический класс верхнего уровня.

Ключевое слово final используется в нескольких различных контекстах для определения объекта, который нельзя изменить позже.

• Конечный класс не может быть подклассом. Это сделано из соображений безопасности и эффективности. Следовательно, многие классы стандартной библиотеки Java final, например, java.lang.Systemи java.lang.String. Все методы класса finalнеявно final.

• Метод, объявленный как finalне может быть переопределен подклассами. Это используется для предотвращения неожиданного поведения подкласса, который изменяет метод, который может иметь решающее значение для функции или согласованности класса.

• 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

Иногда они усложняют определение определенных ключевых слов, я постараюсь быть максимально простым.

статический:

сделать свойство или метод класса, соответствовать классу, это означает, что если у вас есть класс Dog и у вас есть свойство, color = "negro"все объекты собаки, которые вы создаете с этим классом, будут из color = negro, если через мгновение вы измените значение на color = "azul", теперь все объекты собаки, которые вы создали с черным цветом, будут синими, потому что это зависит от класса.

Perro.color = "negro";// изменен общедоступный статический атрибут String класса Dog

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"

Изменение связано с тем, что это атрибут класса (вида), а не объекта, если вы изменяете атрибут класса, все объекты этого класса «затрагиваются»

В методах: это позволяет вам вызывать метод напрямую без необходимости создания объекта.В том же случае с собакой, если у нее есть метод 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проще, они только делают атрибут или то, что определено этим словом, не может быть изменено Это его конечное значение, оно в основном используется, когда вы хотите объявить КОНСТАНТЫ, значения, которые никогда не изменятся.

Примечание: переменные staticмногое упрощают, потому что при создании элементов с этим значением они могут быть легко доступны только из класса. атрибут "final" позволяет только убедиться, что элемент неизменяем, его нельзя изменить. Атрибуты "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"

Константы объявляются так:

public static final String CONSTANTE = "VALOR";

static -> указывает, что он доступен на уровне класса и не требует использования его экземпляра.

final -> указывает, что однажды объявленное значение не может быть изменено.

пример

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

    public class Clase2 {

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

}

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.