Grundlagen von statischen Methoden, Klassen, Variablen und Blöcken in Java

Veröffentlicht: 2019-12-13
Grundlagen statischer Java-Methoden und -Variablen

Was ist statisch in Java?

  • Statisches Schlüsselwort kann mit Klasse, Variable, Methode und Block verwendet werden.
  • Statische Member gehören zu keiner bestimmten Instanz.
  • Statische Member gehören nur zur Klasse.
  • Sobald Sie ein Mitglied statisch gemacht haben, können Sie ohne Objekt darauf zugreifen.

Haben Sie eine der folgenden Fragen?

  • Könnten Sie Best Practices für statische Java-Methoden aufschreiben?
  • Was sind statische Java-Methoden in der Schnittstelle?
  • Haben Sie eine Frage zu statischen Java-Methoden im Vergleich zu Singleton?
  • Leistung statischer Java-Methoden im Vergleich zu Instanzmethoden
  • Statische Java-Methoden und -Variablen
  • Statische Java-Methoden vs. nicht statische
  • Statische Java-Methoden in der abstrakten Klasse

Das statische Schlüsselwort kann in 3 Szenarien verwendet werden:

  • Statische Variablen
  • Statische Methoden
  • Statische Codeblöcke.

statische Variable („static“-Schlüsselwort = Klassenvariablen)

java-static-method-einführung-und-vollständiges-tutorial

In Java können Variablen mit dem Schlüsselwort „ static “ deklariert werden.

Beispiel: static int y = 0;

Wenn eine Variable mit dem Schlüsselwort static deklariert wird, wird sie als class variable . Alle Instanzen teilen dieselbe Kopie der Variablen. Auf eine Klassenvariable kann direkt mit der Klasse zugegriffen werden, ohne dass eine Instanz erstellt werden muss.

Kein „statisches“ Schlüsselwort = Instanzvariablen

Ohne das static keyword heißt es instance variable , und jede Instanz der Klasse hat ihre eigene Kopie der Variable.

Beispiel: static int crunchify_variable_name ;

  • Die statischen Variablen werden von allen Instanzen der Klasse gemeinsam genutzt.
  • Einer der Hauptgründe, warum Sie es brauchen, wenn Sie viel Speicherverwaltung durchführen möchten.
  • Für alle statischen Variablen steht Ihnen nur eine einzige Kopie zur Verfügung.
  • Sie benötigen absolut kein Klassenobjekt, um auf statische Variablen zuzugreifen.
    • Verwenden Sie es einfach direkt. Du brauchst kein object.StaticVariable

Was ist ein statischer Block?

Der statische Block ist ein Anweisungsblock innerhalb einer Java class , der ausgeführt wird, wenn eine Klasse zum ersten Mal in die JVM geladen wird.

Können Sie die private Methode in Java überschreiben?

  • Nun, nein. Private Methoden können nicht überschrieben werden, da sie außerhalb des Unterrichts nicht verwendet werden können.

Warum können wir statische Methoden in Java nicht überschreiben?

  • Statische Methoden können auch nicht überschrieben werden, da sie eher Teil einer Klasse als eines Objekts sind

Können wir im statischen Kontext auf nicht statische Variablen zugreifen?

  • Um von Ihren statischen Methoden aus auf nicht statische Variablen zugreifen zu können, müssen sie statische Mitgliedsvariablen sein.

Details zur statischen Methode

  • Wie identifizieren? Überprüfen Sie dies einfach zuerst. Benötigen Sie ein Klassenobjekt, um auf die statische Methode zuzugreifen? Wenn Sie kein Objekt benötigen, ist es die statische Methode.
  • Sie müssen das Schlüsselwort static verwenden, um die statische Methode anzugeben
  • Verwenden Sie besser das Schlüsselwort static, wenn sich diese Methode zur Laufzeit nicht im gesamten Projekt ändert.
  • Sie können die statische Methode nicht überschreiben.

Werfen wir einen Blick auf die folgenden Beispiele:

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

Schauen Sie sich die Erklärung im above code block . Wir müssen eine Instanz der Klasse erstellen, um auf die nicht statische Methode zuzugreifen.

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

Jetzt machen wir einen 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" ) ;
}
}

Ausgabe:

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

Ich hoffe, Sie erhalten wirklich gute Informationen über statische Methoden, Variablen und Blöcke.

Lassen Sie uns wissen, wenn Sie Probleme haben, das obige Programm auszuführen, oder wenn Sie ein Problem haben, das statische Schlüsselwort in Java zu verstehen.