Quelle est l'utilisation du mot clé final?

C'est parce que vous utilisez la fermeture ici. Cela signifie que l'intérieur de la classe utilise le contexte de la inbounded. Utiliser les variables doivent être déclarées final, afin de ne pas être changé.

Voir plus ici.

Lire cet article de comprendre les détails de mise en œuvre concernés:

La raison de cette restriction
devient évident si nous éclairer
sur la façon dont les classes sont mises en œuvre.
Un anonyme, un local de classe peut utiliser les locaux
les variables, car le compilateur
donne automatiquement à la classe a
privé champ d'instance afin de conserver une copie
de chaque variable locale la classe.
Le compilateur ajoute également caché
les paramètres de chaque constructeur
initialiser automatiquement créé
champs privés. Ainsi, une classe locale
ne fait pas les accès locaux
variables, mais simplement de sa propre salle de
des copies. Le seul moyen d'
travail correctement, c'est si le local
les variables sont déclarées final, de sorte que
ils sont garantis de ne pas changer.
Avec cette garantie en place, le
classe locale est assuré que son
interne des copies des variables
fidèlement la réalité locale
les variables.

EDIT:

Berlin Brown dit: "j'ai posté un décompilé version d'un
anonyme intérieur de la classe. Mais pour être
honnête, je ne vois pas pourquoi l'
compilateur doit avoir cette information.
Même si le champ est déclarée final,
le champ peut encore être null. Je pense
c'est l'un de ceux de Java bizarreries, vous
devez déclarer ce domaine
final...parce que c'est la façon dont il est.
Il n'y a pas une raison précise"

La raison est de s'assurer que les utilisateurs se rendent compte que la fermeture "fermer", des variables et non des valeurs. Supposons qu'il n'y a pas d'obligation d'avoir final des variables locales. Puis on a pu écrire du code comme:

public void doIt() {
    for(int i = 0; i < 3; ++i) {
        runnables.add(new Runnable() {
            @Override
            public void run() {
                System.out.println(i);
            }
        });
    }
    run(runnables); //run each runnable
}

Que pensez-vous serait la sortie? Si vous pensez qu'il serait "0 1 2" vous aurait tort depuis le Praticable ferme au cours de la "variable" i et non pas la "valeur" de moi, à ce point dans le temps et donc le résultat sera "2 2 2". Ce qui peut être fait pour obtenir le comportement attendu d'ici? Deux solutions: soit s'appuyer sur les utilisateurs à avoir une compréhension de la façon dont les fermetures de travail ou d'une certaine manière de l'appliquer au niveau du langage. Et c'est la deuxième option avec laquelle la langue designers ont passé avec.

public void doIt() {
    for(int i = 0; i < 3; ++i) {
        final int j = i; //notice the final local variable
        runnables.add(new Runnable() {
            @Override
            public void run() {
                System.out.println(j);
            }
        });
    }
    run(runnables);
}

JFTR, je ne dis pas que la deuxième option est "la" façon de faire, c'est juste que le fait d'avoir des variables locales marqué comme final avant d'être utilisés dans les classes internes anonymes est un grand briseur d'affaire pour moi. Bien sûr, YMMV. 🙂

Le but de la “finale” du mot-clé dans JAVA peut être défini en trois niveau de la Classe, la Méthode, la variable

Java final variable: If you make any variable as final, you cannot change the value of final variable (It will be constant).

Java final method: If you make any method as final, you cannot override it.

Java final class: If you make any class as final, you cannot extend it.

Il aide également à comprendre comment Java crée un anonyme intérieur de la classe. Comment Java implémente la classe particulière.

Java besoins de cette variable, pour être définitive, car le compilateur doit connaître le type de l'objet au moment de la compilation. Le compilateur génère un champ à l'intérieur de l'anonyme intérieure implémentation de la classe (dans ce cas la "et").

Si le type n'est pas définitive, comment le compilateur de déterminer comment construire l'intérieur de la classe de mise en œuvre. Fondamentalement, en déclarant le champ final, vous donnez le compilateur Java plus d'informations.

Code qui n'aide pas le compilateur, ne compile pas votre anonyme intérieure:

Object et;
et = a ? new Object() : new EditText();

...

Avec le code ci-dessus, le compilateur Java ne peut pas vraiment construire l'anonyme intérieur de la classe.

Votre code:

final EditText et=(EditText)findViewById(R. id.t);

...

new Button.OnClickListener$1(){
            public void onClick(View v)<br>
            {
            Intent on=new Intent(Intent.ACTION_CALL,Uri.parse("tel:"+et.getText()));
            startActivity(on);
            }
        });

...
La java, le compilateur va créer un bytecode de la classe, l'implémentation de l'intérieur de la classe du bloc que vous avez prévu que pourrait ressembler à ceci.

public class OnClickListener$1 {

 private final EditText et ; <---- this is important
 public OnClickListener$1(final et) {
    this.et = et;
 }
 public void onClick(View v)<br>
                {
                Intent on=new Intent(Intent.ACTION_CALL,Uri.parse("tel:"+et.getText()));
                startActivity(on);
                }
}

Vous pouvez tester le pseudo-code que j'ai fourni par trouver l'anonyme du bytecode de la classe de 1 $et de décompiler que fichier bytecode.