Cet article est un compte rendu de ce que je comprends pour ceux qui étudient Java.
Dans mon article, les principales fonctionnalités Java sont résumées dans la liste ci-dessous. Cette fois, on suppose que vous avez une certaine compréhension des variables et des types, donc si vous avez des questions, veuillez vérifier à partir du lien ci-dessous.
À propos de la déclaration, de l'initialisation et du type de variable Java Le lien ci-dessus est mon article que j'ai mentionné plus tôt, mais il y a d'autres choses à garder à l'esprit lors de la déclaration et du référencement de variables internes. C'est la plage dans laquelle vous pouvez voir les variables. Dans ce qui suit, les variables locales et les variables statiques sont utilisées comme exemples.
class Main{
public static void main(String args[]){
int i = 30;
System.out.println(i);
}
}
Déclarer int i dans la méthode principale. Vous pouvez donc l'utiliser en main jusqu'à ce que le processus principal soit terminé. Quand tu cours
30
Est affiché, ainsi le contenu de i peut être affiché. Cependant, si vous limitez la place à déclarer, vous ne pourrez peut-être pas trouver la variable.
class Main{
public static void main(String args[]){
if(true){
int i = 30; //Déclaré en si
}
System.out.println(i);
}
}
Si vous exécutez cette description, vous obtiendrez l'erreur suivante.
Erreur:Impossible de trouver le symbole
System.out.println(i);
^
Je ne trouve pas i parce que je le déclare dans if. Je pense que de telles erreurs disparaîtront si nous les déclarons dans un large éventail afin que cela ne se produise pas, mais cette méthode a un piège.
class Main{
static int i = 30;
public static void main(String args[]){
System.out.println(i);
plus20();
}
static void plus20(){
i = i + 20;
System.out.println(i);
}
}
Lorsque vous faites ce qui précède,
30
50
Sera. Puisque i est déclaré utilisable n'importe où dans la classe, vous pouvez obtenir l'intérieur de la variable avec plus20 et main. Cette description semble correcte, mais par exemple, la méthode plus20 est une méthode qui veut simplement afficher l'état d'ajout de 20, et lorsque vous souhaitez afficher la valeur d'origine plus tard, la valeur de i est réécrite avec plus20. Je vais finir.
class Main{
static int i = 30;
public static void main(String args[]){
System.out.println(i);
plus20();
System.out.println(i);
}
static void plus20(){
i = i + 20;
System.out.println(i);
}
}
Quand tu cours
30
50
50
Dans l'ordre du code, je voudrais que le troisième nombre soit 30, mais comme la valeur a été réécrite en plus20, elle est 50. Étant donné que de tels problèmes surviennent, je pense qu'il est préférable de restreindre autant que possible la gamme de variables.
class Main{
public static void main(String args[]){
int i = 30;
System.out.println(i);
plus20(i);
System.out.println(i);
}
static void plus20(int z){
z = z + 20;
System.out.println(z);
}
}
Quand tu cours
30
50
30
Même si j'ai ajouté les valeurs dans plus20, cela n'a pas interféré avec i, donc j'ai pu obtenir la valeur d'origine de i.
Chacun a un nom en fonction de la plage de référence des variables mentionnées ci-dessus.
Fondamentalement, c'est une variable utilisée à l'intérieur de la méthode, et c'est une variable locale qui ne peut pas être référencée en dehors de la méthode.
class Main{
public static void main(String args[]){
int i = 100; //d'ici
System.out.println(i);
//Jusque là
}
}
Fondamentalement, je veux restreindre la plage de référence des variables, donc je pense qu'il est facile de décrire cela.
En gros, écrivez la déclaration sous la classe et gérez-la dans la classe
class Mikan{
int i;
Mikan(){
this.i = 10;
}
}
Déclaré pour chaque instance lorsque Mikan est instancié. Si vous faites deux Mikan, c'est comme si chacun avait int i. Dans le cas de cette définition, c'est une variable qui peut être utilisée à l'intérieur de l'instance, et il est également possible de créer une instance en externe et de lire la variable.
class Mikan{
int j;
Mikan(){
this.j = 10;
}
}
class Main{
public static void main(String args[]){
Mikan mikan1 = new Mikan();
Mikan mikan2 = new Mikan();
mikan2.j += 10;
//Variable d'instance
System.out.println(mikan1.j);
System.out.println(mikan2.j);
}
}
Si vous l'exécutez ici
10
20
Il sera affiché. Vous pouvez créer une instance Mikan dans la classe Main et faire référence aux variables qu'elle contient.
La variable statique est similaire à la variable d'instance ci-dessus, mais vous pouvez l'utiliser sans créer d'instance.
class Mikan{
static int i = 10;
}
class Main{
public static void main(String args[]){
System.out.println(Mikan.i);
}
}
10
Elle ressemble à une variable d'instance, mais elle a une variable à chaque fois qu'elle est créée. Les variables statiques partagent la même valeur au sein de la classe.
class Mikan{
static int i = 10;
int j;
Mikan(){
this.j = 10;
}
}
class Main{
public static void main(String args[]){
Mikan mikan1 = new Mikan();
Mikan mikan2 = new Mikan();
mikan2.j += 10;
//Variable d'instance
System.out.println(mikan1.j);
System.out.println(mikan2.j);
//variable statique
System.out.println(Mikan.i);
Mikan.i += 30;
System.out.println(Mikan.i);
}
}
10
20
10
40
Si vous souhaitez avoir une valeur unique pour chaque instance, utilisez une variable d'instance, et si vous souhaitez voir une variable en commun, utilisez une variable statique.
De plus, lors de l'appel d'une variable d'instance ou d'une variable statique à partir d'une fonction de la classe, elle sera décrite comme ceci.
class Mikan{
static int i = 10;
int j = 50;
void inscheck(){
//les variables statiques peuvent être appelées
System.out.println(i);
//Les variables d'instance peuvent être appelées
System.out.println(j);
}
static void check(){
//les variables statiques peuvent être appelées
System.out.println(i);
//Les variables d'instance ne peuvent pas être appelées
// System.out.println(j);
}
}
class Main{
public static void main(String args[]){
Mikan mikan1 = new Mikan();
//Fonctions de l'instance
mikan1.inscheck();
//fonction statique
Mikan.check();
}
}
Quand tu cours
10
50
10
Ce sera. Les deux peuvent être appelés à partir de la fonction de l'instance appelée à partir de l'instance.
Dans le cas d'une fonction statique appelée depuis une classe, les variables statiques peuvent être appelées, mais les variables d'instance ne peuvent pas être appelées.
Si vous décommentez et compilez
test.java:18:Erreur:La variable non statique j ne peut pas être référencée à partir d'un contexte statique
System.out.println(j);
^
1 erreur
Je vais sortir. Si vous obtenez une erreur comme celle-ci, vous pouvez la résoudre rapidement en vérifiant le modificateur de la spécification de variable.
C'était une explication sur la plage où les variables peuvent être vues. Au fur et à mesure que la compréhension de ce domaine progresse, je pense qu'il y aura moins de bugs tels que des valeurs involontaires.
Recommended Posts