Comment utiliser le mot-clé final en Java

1. Comprendre

final : la

2. Fonction

structures finales modifiables : classes, méthodes, Variable.

1. Modification-class

final est utilisé pour modifier une classe, indiquant que cette classe ne peut pas être héritée par d'autres classes, améliorant ainsi la sécurité et la lisibilité du programme.

Par exemple : classe String, classe System, classe StringBuffer... #}

class B extends A{ //Erreur, ne peut pas être hérité.

}

2. La méthode de modification

final est utilisée pour modifier la méthode : indiquant que cette méthode ne peut pas être remplacée par les sous-classes.

Par exemple : getClass(); dans la classe Object #3 Modification-Variable

final Variables modifiées. (variables membres ou variables locales) sont appelées constantes. Le nom est en majuscule et ne peut être attribué qu'une seule fois.

static final est utilisé pour modifier des propriétés : les constantes globales.

Démonstration de code : Object类中getClass();

代码演示：

class A {
   public final void print() {
     System.out.println("A");
   } 
}
class B extends A {
    public void print() { 
    // 错误，不能被重写。
    } 
}

3. 修饰-变量

final 修饰的变量(成员变量或局部变量)称为常量。名称大写，且只能被赋值一次。

static final 用来修饰属性：全局常量。

代码演示：

class A {
   private final String INFO = "嘻嘻"; //声明常量
     public void print() {     
     //INFO = "哈哈";
     //The final field A.INFO cannot be assigned
     } 
}

3.1 修饰-成员变量(属性)

final 标记的成员变量必须在声明（显式初始化）时或在 每个构造器中或代码块中显式赋值，然后才能使用。

如：final double MY_PI = 3.14;

//题目一：
public class Test1 {    
        public int addOne(final int x) {
         //   return ++x;
         //Cannot assign a value to final variable 'x'
            return x + 1;
        }
}
//题目二：
public class Something {
    public static void main(String[] args) {
       Other o = new Other();
       new Something().addOne(o);
    }
    public void addOne(final Other o) {
       // o = new Other();
       o.i++;
     } 
}
class Other {
   public int i; 
}
//题目三：
class Root{
	static{
		System.out.println("Root的静态初始化块");
	}
	{
		System.out.println("Root的普通初始化块");
	}
	public Root(){
		super();
		System.out.println("Root的无参数的构造器");
	}
}
class Mid extends Root{
	static{
		System.out.println("Mid的静态初始化块");
	}
	{
		System.out.println("Mid的普通初始化块");
	}
	public Mid(){
		super();
		System.out.println("Mid的无参数的构造器");
	}
	public Mid(String msg){
		//通过this调用同一类中重载的构造器
		this();
		System.out.println("Mid的带参数构造器，其参数值："
			+ msg);
	}
}
class Leaf extends Mid{
	static{
		System.out.println("Leaf的静态初始化块");
	}
	{
		System.out.println("Leaf的普通初始化块");
	}	
	public Leaf(){
		//通过super调用父类中有一个字符串参数的构造器
		super("小老师ir");
		System.out.println("Leaf的构造器");
	}
}
public class LeafTest{
	public static void main(String[] args){
		new Leaf(); 
		System.out.println();
		new Leaf();
	}
}
/*output：
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：小老师ir
Leaf的普通初始化块
Leaf的构造器
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：小老师ir
Leaf的普通初始化块
Leaf的构造器
*/

3.1 Modification - variables membres (propriétés)

les variables membres marquées finales doivent être déclarées (explicitement initialisées) Ou attribuer le valeur explicitement dans chaque constructeur ou bloc de code avant de pouvoir être utilisé.

Par exemple : final double MY_PI = 3.14;

3.2 Variables locales de modification#🎜🎜##🎜🎜#Lors de l'utilisation de final pour modifier variables locales, indiquant que ce paramètre est une constante. Lorsque nous appelons cette méthode, attribuez un paramètre réel au paramètre constant. Une fois attribué, ce paramètre formel ne peut être utilisé que dans le corps de la méthode et ne peut pas être réaffecté. #🎜🎜##🎜🎜#三、Questions classiques#🎜🎜#rrreee

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!