When using the reserved word static, the declaration of the constant must be made in the class header.
If we try to incorporate it into a method we will get an error.
This example does not compile:
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;
}
}
but this one yes:
class Ideone
{
static final double PI = 3.1416;
public static void main (String[] args) throws java.lang.Exception
{
System.out.println(Ideone.PI);
}
}
That is why within the method main, since this is a class method and it is incorporated staticin its declaration, we cannot declare class constants.
But finalyes, it can be used inside methods as well as inside the method main.
Example:final double PI = 3.1416; it is valid within a method.
It can also final double PI = 3.1416;be used to access data that you know cannot be modified in theory once it is declared/initialized with a value.
class Ideone
{
public static void main (String[] args) throws java.lang.Exception
{
final double PI = 3.1416;
}
}
Static members can be called without having to create an instance of it, for example when you use new MiClase... miClase.a. Now you could make MyClass.a without having to use or create an instance of it.
class MiClass{
static int a; // Puedes acceder sin crear una instancia por ejemplo MiClass.a
final double PI = 3.1416
}
By making a class staticit can be called, that is you can use for example its methods without having to create an instance of it, for example when you use new MiClase... miClase.miMetodo();. Now you could do MiClaseEstatica.miMetodo();without having to use or create an instance of it.
Java has no way to make a static top level class you can do something like the following:
public final class MiClaseEstatica {
static public int sumar (int a, int b){
return a + b;
}
}
//...
System.out.println(MiClaseEstatica.sumar(3, 2));
Here we make use of a static call without the need to create an instance to access, for example, a method of the class.
It would save something like:
public MiClase miClase = new MiClase();
System.out.println(MiClase.sumar(3, 2));
a .class will be created for each of these inner classes.
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;
}
}
}
you can also create code blocks as static so that they are executed when the class is loaded.
they are usually known as (static initializer block) if it is not explicitly declared the JIT (just-in-time) compiler combines all the static fields in a block and executes them during class loading.
public class Obj {
private static int data1;
static {
data1 = 10;
}
The initialization blocks can be replaced by static methods as in the following example you can see:
public class Obj {
private static int data1 = inicializacionDeCampo();
private static int inicializacionDeCampo() {
return 10;
}
}
You can apply this initialization logic to class variables staticwithout needing to include it in your class constructor.
static allows access to methods, class variables without the need to instantiate an object of the class in question, it is often used for example for the creation of utility classes. Java has several of these, such as:
So the members staticbelong to the class instead of a specific instance, this is key to understand the following faster:
Only one field will exist staticeven if thousands of instances of the class were created, and even more to have found even if no instance of it "exists".
So that field will be shared by all instances.
This, if analyzed a bit, makes a lot of sense, both for the above and when applied to static methods. When it is said that they cannot refer to members of an instance, because if so, which instance is it referring to when they all share the same static field or method.
Which is not the same as accessing through a specific instance.
Example:
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.
}
All this makes sense because the values, fields, methods NOT static depend on the creation of instances of the class.
When it is said that there will only be one static field, it is half true, but depending on the level at which it is being explained, it can be more valid or less valid, for example it can be one per Class Loaderper or the thread (thread) , among other cases, I only mention it so that it can be found in a certain way, in case you want to go deeper into it.
staticThe and modifiers finalhave completely different contexts.
static
The modifier staticimplies that something is defined in the general context, not in an object context. Without this modifier, variables, classes, or fields always exist in the context of an instance of a particular object.
Defined fields staticare global variables.
Defined methods staticare global functions.
Declared inner classes staticwork like normal classes, they can be called from outside the containing class and (obviously) they don't have the same access to variables and methods of called objects of the containing class.
final
Final in general means immutable. There are two main uses:
Variables declared as final cannot be overwritten. That doesn't mean that an object that was assigned to a final variable can't be modified in its fields or by its methods, it just means that the reference from this variable to this same object will never change.
Classes declared as final cannot be used as superclasses. Stringfor example it is a class defined as final, so it is not possible to declare one MegaString extends String- Java does not allow it. Similarly, methods declared final cannot be overridden by @Override.
Common uses ofstatic
Constants (in combination with final):
public static final int RESULT_CANCELED=0;
Singletons (objects that should only be used in one instance):
public static final SecureRandom sr = SecureRandom();
Global variables:
private static int numLusers=0;
Global methods:
public static Luser newInstance(){
numLusers++;
return new Luser();
}
Public Internal Classes
public class Almacenamiento{
public static class AlmacenamientoCreateHelper{
...
}
...
}
But if a declared inner class staticdoes not have direct access to methods and fields of the outer class, what is the advantage of declaring such an inner class?
It's an organizational issue and there's probably a variety of opinions on that. I personally prefer to group classes by packages to organize them, however there is an obvious advantage: If I keep classes that are highly dependent on their code, keeping them in the same file helps a lot in avoiding errors by combining classes from different versions, if I use the .javaone that contains outer and inner class, I can always be sure that I have the compatible versions.
Common uses offinal
Constants (in combination with static)
public static final String AUTHORITY="com.snolde.app";
"Value Objects" fields used in concurrency contexts.
public class LuserVO{
public final String uname;
public final int uid;
public final Token authToken;
public LuserVO(String uname, int uid, Token auth);
}
Local variables for use in anonymous classes:
final Socket sock = server.accept();
Task t = new Task(new Runnable(){
@Override
public void run(){
InputStream is = sock.getInputstream();
...
}
});
Final classes that should not be extended:
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; }
}
Methods that should not be overridden:
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);
Let's first look at static variables and static methods.
Static Variable
It is a variable that belongs to the class and not to the object (instance).
Static variables are initialized only once, at the start of execution. These variables will be initialized first, before the initialization of any instance variables
A single copy to be shared by all instances of the class
A static variable can be accessed directly by the class name and does not need any object
Syntax: Class.variable
static method
It is a method that belongs to the class and not to the object (instance) A static method can only access static data. You can't access non-static data (instance variables) unless you have/create an instance of the class. A static method can call other static methods, and you can't call a non-static method of it unless you have/create an instance of the class. A static method can be accessed directly by the class name and does not need any object Syntax: Class.methodName() A static method cannot refer to this or super keywords in any case
static class
Java also has "static nested classes", A static nested class is one that does not implicitly imply a reference to an instance of the outer class.
Static nested classes can have instance methods and static methods.
There is no such thing as a top level static class in Java.
The final keyword is used in several different contexts to define an entity that cannot be changed later.
A final class cannot be subclassed. This is done for security and efficiency reasons. Consequently, many of the Java standard library classes are final, for example java.lang.Systemand java.lang.String. All methods of a class finalare implicitly final.
A method declared as finalcannot be overridden by subclasses. This is used to prevent unexpected behavior of a subclass that alters a method that may be crucial to the function or consistency of the class.
A variable finalcan only be initialized once, either through an initializer or an assignment statement. It does not need to be initialized at the point of the declaration: this is called a trailing blank ( blank final) variable. finalA blank instance variable of a class must definitely be assigned to the end of each constructor of the class in which it is declared; Similarly, a final blank static variable must definitely be assigned in a static initializer of the class in which it is declared; Otherwise, a compile-time error will occur in both cases.
Sometimes they make the definition of certain keywords complicated, I will try to be as simple as possible.
static :
make a property or method of the class, be proper to the class, this means, if you have the class Dog, and you have a property, color = "negro"all the dog objects that you create with this class will be from color = negro, if in a moment you change the value to color = "azul", now all the dog objects that you created with black will be blue, because it is class-specific.
Perro.color = "negro";// the public static String attribute of the Dog class is modified
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"
The change is due to the fact that it is an attribute of the class (species) not of the object, if you change an attribute of the class, all the objects of that class are "affected"
In the methods: it allows you to call the method directly without the need for an object created. In the same case of the dog, if it has a method correr()and it is not static, you could only call it like this
Perro perro = new Perro();
perro.correr();// <- lo llamas desde el objeto perro creado.
If it were static, you don't need to have an object created, just call from the class
Perro.correr() //<-- se llama desde la propia clase porque es static, propia de la clase
final
The variable types Finalare simpler, they only make the attribute or what is defined with this word cannot be modified. It is its final value, it is mostly used when you want to declare CONSTANTS, values that will never change.
Note: variables staticmake a lot of things easier, because when you create elements with this value, they can be easily accessible only from the class. the "final" attribute only allows you to make sure that the element is immutable, it cannot be modified. "static final" attributes allow both, are accessible from anywhere only from your Class, and are immutable.
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"
static -> indicates that it is accessible at the Class level and does not need an instance of it to be used.
final -> indicates that the value once declared cannot be changed.
example
public class Clase1
{
public static final String CONSTANTE = "VALOR";
}
public class Clase2 {
public static void main (String[]agr)
{
System.out.println(Clase1.CONSTANTE);
}
}
The static does not need to instantiate the class... that = new Clase()is, to call them, it is simply to call the method for example: clase.metodoStatic();, without requiring the instance Clase clase = new Clase(), within these you can only use more static methods, none of instance.
The Final class means that they cannot have inheritance .
And that's all the difference, the rest is pure straw... more information.
When using the reserved word
static, the declaration of the constant must be made in the class header.If we try to incorporate it into a method we will get an error.
This example does not compile:
but this one yes:
That is why within the method
main, since this is a class method and it is incorporatedstaticin its declaration, we cannot declare class constants.But
finalyes, it can be used inside methods as well as inside the methodmain.Example:
final double PI = 3.1416;it is valid within a method.It can also
final double PI = 3.1416;be used to access data that you know cannot be modified in theory once it is declared/initialized with a value.Static members can be called without having to create an instance of it, for example when you use
new MiClase...miClase.a. Now you could make MyClass.a without having to use or create an instance of it.By making a class
staticit can be called, that is you can use for example its methods without having to create an instance of it, for example when you usenew MiClase...miClase.miMetodo();. Now you could doMiClaseEstatica.miMetodo();without having to use or create an instance of it.Java has no way to make a static top level class you can do something like the following:
Here we make use of a static call without the need to create an instance to access, for example, a method of the class.
It would save something like:
You may be interested in reading this question/answer
Inner classes can be declared static.
a .class will be created for each of these inner classes.
you can also create code blocks as static so that they are executed when the class is loaded.
they are usually known as (static initializer block) if it is not explicitly declared the JIT (just-in-time) compiler combines all the static fields in a block and executes them during class loading.
The initialization blocks can be replaced by static methods as in the following example you can see:
You can apply this initialization logic to class variables
staticwithout needing to include it in your class constructor.static allows access to methods, class variables without the need to instantiate an object of the class in question, it is often used for example for the creation of utility classes. Java has several of these, such as:
So the members
staticbelong to the class instead of a specific instance, this is key to understand the following faster:Only one field will exist
staticeven if thousands of instances of the class were created, and even more to have found even if no instance of it "exists".So that field will be shared by all instances.
This, if analyzed a bit, makes a lot of sense, both for the above and when applied to static methods. When it is said that they cannot refer to members of an instance, because if so, which instance is it referring to when they all share the same static field or method.
Which is not the same as accessing through a specific instance.
Example:
All this makes sense because the values, fields, methods NOT static depend on the creation of instances of the class.
When it is said that there will only be one static field, it is half true, but depending on the level at which it is being explained, it can be more valid or less valid, for example it can be one per
Class Loaderper or the thread (thread) , among other cases, I only mention it so that it can be found in a certain way, in case you want to go deeper into it.https://docs.oracle.com/javase/7/docs/api/java/lang/ClassLoader.html
staticThe and modifiersfinalhave completely different contexts.static
The modifier
staticimplies that something is defined in the general context, not in an object context. Without this modifier, variables, classes, or fields always exist in the context of an instance of a particular object.staticare global variables.staticare global functions.staticwork like normal classes, they can be called from outside the containing class and (obviously) they don't have the same access to variables and methods of called objects of the containing class.final
Final in general means immutable. There are two main uses:
Variables declared as final cannot be overwritten. That doesn't mean that an object that was assigned to a final variable can't be modified in its fields or by its methods, it just means that the reference from this variable to this same object will never change.
Classes declared as final cannot be used as superclasses.
Stringfor example it is a class defined as final, so it is not possible to declare oneMegaString extends String- Java does not allow it. Similarly, methods declared final cannot be overridden by @Override.Common uses of
staticConstants (in combination with
final):public static final int RESULT_CANCELED=0;Singletons (objects that should only be used in one instance):
public static final SecureRandom sr = SecureRandom();Global variables:
private static int numLusers=0;Global methods:
public static Luser newInstance(){ numLusers++; return new Luser(); }Public Internal Classes
But if a declared inner class
staticdoes not have direct access to methods and fields of the outer class, what is the advantage of declaring such an inner class?It's an organizational issue and there's probably a variety of opinions on that. I personally prefer to group classes by packages to organize them, however there is an obvious advantage: If I keep classes that are highly dependent on their code, keeping them in the same file helps a lot in avoiding errors by combining classes from different versions, if I use the
.javaone that contains outer and inner class, I can always be sure that I have the compatible versions.Common uses of
finalConstants (in combination with
static)"Value Objects" fields used in concurrency contexts.
Local variables for use in anonymous classes:
Final classes that should not be extended:
Methods that should not be overridden:
Let's first look at static variables and static methods.
Static Variable
static method
It is a method that belongs to the class and not to the object (instance) A static method can only access static data. You can't access non-static data (instance variables) unless you have/create an instance of the class. A static method can call other static methods, and you can't call a non-static method of it unless you have/create an instance of the class. A static method can be accessed directly by the class name and does not need any object Syntax: Class.methodName() A static method cannot refer to this or super keywords in any case
static class
Java also has "static nested classes", A static nested class is one that does not implicitly imply a reference to an instance of the outer class.
Static nested classes can have instance methods and static methods.
There is no such thing as a top level static class in Java.
A final class cannot be subclassed. This is done for security and efficiency reasons. Consequently, many of the Java standard library classes are
final, for examplejava.lang.Systemandjava.lang.String. All methods of a classfinalare implicitlyfinal.A method declared as
finalcannot be overridden by subclasses. This is used to prevent unexpected behavior of a subclass that alters a method that may be crucial to the function or consistency of the class.A variable
finalcan only be initialized once, either through an initializer or an assignment statement. It does not need to be initialized at the point of the declaration: this is called a trailing blank (blank final) variable.finalA blank instance variable of a class must definitely be assigned to the end of each constructor of the class in which it is declared; Similarly, a final blank static variable must definitely be assigned in a static initializer of the class in which it is declared; Otherwise, a compile-time error will occur in both cases.There is an answer on SO by @Ashish
Sometimes they make the definition of certain keywords complicated, I will try to be as simple as possible.
static :
make a property or method of the class, be proper to the class, this means, if you have the class Dog, and you have a property,
color = "negro"all the dog objects that you create with this class will be fromcolor = negro, if in a moment you change the value tocolor = "azul", now all the dog objects that you created with black will be blue, because it is class-specific.Perro.color = "negro";// the public static String attribute of the Dog class is modifiedThe change is due to the fact that it is an attribute of the class (species) not of the object, if you change an attribute of the class, all the objects of that class are "affected"
In the methods: it allows you to call the method directly without the need for an object created. In the same case of the dog, if it has a method
correr()and it is not static, you could only call it like thisIf it were
static, you don't need to have an object created, just call from the classfinal
The variable types
Finalare simpler, they only make the attribute or what is defined with this word cannot be modified. It is its final value, it is mostly used when you want to declare CONSTANTS, values that will never change.Note: variables
staticmake a lot of things easier, because when you create elements with this value, they can be easily accessible only from the class. the "final" attribute only allows you to make sure that the element is immutable, it cannot be modified. "static final" attributes allow both, are accessible from anywhere only from your Class, and are immutable.Constants are declared like this:
static -> indicates that it is accessible at the Class level and does not need an instance of it to be used.
final -> indicates that the value once declared cannot be changed.
example
The static does not need to instantiate the class... that
= new Clase()is, to call them, it is simply to call the method for example:clase.metodoStatic();, without requiring the instanceClase clase = new Clase(), within these you can only use more static methods, none of instance.The Final class means that they cannot have inheritance .
And that's all the difference, the rest is pure straw... more information.
I hope I can help you, greetings.