zoukankan      html  css  js  c++  java
  • Java Review (十二、面向对象----final 修饰符)

    @


    final关键宇可用于修饰类、方法和变量,被它修饰的类、方法和变量不可改变。


    final变量


    final 成员变量

    成员变量是随类初始化或对象初始化而初始化的 。

    • 当类初始化时,系统会为该类的类变量分配内存,并分配默认值 ;
    • 当创建对象时,系统会为该对象的实例变量分配内存,并分配默认值。

    对于 final 修饰的成员变量而言,一旦有了初始值,就不能被重新赋值,如果既没有在定义成员变量时指定初始值,也没有在初始化块、构造器中为成员变量指定初始值,那么这些成员变量的值将一直是系统默认分配的0、'u000'、false或 null ,这些成员变也就完全失去了存在的意义。 因此:

    Java语法规定 final 修饰的成员变量必须由程序员显式地指定初始值。

    归纳起来, final 修饰的类变量、实例变量能指定初始值的地方如下:

    • 类变量 : 必须在静态初始化块中指定初始值或声明该类变量时指定初始值,而且只能在两个地方的其中之一指定 。
    • 实例变量:必须在非静态初始化块、声明该实例变量或构造器中指定初始值 , 而且只能在三个地方的其中之一指定 。


    final成员变量实例

    public class FinalVariableTest{
        //定义成员变量时指定默认值,合法
       final int a = 6;
       //下面变量将在构造器或初始化块中分配初始值
        final String str;
       final int c;
       final static double d ;
       //既没有指定默认值 ,又没有在初始化块、构造器中指定初始值
        //下面定义的 ch 实例变量是不合法的
        // final char ch;
        //初始化块 ,可对没有指定默认值的实例变量指定初始值
       //;在初始化块中为实例变囊指定初始值,合法
       str = "He110";
      //定义 a 实例变量时已经指定了默认值
      //不能为 a 重新赋值,因此下面赋值语句非法
       // a = 9;
       
       //静态初始化块,可对没有指定默认值的类变量指定初始值
       static{
           //在静态初始化块中为类变量指定初始值,合法
           d = 5 . 6;
        }
        
         //构造器,可对既没有指定默认值, 又没有在初始化块中
         //指定初始值的实例变量指定初始值
      public FinalVariableTest (){
         //如果在初始化块中已经对 str 指定了初始值
        //那么在构造器中不能对 final 变量重新赋值,下面赋值语句非法
        // str = "java";
        c = 5;
        }
        
       public void changeFinal( ){
         //普通方法不能为 final 修饰的成员变量赋值
         //d= 1. 2;
        //不能在普通方法中为 final 成员变量指定初始值
       // ch = ' a ';
       }
       
    publ i c static void main(String[] args){
        FinalVariableTest ft = new FinalVariableTest();
        System.out . println(ft . a);
        System . out.println(ft.c) ;
        System . out.println(ft.d);
        }
    
    }
    

    final局部变量

    系统不会对局部变量进行初始化,局部变量必须由程序员显式初始化 。 因此:
    使用 final 修饰局部变量时 , 既可以在定义时指定默认值,也可以不指定默认值 。

    • 如果 final 修饰的局部变量在定义时没有指定默认值,则可以在后面代码中对该 final 变量赋初始值,但只能一次,不能重复赋值 ;
    • 如果 final 修饰的局部变量在定义时己经指定默认值,则后面代码中不能再对该变量赋值 。


    final修饰局部变量、形参实例

    pub1ic c1ass Fina1Loca1Variab1eTest{
      pub1ic void test( final int a){
       // 不能对 fina1 修饰的形参赋值,下面语句非法
       // a = 5;
       }
       
     pub1ic static void main(String[] args){
       //定义 fina1 局部变量时指定默认值,则 str 变量无法重新赋值
       final String str = "hello";
       //下面赋值语句非法
       // str = " Java";
       // 定义 fina1 局部变量时没有指定默认值,则 d 变量可被赋值一 次
      final double d;
      // 第一次赋初始值,成功
      d = 5.6;
      // 对 fina1 变量重复赋值 , 下面语句非法
      // d = 3.4;
      }
      
    }
    

    final 修饰基本类型变量和引用类型变量的区别

    • 当使用 final 修饰基本类型变量时,不能对基本类型变量重新赋值,因此基本类型变量不能被改变 。
    • 但对于引用类型变量而言 ,它保存的仅仅是一个引用, final 只保证这个引用类型变量所引用的地址不会改变,即 一直引用同一个对象,但这个对象完全可以发生改变 。


    final 修饰基本类型变量和引用类型变量的区别实例

    c1ass Person{
       private int age;
       pub1ic Person() {
       }
      // 有参数的构造器
      pub1ic Person(int age){
       this.age = age;
       //省略 age 的 setter 和 getter 方法
       //age 的 setter 和 getter 方法
      }
    }  
     
    pub1ic c1ass Fina1ReferenceTest{
      pub1ic static void main(String[] args){
        //fina1 修饰数组变量, iArr 是一个引用变量
       fina1 int[] iArr = (5 , 6, 12, 9) ;
       System.out.print1n(Arrays.toString(iArr));
       //对数组元素进行排序,合法
       Arrays.sort(iArr);
       System.out.println(Arrays.toString(iArr));
      //对数组元素赋值,合法
      iArr[2] = - 8 ;
      System.out.println(Arrays.toString (iArr) );
      // 下面语句对 iArr 重新赋值,非法
      // iArr = null;
      // final 修饰 Person 变量 , p 是一个引用变量
      final Persoηp =new Person(45) ;
      // 改变 Person 对象的 age 实例变量 ,合法
      p.setAge(23) ;
      System.out.println(p.getAge()) ;
      //下面语句对 p 重新赋值 ,非法
     // p = null;
    }
    
    }
     
    


    final方法

    之所以要使用final 方法,可能是出于对两方面理由的考虑。

    • 第一个是为方法“上锁”,防止任何子类改变它的本来含义。用final修饰的方法的行为在继承期间保持不变,而且不可被重写。
    • 采用final 方法的第二个理由是程序执行的效率——将一个方法设成 final 后,编译器就可以把对那个方法的所有调用都置入“嵌入”调用里。只要编译器发现一个final 方法调用,就会(编译器判断)忽略为执行方法调用机制而采取的常规代码插入方法(将变量压入堆栈;跳至方法代码并执行它;跳回来; 清除堆栈变量; 最后对返回值进行处理)。相反,它会用方法主体内实际代码的一个副本来替换方法调用。这样做可避免方法调用时的系统开销。
    
    public class Test{
        public final void changeName(){
           // 方法体
        }
    }
    
    

    对于一个 private 方法 , 因为它仅在当前类中可见, 其子类无法访问该方法 , 所以子类无法重写该方法一一如果子类中定义一个与父类 private 方法有相同方法名、相同形参列表、相同返回值类型 的方法 ,也不是方法重写,只是重新定义了 一个新方法。因此, 即使使用 final 修饰一个 private 访问权限的方法,依然可 以在其子类中定义与该方法具有相同方法名 、 相同形参列表、相同返回值类型的方法。

    public class PrivateFinalMethodTest{
      private final void test(){}
    }  
    class Sub extends PrivateFinalMethodTest{
      //下面的方法定义不会出现 问题
      public void test(){}
    }
    

    final 修饰的方法不能被重写 , 但是可以被重载 。


    final类

    final 修饰的类不可被继承。

    public final class Test {
       // 类体
    }
    

    不可变类

    不可变( immutable ) 类的意思是创建该类的实例后,该实例 的实例变量是不可改变的。 Java 提供的 8 个包装类和 java.lang.String 类都是不可变类 , 当创建它们的实例后 , 其实例的实例变量不可改变。

    Double d = new Double(6.5) ;
    String str =new String( "Hello");
    

    如果需要创建自定义的不可变类,可遵守如下规则 。

    • 使用 private 和 final 修饰符来修饰该类的成员变量。
    • 提供带参数构造器,用于根据传入参数来初始化类里的成员变量 。
    • 仅为该类的成员变量提供 getter 方法,不要为该类的成员变量提供 setter 方法 ,因为普通方法无法修改 final 修饰的成员变量。
    • 如果有必要,重写 Object 类的 hashCode()和 equals()方法, equals()方法根据关键成员变量来作为两个对象是否相等的标准,除此之外,还应该保证两个用 equals()方法判断为相等的对象的 hashCode()也相等。

    定义一个不可变的 Address 类,程序把 Address 类的 detail 和 postCode 成员变量都使用 private隐藏起来,并使用 final 修饰这两个成员变量 , 不允许其他方法修改这两个成员变量的值。

    public class Address{
       private final String detail ;
       private final String postCode ;
       // 在构造器里初始化两个实例变量
       public Address(){
        this .detail = "";
        this.postCode = "";
       }
       
      pub1ic Address(String detai1 , String postCode){
       this.deta = deta ;
       this.postCode = postCode ;
      }
       
      //仅为两个实例变量提供 getter 方法
      pub1ic String getDetai1(){
       return this.detai1 ;
      }
       
      pub1ic String getPostCode(){
       return this.postCode;
      }
       
      //重写 equa1s ()方法,判断两个对象是否相等
      pub1ic boo1ean equa1s(Object obj){
        if (this == obj ){
         return true ;
       }
       
       if(obj != nu11 && obj.getC1ass() == Address.c1ass{
        Address ad = (Address)obj;
        //当 detai1 和 postCode 相等时 , 可认为两个 Address 对象相等
        if(this . getDeta 工 1() .equa1s (ad . getDetai1())&& this.getPostCode (} . equa1s(ad.getPostCode())){
            return true ;
        }
       } 
      return fa1se ;
     } 
     
     pub1ic int hashCode(){
       return detai1.hashCode() + postCode.hashCode()*31;
     }
    
    }  
    




    参考:
    【1】:《疯狂Java讲义》
    【2】:https://www.runoob.com/java/java-modifier-types.html
    【3】:《Java编程思想》

  • 相关阅读:
    Mac上的USB存储设备使用痕迹在新版操作系统有所变化
    Beware of the encrypted VM
    A barrier for Mobile Forensics
    Second Space could let suspect play two different roles easily
    Take advantage of Checkra1n to Jailbreak iDevice for App analysis
    Find out "Who" and "Where"
    Where is the clone one and how to extract it?
    Downgrade extraction on phones running Android 7/8/9
    高版本安卓手机的取证未来
    How to extract WeChat chat messages from a smartphone running Android 7.x or above
  • 原文地址:https://www.cnblogs.com/three-fighter/p/13052616.html
Copyright © 2011-2022 走看看