JAVA11——final、权限、内部类

final

• 不可改变。可以用于修饰类、方法和变量。
  • 类：被修饰的类不能被继承
  • 方法：被修饰的方法不能被重写
  • 变量：被修饰的变量不能被重新赋值

格式：

• // 修饰类
  
  final class 类名 {
      //...
  }
  
  
  // 修饰方法
  修饰符 final 返回值类型 方法名(参数列表) {};
  

• 局部变量——基本类型

• public class FinalDemo1 {
      public static void main(String[] args) {
      // 声明变量，使用final修饰
      final int a;
      // 第一次赋值
      a = 10;
      // 第二次赋值
      a = 20; // 报错,不可重新赋值
      // 声明变量，直接赋值，使用final修饰
      final int b = 10;
      // 第二次赋值
      b = 20; // 报错,不可重新赋值
      }
  }
  
  //报错
  final int c = 0;
      for (int i = 0; i < 10; i++) {
      c = i;
      System.out.println(c);
  }
  
  //不报错，因为每次都重新定义变量
  for (int i = 0; i < 10; i++) {
      final int c = i;
      System.out.println(c);
  }

• 局部变量——引用类型

• public class FinalDemo2 {
      public static void main(String[] args) {
      // 创建 User 对象
      final User u = new User();
      // 创建 另一个 User对象
      u = new User(); // 报错，指向了新的对象，地址值改变。
      // 调用setName方法
      u.setName("张三"); // 可以修改
      }
  }

• 成员变量

• // 显示初始化
  public class User {
      final String USERNAME = "张三";
      private int age;
  }
  
  // 构造方法初始化
  public class User {
      final String USERNAME ;
      private int age;
  
      public User(String username, int age) {
      this.USERNAME = username;
      this.age = age;
      }
  }

   

---

权限修饰符

• public 公共的
• protected 受保护的
• default 默认的
• private 私有的

不用权限的访问能力

	public	protected	default(空)	private
同一个类中	√	√	√	√
同一个包中	√	√	√
不同包的子类	√	√
不同包中的无关类	√

 

 

 

 

 

 

• 编写代码时，如果没有特殊考虑，建议：
  1. 成员变量使用private，隐藏细节
  2. 成员方法使用public，方便调用
  3. 构造方法使用public，方便创建对象

---

 

内部类

• 将一个类A定义在另一个类B中，那么类A就是类B的内部类，B则成为外部类

成员内部类

• 定义在类中方法外的类

• class 外部类 {
      class 内部类{
      }
  }

•  访问特点：
  1. 内部类可以直接访问外部类的成员，包括私有成员
  2. 外部类要访问内部类的成员，必须创建一个内部类对象

• 外部类名.内部类名 对象名 = new 外部类型().new 内部类型()；

• 内部类仍然是一个独立的类，编译之后内部类会被编译成独立的.class文件，但前面会被冠以外部类的类名和$符号。如Person$Heart.class

匿名内部类

• 内部类的简化写法，本质是一个带具体实现的父类或父接口的匿名的子类对象。
• 前提：匿名内部类必须继承一个父类或者一个父接口

• new 父类名称或父接口名称{
      // 方法重写
      @Override
      public void mothod() {}
  };

使用方式：

• // 将匿名内部类作为参数传递
  public class InnerDemo {
      public static void main(String[] args) {
      /*
      1.等号右边:定义并创建该接口的子类对象
      2.等号左边:是多态,接口类型引用指向子类对象
      */
      FlyAble f = new FlyAble(){
          public void fly() {
          System.out.println("我飞了~~~");
          }
      };
      // 将f传递给showFly方法中
      showFly(f);
      }
      public static void showFly(FlyAble f) {
      f.fly();
      }
  }

• // 将创建匿名匿名内部类和传递参数合起来
  
  public class InnerDemo {
      public static void main(String[] args) {
      /*
      创建匿名内部类,直接传递给showFly(FlyAble f)
      */
          showFly( new FlyAble(){
              public void fly() {
                  System.out.println("我飞了~~~");
              }
          });
      }
      public static void showFly(FlyAble f) {
      f.fly();
      }
  }