Java-Programmierung (statische Klausel und "Klassenvariablen")

statische Klausel und Klasse

Informationen zum Wort static, das vor dem Methodennamen der Hauptmethode steht. Sie können es lesen, wenn Sie die Standardausgabe verstehen, wie man Klassen schreibt und wie man sie aufruft.

Klassenvariable

Normalerweise werden Klassen instanziiert und verwendet. Versuchen wir die folgende Methode.

public class Calculate {
 private int s = 3;
 public int multipleIntegerNumber(int num){
  s = num + s;
  s = num + s;
  return s;  
 }
}

Nennen wir dies in der Hauptmethode.

public class Mainmethod{
  public static void main(String[] args){
    
  int result; 
   
   Calculate calculate = new Calculate(); 
   result = calculate.multipleIntegerNumber(3);
  }
}

Dann ist das variable Ergebnis 9. Lassen Sie es uns wie folgt ändern.

public class Calculate {
private static int s = 3;
	private int ns = 3;
	int[] r = new int[2];

	public int[] multipleIntegerNumber1(int num){
	 s = 2*num + s; // -----> A
	 ns = 2*num + ns; 

	 r[0] = s;
	 r[1] = ns;
	 return r;

	}
}

Rufen wir diese Klasse mit der folgenden Hauptmethode auf.

public class Mainmethod{
  public static void main(String[] args){
    
   int[] result1;
   int[] result2;

   ClassValue calculate1 = new ClassValue();
   ClassValue calculate2 = new ClassValue();

   result1 = calculate1.multipleIntegerNumber1(3);// -------> ➀
   result2 = calculate2.multipleIntegerNumber1(3);// -------> ➁

  }
}

Was ist nun mit Ergebnis1 und Ergebnis2? Abschließend sprechen Es wird sein. Der Wert von resul2 [0] ändert sich. Das liegt daran, dass ich es statisch genannt habe. Wenn keine statische Aufladung vorliegt, wird der Wert der Variablen für jede Instanz zurückgesetzt. Jedoch. Der Wert der Variablen wird auch dann vererbt, wenn sich die Instanz ändert, an die die Statik angehängt ist. In diesem Beispiel war die Variable ns zum Zeitpunkt der Deklaration nicht als statisch markiert, sodass die Werte in den Instanzen berechne1 und berechne2 zurückgesetzt wurden. Da die Variable s zum Zeitpunkt der Deklaration als statisch angehängt ist, wurde der Wert in den Instanzen berechne1 und berechne2 vererbt. Zum Zeitpunkt von ➀ wird $ 2 {\ times} num (= 6) $ zu $ s (= 3) $ addiert, um $ 9 $ zu erhalten. Wenn ➁, wird $ 2 {\ times} num (= 6) $ zu $ s (= 9) $ addiert, um $ 15 $ zu erhalten. Es wird übrigens als Instanzvariable oder Klassenvariable bezeichnet, je nachdem, ob eine statische Klausel hinzugefügt wird oder nicht.

Zwei Methoden für Klassenvariablen

Abschließend werde ich ein Beispiel für die Verwendung einer anderen Klassenvariablen geben. Die folgende ClassValue2-Klasse definiert zwei Instanzen, die static_count und die Klassenvariable instans_count. Jedes Mal, wenn die vier in der Klasse definierten Methoden aufgerufen werden, wird 1 zu den beiden Variablen hinzugefügt. Dann wird der Wert durch die Bestätigungsmethode angegeben.

public class ClassValue2 {
	private int s = 3;
	private static int static_count = 0;
	private int instans_count = 0;

	public void add(int num){
		s = num + s;
		static_count = static_count + 1;
		instans_count = instans_count + 1;
	}

	public void substract(int num){
		s = -num + s;
		static_count = static_count + 1;
		instans_count = instans_count + 1;
	}

	public void multiple(int num){
		s = num*s;
		static_count = static_count + 1;
		instans_count = instans_count + 1;
	}
	public void division(int num){
		s = 1/num*s;
		static_count = static_count + 1;
		instans_count = instans_count + 1;
	}

	public void confirmation(){
		System.out.println("static_count:" + static_count);
		System.out.println("instans_count:" + instans_count);
		System.out.println("s:" + s);
	}

}

Nennen wir es so: Wir rufen aus 3 Instanzen an.

ClassValue2 classValue2_1 = new ClassValue2();
classValue2_1.add(3);
ClassValue2 classValue2_2 = new ClassValue2();
classValue2_2.substract(1);
ClassValue2 classValue2_3 = new ClassValue2();
classValue2_3.division(2);
classValue2_1.confirmation();
classValue2_2.confirmation();
classValue2_3.confirmation();

Das Ergebnis ist wie folgt: Auf diese Weise. Die Variable instans_count kann die Anzahl der Anrufe von dieser Instanz zählen, und die Variable static_count kann die Gesamtzahl der Anrufe von allen Instanzen zählen.