Java final 关键字和instanceof 关键字

小咪咪 2024-03-17 21:38 100阅读 0赞

## Java final 关键字 ##

在Java中，final关键字用于表示常量。它可以与变量，方法和类一起使用。

任何实体（变量，方法或类）一旦被声明final后，只能分配一次。也就是：

>  *  final变量不能用另一个值重新初始化
>  *  final方法不能被重写
>  *  final类不能被继承

### 1. Java final变量 ###

在Java中，我们无法更改final变量的值。例如：

class Main {
      public static void main(String[] args) {
    
        //创建一个final变量
        final int AGE = 32;
    
        //尝试更改final变量
        AGE = 45;
        System.out.println("Age: " + AGE);
      }
    }

在上述程序中，我们创建了一个名为age的final变量。并且我们尝试更改final变量的值。

运行程序时，将出现以下错误消息，提示编译错误。

cannot assign a value to final variable AGE
        AGE = 45;

**注意**：建议使用大写形式在Java中声明final变量。

### 2. Java final方法 ###

在Java中，该final方法不能被子类覆盖。例如：

class FinalDemo {
        //创建final方法
        public final void display() {
          System.out.println("这是Final方法。");
        }
    }
    
    class Main extends FinalDemo {
      //尝试重写final方法
      public final void display() {
        System.out.println("Final方法被覆盖。");
      }
    
      public static void main(String[] args) {
        Main obj = new Main();
        obj.display();
      }
    }

在上面的示例中，我们创建了一个在FinalDemo类内部命名display()的final方法。在这里，Main类继承了FinalDemo类。

我们试图覆盖Main该类中的final方法。运行程序时，将出现以下错误消息，提示编译错误。

display() in Main cannot override display() in FinalDemo
      public final void display() {
                        ^
      overridden method is final

### 3. Java final类 ###

在Java中，final类不能被另一个类继承。例如：

final class FinalClass {
        //创建final方法
        public void display() {
          System.out.println("这是final方法。");
        }
    }
    
    class Main extends FinalClass {
      //尝试重写final方法
      public  void display() {
        System.out.println("重写final方法");
      }
    
      public static void main(String[] args) {
        Main obj = new Main();
        obj.display();
      }
    }

在上面的示例中，我们创建了一个名为FinalClass的final类。在这里，我们试图通过Main类继承final类。

运行程序时，将出现以下错误消息，提示编译错误。

cannot inherit from final FinalClass
    class Main extends FinalClass {

## Java instanceof 关键字 ##

在Java中，instanceof关键字是二进制运算符。它用于检查对象是否是特定类的实例。

运算符还检查对象是否是实现接口的类的实例（将在本教程后面讨论）。

instanceof的语法为：

result = objectName instanceof className;

instanceof运算符的左操作数是对象名，右操作数是类名。如果对象是类的实例，则结果为true；如果不是，则为false。

#### 示例1：instanceof ####

class Main {
        public static void main (String[] args) {
            String name = "nhooo";
            Integer age = 22;
    
            System.out.println("name是String的实例吗: "+ (name instanceof String));
            System.out.println("age是Integer的实例吗: "+ (age instanceof Integer));
        }
    }

**输出**：

>     name是String的实例吗: true
>     age是Integer的实例吗: true

在上面的示例中，我们创建了一个String类型的对象name和另一个Integer类型的对象age。 然后，我们使用instanceof运算符检查名称是否为String类型以及age是否为Integer类型。

### instanceof 和 继承 ###

在继承的情况下，instanceof运算符用于检查子类的对象是否也是超类的实例。

#### 示例2：继承中的instanceof ####

class Animal {
    }
    
    //Dog类是Animal的子类
    class Dog extends Animal {
    }
    
    class Main {
        public static void main(String[] args){
            Dog d1 = new Dog();
    
            //检查d1是否是Dog的对象
            System.out.println("d1是Dog的实例吗: "+ (d1 instanceof Dog));
           
            //检查d1是否是Animal的对象
            System.out.println("d1是Animal的实例吗: "+ (d1 instanceof Animal));
        }
    }

**输出**：

>     d1是Dog的实例吗: true
>     d1是Animal的实例吗: true

在上面的示例中，d1是Dog和Animal类的实例。 因此，d1 instanceof Dog 和 d1 instanceof Animal 都为true。

### Object类 ###

在Java中，所有类都继承自Object类，继承Object类不使用extends关键字。这种继承在Java中隐式发生。

#### 示例3：Object类 ####

class Animal {
    }
    
    class Dog {
    }
    
    class Cat {
    }
    class Main {
        public static void main(String[] args) {
            Dog d1 = new Dog();
            Animal a1 = new Animal();
            Cat c1 = new Cat();
    
            System.out.println("d1是Object类的实例吗: "+ (d1 instanceof Object));
            System.out.println("a1是Object类的实例吗: "+ (a1 instanceof Object));   
            System.out.println("c1是Object类的实例吗: "+ (c1 instanceof Object));
        }
    }

**输出**：

>     d1是Object类的实例吗: true
>     a1是Object类的实例吗: true
>     c1是Object类的实例吗: true

在上面的实例中，我们分别创建了类Animal、Dog和Cat的对象a1、d1和c1。我们已经使用instanceof操作符来检查这些对象a1, d1, c1是否也是Object类的对象。输出结果都为true（真）。

这是因为Object类是java.lang包中定义的根类。 所有其他类都是在Java中形成层次结构的Object类的子类。

### 对象向上转型和向下转型 ###

在Java中，子类的对象可以视为父类的对象。这称为向上转型。**通俗地讲即是将子类对象转为父类对象。此处父类对象可以是接口。**

Java编译器自动执行向上转型。

#### 示例4：对象向上转型 ####

class Animal {
        public void displayInfo() {
            System.out.println("I am an animal.");
        }
    }
    
    class Dog extends Animal {
    }
    
    class Main {
        public static void main(String[] args) {
            Dog d1 = new Dog();
            Animal a1 = d1;
            a1.displayInfo();
        }
    }

**输出**：

>     I am an animal.

在上面的实例中，我们创建了Dog类的对象d1。我们使用d1对象来创建Animal类的对象a1。这在Java中称为向上转型。

该代码执行没有任何问题。这是因为向上转型是由Java编译器自动完成的。

**向下转型是向上转型的相反过程，也就是与向上转型相反，即是把父类对象转为子类对象。**

在向下转型的情况下，父类的对象被视为子类的对象。我们必须在Java中显式地指示编译器向下转型。

#### 示例5：对象向下转型的问题 ####

class Animal {
    }
    
    class Dog extends Animal {
       public void displayInfo() {
           System.out.println("I am a dog.");
       }
    }
    
    class Main {
       public static void main(String[] args) {
           Animal a1 = new Animal();
           Dog d1 = (Dog)a1; // 向下类型转换
     
           d1.displayInfo();
       }
    }

运行程序时，将获得名为的异常ClassCastException。让我们看看这里发生了什么。

在这里，我们创建了一个父类Animal的对象a1。然后我们尝试将a1对象强制转换为子类Dog的对象d1。

这引起了问题。 这是因为父类Animal的a1对象也可能引用其他子类。 如果我们与Dog一起创建了另一个子类Cat； 动物可能是猫，也可能是狗，引起歧义。

为了解决这个问题，我们可以使用instanceof运算符。这是如何做：

#### 示例6：使用instanceof解决向下类型转换 ####

class Animal {
    }
    
    class Dog extends Animal {
      public void displayInfo() {
         System.out.println("I am a dog");
      }
    }
    
    class Main {
      public static void main(String[] args) {
        Dog d1 = new Dog();
        Animal a1 = d1;    // 向上转型
    
        if (a1 instanceof Dog){
           Dog d2 = (Dog)a1;    // 向下转型
           d2.displayInfo();
        }
      }
    }

**输出**：

>     I am a dog

在上面的示例中，我们使用instanceof运算符检查a1对象是否为Dog类的实例。仅当表达式a1 instanceof Dog为true时才进行向下类型转换。

### 接口 和 instanceof ###

instanceof运算符还用于检查类的对象是否也是实现该类的接口的实例。

#### 示例7：接口中的instanceof ####

interface Animal {
    }
    
    class Dog implements Animal {
    }
    
    class Main {
       public static void main(String[] args) {
          Dog d1 = new Dog();
          System.out.println("d1对象是Animal的实例吗: "+(d1 instanceof Animal));
       }
    }

**输出**：

>     d1对象是Animal的实例吗: true

在上面的示例中，我们创建了一个Dog实现Animal接口的类。

然后，创建Dog类的对象d1。我们已经使用instanceof运算符来检查d1对象是否也是Animal接口的实例。