Fundamentele metodei statice Java, clasă, variabilă și bloc

Publicat: 2019-12-13
Elementele fundamentale ale metodelor și variabilelor statice Java

Ce este static în Java?

  • Cuvântul cheie static poate fi folosit cu clasă, variabilă, metodă și bloc.
  • Membrii statici nu aparțin niciunei instanțe specifice.
  • Membrii statici aparțin numai clasei.
  • Odată ce faci un membru static, îl poți accesa fără niciun obiect.

Aveți vreo întrebare de mai jos?

  • Ați putea scrie cele mai bune practici pentru metodele statice Java?
  • Ce sunt metodele statice Java în interfață?
  • Ai o întrebare despre metodele statice Java vs singleton?
  • Metode statice Java versus performanța metodelor de instanță
  • Metode și variabile statice Java
  • Metode statice Java vs non-statice
  • Metode statice Java în clasa abstractă

Cuvântul cheie static poate fi utilizat în 3 scenarii:

  • Variabile statice
  • Metode statice
  • Blocuri statice de cod.

variabilă statică („static” cuvânt cheie = variabile de clasă)

introducerea-și-tutorialul-complet al metodei-statice-java

În Java, variabilele pot fi declarate cu cuvântul cheie „ static ”.

Exemplu: static int y = 0;

Când o variabilă este declarată cu cuvântul cheie static , se numește class variable . Toate instanțele au aceeași copie a variabilei. O variabilă de clasă poate fi accesată direct cu clasa, fără a fi nevoie de a crea o instanță.

Fără cuvânt cheie „static” = variabile de instanță

Fără static keyword , acesta se numește instance variable și fiecare instanță a clasei are propria copie a variabilei.

Exemplu: static int crunchify_variable_name ;

  • Variabilele statice sunt partajate între toate instanțele clasei.
  • Unul dintre motivele principale pentru care aveți nevoie de el atunci când doriți să faceți o mulțime de gestionare a memoriei.
  • Pentru toate variabilele statice – va fi o singură copie disponibilă pentru utilizare.
  • Nu aveți nevoie de un obiect de clasă pentru a accesa variabila statică.
    • Folosește-l direct. Nu aveți nevoie de object.StaticVariable

Ce este blocul static?

Blocul static este un bloc de instrucțiuni în interiorul unei Java class care va fi executat atunci când o clasă este încărcată pentru prima dată în JVM.

Puteți suprascrie metoda privată în Java?

  • Ei bine, nu. Metodele private nu pot fi înlocuite, deoarece nu sunt disponibile pentru utilizare în afara clasei.

De ce nu putem suprascrie metodele statice în Java?

  • De asemenea, metodele statice nu pot fi suprascrise deoarece fac parte mai degrabă dintr-o clasă decât dintr-un obiect

Putem accesa variabile non-statice în context static?

  • Pentru a putea accesa variabile non-statice din metodele dvs. statice, acestea trebuie să fie variabile membre statice.

Detalii despre metoda statică

  • Cum se identifică? Verifică asta mai întâi. Aveți nevoie de un obiect de clasă pentru a accesa metoda statică? Dacă nu aveți nevoie de un obiect, atunci este metoda Statică.
  • Trebuie să utilizați cuvântul cheie static pentru a specifica metoda statică
  • Mai bine folosiți cuvântul cheie static dacă această metodă nu se va schimba pe parcursul proiectului dvs. în timpul execuției.
  • Nu puteți suprascrie metoda statică.

Să aruncăm o privire la exemplele de mai jos:

Exemplul-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 ] ) ;
 
}
 
}

Verificați explicația din above code block . Trebuie să creăm o instanță de Class pentru a accesa metoda non-statică.

Exemplul-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 ;
}
}

Acum să facem testul:

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" ) ;
}
}

Ieșire:

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

Sper că veți obține cu adevărat informații bune despre metoda statică, variabile și blocuri.

Anunțați-ne dacă vă confruntați cu vreo problemă cu rularea programului de mai sus sau cu o problemă de înțelegere a cuvântului cheie static în Java.