Java：内部类与final关键字解析

最新推荐文章于 2021-03-11 15:35:49 发布

JinxLin

最新推荐文章于 2021-03-11 15:35:49 发布

阅读量971

点赞数

文章标签： java 类 javase

本文链接：https://blog.csdn.net/JinxLin/article/details/107620716

版权

final关键字概念

final关键字：代表最终的、不可改变的。
常见的四种用法：

1.可以用来修饰一个类
2.可以用来修饰一个方法
3.可以用来修饰一个局部变量
4.可以用来修饰一个成员变量

如果final修饰一个类，那么格式：

public final class 类名称 {
```
  //...
```
}
含义：当前这个类不能有任何的子类。
注意事项：一个类如果是被final关键字修饰后，那么所有的成员方法都无法被重写。

如果final修饰一个方法，格式：

public final void 方法名(){}
含义：当方法被final修饰时，这个方法就是最终方法，不能被覆盖重写。
注意事项：
对于类、方法来说，abstract关键字和final关键字不能同时使用，因为相互矛盾。

final修饰局部变量赋值后，变量不可再次改变

final修饰成员变量后，这个变量也是不可变的。

1.由于成员变量具有默认值，所以用了final之后必须手动赋值，不会再给默认值了。
2.对于final的成员变量，要么使用直接赋值，要么通过构造方法赋值。
3.必须保证类中的所有重载的构造方法，语句都对final的成员变量进行赋值。

public class Demo01 {
   public static void main(String[] args) {
       int num1 = 10;
       num1 = 20;
       System.out.println(num1);
       final int num2 = 100;//final修饰局部变量赋值后，不可再次改变
//        num2 = 200;
       //对于基本类型来说，不可变是指变量的数据不可改变
       //对于引用类型来说，不可变是指变量的地址值不可改变。
       final Student stu = new Student("小白");
//        stu = new Student("小黑");地址值不能改变
       //但是值可以改变
       System.out.println(stu.getName());
       stu.setName("小黑");
       System.out.println(stu.getName());
   }
}
package demo;

public class Student {
   private String name;

   public Student() {
   }

   public Student(String name) {
       this.name = name;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }
}

内部类

一个事物包含另一个事物，那么这就是一个类内部包含另一个类。
例如身体和心脏的关系。
内部类分为：
1.成员内部类
2.局部内部类(包含匿名内部类)

成员内部类

一个事物包含另一个事物，那么这就是一个类内部包含另一个类。
例如身体和心脏的关系。
内部类分为：
1.成员内部类
2.局部内部类(包含匿名内部类)

成员内部类的定义格式：
修饰符 class 外部类名{
修饰符 class 内部类名{
//…
}
//…
}
注意：内用外，随意访问，外用内，需要使用内部对象。
成员内部类的两种使用方法：
1.间接方式：在外部类的方法中使用内部类(创建对象调用),然后在main中只创建外部类的对象并调用
2.直接方式：外部类名.内部类名对象名 = new 外部类名().new内部类名();
对于成员内部类与外部类中的成员变量名重复的情况
在内部类方法中引用System.out.println(Outer.this.num);
Outer关键字

成员内部类的两种使用方法
public class Demo01InClass {
    public static void main(String[] args) {
        Body body = new Body();
        body.bodyMethod();
        Body.Heart jj = new Body().new Heart();
        jj.heartMethod();
    }
}
package demo02;
public class Body {
    public class Heart{
        public void heartMethod(){
            System.out.println("内部类方法执行");
            System.out.println(num);//可以从内部类中访问到外部类中的成员变量。
        }
    }
    //外部类成员变量
    private int num = 10;
    //外部类方法
    public void bodyMethod(){
        System.out.println("外部类方法执行");
        Heart heart = new Heart();
        heart.heartMethod();
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
}
package demo02;
内部类中的变量重名现象
public class Outer {
    int num = 10;
    public class Inter{
        int num = 20;
        public void method(){
            int num = 30;
            System.out.println(num);//30
            System.out.println(this.num);//20
            //内部类取外部类的同名成员变量值
            System.out.println(Outer.this.num);//10
        }
    }
}

局部内部类

如果一个类是定义在一个方法内部的，那么这就是一个局部内部类。
“局部”：只有当前所属的方法才能使用它，出了这个方法外面就不能用了。
定义格式：

修饰符 class 外部类名称{

  修饰符 返回值 外部类方法名(){

```
      class 局部内部类名称{
```
```
  }
```
}
}

局部内部类，如果希望访问所在方法的局部变量，那么这个局部变量必须是(有效final的)
备注：从java8开始，只要局部变量事实不变，那么final关键字可以省略。
原因：

1.new出来的对象在堆内存当中。
2.局部变量是跟着方法走的，在栈内存中。
3.方法运行结束之后，立刻出栈，局部变量就会立刻消失。
4.但是new出来的对象会在堆当中持续存在，直到垃圾回收消失。

public class Out {
    public void outMethod(){
        class In{
            int num = 20;
            public void inMethod(){
                System.out.println(num);
            }
        }
        In in = new In();
        in.inMethod();
    }
}