Principes de base de la méthode statique Java, de la classe, de la variable et du bloc

Publié: 2019-12-13
Principes de base des méthodes et variables statiques Java

Qu'est-ce que le statique en Java ?

  • Le mot-clé statique peut être utilisé avec une classe, une variable, une méthode et un bloc.
  • Les membres statiques n'appartiennent à aucune instance spécifique.
  • Les membres statiques appartiennent à la classe uniquement.
  • Une fois que vous avez rendu un membre statique, vous pouvez y accéder sans aucun objet.

Avez-vous l'une des questions ci-dessous ?

  • Pourriez-vous écrire les meilleures pratiques des méthodes statiques Java ?
  • Qu'est-ce que les méthodes statiques Java dans l'interface ?
  • Vous avez une question sur les méthodes statiques Java vs singleton ?
  • Performances des méthodes statiques Java et des méthodes d'instance
  • Méthodes et variables statiques Java
  • Méthodes statiques Java vs non statiques
  • Méthodes statiques Java dans une classe abstraite

Le mot-clé static peut être utilisé dans 3 cas :

  • Variables statiques
  • Méthodes statiques
  • Blocs de code statiques.

variable statique (Mot-clé "statique" = Variables de classe)

java-static-method-introduction-and-complete-tutorial

En Java, les variables peuvent être déclarées avec le mot-clé « static ».

Exemple : static int y = 0;

Lorsqu'une variable est déclarée avec le mot-clé static , on l'appelle une class variable . Toutes les instances partagent la même copie de la variable. Une variable de classe est accessible directement avec la classe, sans qu'il soit nécessaire de créer une instance.

Pas de mot-clé "statique" = variables d'instance

Sans le mot- static keyword , cela s'appelle instance variable et chaque instance de la classe a sa propre copie de la variable.

Exemple : static int crunchify_variable_name ;

  • Les variables statiques sont partagées entre toutes les instances de la classe.
  • L'une des principales raisons pour lesquelles vous en avez besoin lorsque vous souhaitez gérer beaucoup de mémoire.
  • Pour toutes les variables statiques, il n'y aura qu'une seule copie disponible que vous pourrez utiliser.
  • Vous n'avez absolument pas besoin d'un objet de classe pour accéder à une variable statique.
    • Utilisez-le simplement directement. Vous n'avez pas besoin d' object.StaticVariable

Qu'est-ce qu'un bloc statique ?

Le bloc statique est un bloc d'instructions à l'intérieur d'une Java class qui sera exécuté lorsqu'une classe est chargée pour la première fois dans la JVM.

Pouvez-vous remplacer la méthode privée en Java?

  • Et bien non. Les méthodes privées ne peuvent pas être remplacées car elles ne peuvent pas être utilisées en dehors de la classe.

Pourquoi ne pouvons-nous pas remplacer les méthodes statiques en Java ?

  • Les méthodes statiques ne peuvent pas non plus être remplacées car elles font partie d'une classe plutôt que d'un objet

Pouvons-nous accéder à une variable non statique dans un contexte statique ?

  • Pour pouvoir accéder aux variables non statiques à partir de vos méthodes statiques, elles doivent être des variables membres statiques.

Détails sur la méthode statique

  • Comment identifier ? Vérifiez d'abord ceci. Avez-vous besoin d'un objet de classe pour accéder à la méthode statique ? Si vous n'avez pas besoin d'un objet, c'est la méthode statique.
  • Vous devez utiliser le mot-clé statique afin de spécifier la méthode statique
  • Mieux vaut utiliser le mot-clé statique si cette méthode ne va pas changer tout au long de votre projet lors de l'exécution.
  • Vous ne pouvez pas remplacer la méthode statique.

Jetons un coup d'œil aux exemples ci-dessous :

Exemple 1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
package crunchify . com . tutorials ;
 
/**
* @author Crunchify.com
*
*/
 
public class CrunchifyStaticMethodMain {
 
public static void main ( String args [ ] ) {
String [ ] crunchifyObject = new String [ 3 ] ;
crunchifyObject = new String [ ] { "Google" , "Facebook" , "Crunchify" } ;
 
// creating instnace
CrunchifyStaticMethodMain object = new CrunchifyStaticMethodMain ( ) ;
object . crunchifyTestMethod ( crunchifyObject ) ;
 
}
 
/*
* Check this out: Let's understand little more...
*
* Here method crunchifyTestMethod is defined as
* public void crunchifyTestMethod(String[])
* so it is "non-static". It can't be called unless it is called on an instance of CrunchifyStaticMethodMain.
*
* If you declared your method as
* public static void crunchifyTestMethod(int[])
* then you could call: CrunchifyStaticMethodMain.crunchifyTestMethod(arr); within main without having created an instance for it.
*/
 
public void crunchifyTestMethod ( String [ ] crunchifyObject ) {
for ( int i = 0 ; i < crunchifyObject . length ; i ++ )
System . out . println ( crunchifyObject [ i ] ) ;
 
}
 
}

Consultez l'explication dans above code block . Nous devons créer une instance de Class pour accéder à la méthode non statique.

Exemple-2 :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
public class CrunchifyStaticDeclaration {
 
// 1st static block
static {
System . out . println ( "\nI'm static block 1.." ) ;
setTestString ( "This is static block's String" ) ;
setTestValue ( 2 ) ;
}
 
// 2nd static blocks in same class
static {
System . out . println ( "\nI'm static block 2.." ) ;
}
 
// static variable example
private static int testValue ; // kept private to control it's value through setter
 
public int getTestValue ( ) {
return testValue ;
}
 
// static method example
public static void setTestValue ( int testValue ) {
if ( testValue > 0 )
CrunchifyStaticDeclaration . testValue = testValue ;
System . out . println ( "setTestValue method: " + testValue ) ;
}
 
public static String testString ;
 
/**
* @return the testString
*/
public static String getTestString ( ) {
return testString ;
}
 
/**
* @param testString the testString to set
*/
public static void setTestString ( String testString ) {
CrunchifyStaticDeclaration . testString = testString ;
System . out . println ( "setTestString method: " + testString ) ;
}
 
// static util method
public static int subValue ( int i , int . . . js ) {
int sum = i ;
for ( int x : js )
sum -= x ;
return sum ;
}
}

Faisons maintenant le test :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com . crunchify . tutorials ;
 
/**
* @author Crunchify.com
*/
 
public class CrunchifyStaticExample {
 
public static void main ( String [ ] args ) {
CrunchifyStaticDeclaration . setTestValue ( 5 ) ;
 
// non-private static variables can be accessed with class name
CrunchifyStaticDeclaration . testString = "\nAssigning testString a value" ;
CrunchifyStaticDeclaration csd = new CrunchifyStaticDeclaration ( ) ;
System . out . println ( csd . getTestString ( ) ) ;
 
// class and instance static variables are same
System . out . print ( "\nCheck if Class and Instance Static Variables are same:  " ) ;
System . out . println ( CrunchifyStaticDeclaration . testString == csd . testString ) ;
System . out . println ( "Why? Because: CrunchifyStaticDeclaration.testString == csd.testString" ) ;
}
}

Sortir:

1
2
3
4
5
6
7
8
9
10
11
I 'm static block 1..
setTestString method: This is static block' s String
setTestValue method : 2
 
I ' m static block 2..
setTestValue method : 5
 
Assigning testString a value
 
Check if Class and Instance Static Variables are same :    true
Why ? Because : CrunchifyStaticDeclaration . testString == csd . testString

J'espère que vous obtiendrez vraiment de bonnes informations sur la méthode statique, les variables et les blocs.

Faites-nous savoir si vous rencontrez un problème lors de l'exécution du programme ci-dessus ou si vous rencontrez un problème pour comprendre le mot-clé statique en Java.