_
*{ margin: 0; padding: 0; }
.on2{
margin: 10px 0;
cursor: pointer;
user-select: none;
color: white;
box-shadow: 1px 1px 6px 1px;
text-shadow: rgb(34, 34, 34) 2px 2px 3px;
text-indent: 2rem;
background-color: deeppink;
font: bold 24px/50px "" ;
border-bottom-right-radius: 40px;
border-top-right-radius: 40px;
}
.on3{
width:100%;
margin: 10px 0;
cursor: pointer;
user-select: none;
color: white;
border-bottom-right-radius: 40px;
border-top-right-radius: 40px;
box-shadow: 1px 1px 6px 1px;
text-shadow: rgb(34, 34, 34) 2px 2px 3px;
text-indent: 2rem;
font: bold 20px/40px "" ;
background-color:rgb(44, 219, 135);
}
p{font: 20px/34px "";}
-->
关键字 final 的使用小结：
final 可以修饰变量，被 final 修饰的变量被赋初始值之后，不能对它重新赋值。
final 可以修饰方法，被 final 修饰的方法不能被重写。
final 可以修饰类，被 final 修饰的类不能派生子类。
final 修饰变量
final 成员变量
被 final 修饰的成员变量必须显式指定初始值，而且只能在如下 3 个位置指定初始值。
定义 final 实例变量时指定初始值；
在非静态初始化块中为 final 实例变量指定初始值；
在构造器中为 final 实例变量指定初始值。
对于普通实例变量， Java 程序可以对它执行默认的初始化，也就是将实例变量的值指定为默认的初始值 0 或 null ；但对于 final 实例变量，则必须由程显式指定初始值。
下面程序示范了在 3 个地方对 final 实例变量进行初始化。
public class FinalDemo {
final String str1 = "直接显式指定初始值";
final String str2 ;
final String str3 ;
{
str2 = "非静态初始化块中指定初始值";
}
public FinalDemo(){
str3 = "构造器中指定初始值";
}
｝
final 类变量
定义 final 类变量时指定初始值； 在静态初始化块中为 final 实例变量指定初始值；
final static String str2 ;
final static String str3 = "指定初始值";
static{
str2 = "非静态初始化块中指定初始值";
}
final 局部变量
final 修饰局部变量时必须显式指定初始值；
final String str1 = "指定初始值";
宏替换 （常量替换）
对于 final 修饰变量，不管它是类变量、实例变量，还是局部变量，只要定义该变量时使用了 final 修饰符修饰，并在定义该 final 类变量时指定了初始值，而且该初始值可以在编译时就被确定下来，那么这个 final 变量本质上已经不再是变量，而是相当于一个直接量，编译器会把程序中所有用到该变量的地方直接替换成该变量的值。
事例如下：
import java.util.Random;
public class FinalDemo {
final String str1 = "java";
final String str2 ;
final String str3 ;
{
str2 = "java";
}
public FinalDemo(){
str3 = "java";
}
public void show(){
System.out.println(str1+str1 == "javajava");//true
System.out.println(str2+str2 == "javajava");//false
System.out.println(str3+str3 == "javajava");//false
}
public static void main(String[] args) {
final int a = 30;
final int b = 90/3; //编译期常量，执行替换
final String c = "30";
final String str = "java";
final double d= 99.0;
final int r = new Random().nextInt(100); //运行时决定初始值
System.out.println("java30" == "java"+a); //true
System.out.println("java30" == "java"+b); //true
System.out.println("java30" == "java"+String.valueOf(a));//false
System.out.println("java30" == "java"+c); //true
System.out.println("---------------------------");
FinalDemo fd = new FinalDemo();
fd.show();
}
}
a、b、c、str 在编译时期就确定这是个变量的值，因此它们都是“常量”。 String.valueOf(a) 需要调用 String 方法因此编译器无法在编译时就确定变量值，无法执行常量替换。
上面程序中定义了 3 个 final 实例变量，但只有 str1 在定义该变量时指定了初始值，另外的 str2 、 str3 分别在非静态初始化块、构造器中指定初始值，因此系统不会对 str2 、 str3 执行“常量替换”，但会对 str1 执行“宏替换”。
上面程序里的 3 条粗体字代码中只有第 1 条才会输出 true ，因为系统会对 str1 执行“宏替换”，也就是说第 3 条粗体字代码相当于： System.out.println （ "Java" + "Java" == "JavaJava" ） ; 上面代码会输出 true 。
与此类似的是，对于普通类变量，在定义时指定初始值、在静态初始化块中赋初始值的效果基本一样。但对于 final 类变量而言，只有在定义 final 类变量时执指定初始值，系统才会对该 final 类变量执行“宏替换”。示例如下：
public class FinalDemo {
final static String str1 = "java";
final static String str2 ;
static{
str2 = "java";
}
public static void main(String[] args) {
System.out.println("javajava" == str1+str1); //true
System.out.println("javajava" == str2+str2); //false
}
}
上面程序中定义了 2 个 final 类变量，但只有 str2 在定义该变量时指定了初始值， str1 则在静态初始化块中指定初始值，因此系统不会对 str1 执行“宏替换”，但会对 str2 执行“宏替换”。上面程序里的 2 条粗体字代码中只有第 2 条才会输出 true ，因为系统会对 str2 执行“宏替换”，也就是说第 2 条粗体字代码相当于： System.out.println （ "Java" + "Java" == "JavaJava" ）;上面代码输出 true 。
注意：对于运行期常量，它既可是基本数据类型，也可是引用数据类型。基本数据类型不可变的是其内容，而引用数据类型不可变的是其引用，引用所指定的对象内容是可变的。示例如下：
public class Person {
private String name;
Person(String name){
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public class FinalTest {
private final String final_01 = "chenssy"; //编译期常量，必须要进行初始化，且不可更改
private final String final_02; //构造器常量，在实例化一个对象时被初始化
private static Random random = new Random();
private final int final_03 = random.nextInt(50); //使用随机数来进行初始化
//引用
public final Person final_04 = new Person("chen_ssy"); //final指向引用数据类型
FinalTest(String final_02){
this.final_02 = final_02;
}
public String toString(){
return "final_01 = " + final_01 +" final_02 = " + final_02 + " final_03 = " + final_03 +
" final_04 = " + final_04.getName();
}
public static void main(String[] args) {
System.out.println("------------第一次创建对象------------");
FinalTest final1 = new FinalTest("cm");
System.out.println(final1);
System.out.println("------------第二次创建对象------------");
FinalTest final2 = new FinalTest("zj");
System.out.println(final2);
System.out.println("------------修改引用对象--------------");
final2.final_04.setName("chenssy");
System.out.println(final2);
}
}
------------------
Output:
------------第一次创建对象------------
final_01 = chenssy final_02 = cm final_03 = 34 final_04 = chen_ssy
------------第二次创建对象------------
final_01 = chenssy final_02 = zj final_03 = 46 final_04 = chen_ssy
------------修改引用对象--------------
final_01 = chenssy final_02 = zj final_03 = 46 final_04 = chenssy
final 修饰引用变量
备注：Java 会缓存所用曾经用过的字符串直接量。例如执行 String a = "java" ；语句之后，系统的字符串池中就会缓存一个字符串 "java" ；如果程序再次执行 String b = "java" ；，系统将会让 b 直接指向字符串池中的 "java" 字符串，因此 a==b 将会返回 true 。
final方法
父类的final方法是不能被子类所覆盖的，也就是说子类是不能够存在和父类一模一样的方法的。
public class Custom extends Person{
public void method1(){
System.out.println("Person's method1....");
}
// Cannot override the final method from person：子类不能覆盖父类的final方法
// public void method2(){
// System.out.println("Person's method2...");
// }
}
final 类
如果某个类用final修改，表明该类是最终类，它不希望也不允许其他来继承它。在程序设计中处于安全或者其他原因，我们不允许该类存在任何变化，也不希望它有子类，这个时候就可以使用final来修饰该类了。 对于final修饰的类来说，它的成员变量可以为final，也可以为非final。如果定义为final，那么final数据的规则同样适合它。而它的方法则会自动的加上final，因为final类是无法被继承，所以这个是默认的。