Programmation Java (clause statique et "variables de classe")

clause statique et classe

À propos du mot statique qui précède le nom de la méthode principale. Si vous comprenez la sortie standard, comment écrire une classe et comment l'appeler, vous pouvez la lire.

Variable de classe

Habituellement, les classes sont instanciées et utilisées. Essayons la méthode suivante.

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

Appelons cela dans la méthode principale.

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

Ensuite, le résultat variable est 9. Changeons cela comme suit.

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;

	}
}

Appelons cette classe à partir de la méthode principale suivante.

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);// -------> ➁

  }
}

Maintenant qu'en est-il du résultat1 et du résultat2? Parlant de la conclusion Ce sera. La valeur de resul2 [0] change. C'est parce que je l'ai nommé statique. Lorsqu'il n'y a pas de statique, la valeur de la variable est réinitialisée pour chaque instance. Pourtant. La valeur de la variable est héritée même si l'instance à laquelle la statique est attachée change. Dans le cas de cet exemple, la variable ns n'était pas marquée comme statique au moment de la déclaration, les valeurs ont donc été réinitialisées dans les instances Calculate1 et Calculate2. Cependant, comme la variable s est attachée en tant que statique au moment de la déclaration, la valeur a été héritée dans les instances Calculate1 et Calculate2. Au moment de ➀, $ 2 {\ times} num (= 6) $ est ajouté à $ s (= 3) $ pour faire 9 $. De plus, quand ➁, $ 2 {\ times} num (= 6) $ est ajouté à $ s (= 9) $ pour faire 15 $. En passant, on l'appelle une variable d'instance ou une variable de classe selon que l'on ajoute ou non une clause statique.

Deux méthodes de variables de classe

Enfin, je vais donner un exemple de la façon d'utiliser une autre variable de classe. La classe ClassValue2 suivante définit deux instances, le static_count et la variable de classe instans_count. Et chaque fois que les quatre méthodes définies dans la classe sont appelées, une est ajoutée aux deux variables. Ensuite, la valeur est donnée par la méthode de confirmation.

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

}

Appelons ça comme ça: Nous appelons depuis 3 instances.

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();

Le résultat est le suivant: De cette façon. La variable instans_count peut compter le nombre d'appels de cette instance, et la variable static_count peut compter le nombre total d'appels de toutes les instances.