final

final 不可改变，可以用于修饰类、方法、变量

类：被修饰的类，不能被继承
方法：被修饰的方法，不能被重写
变量：被修饰的变量、不能被重新赋值

使用

修饰类
格式如下：

final class 类名 {
}

像 String、Math、Scanner这些类都是被final修饰，目的是供我们呢使用，而不让我们修改。

修饰方法
格式：

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

如果重写final修饰的方法，编译会报错

修饰变量

局部变量--基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能再改

 public static void main(String[] args) {
        // 声明一个变量，被final修饰
        final int a;
        a = 10;
        // a = 20; 不可以

        final  int b = 20;
        // 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);
}

写法一会报错，写法二会通过编译，因为每次循环，都是一个新的c

局部变量--引用类型
引用类型的局部变量被final修饰后只能指向一个对象，但是不影响对象内部的成员变量值的修改。

public static void main(String[] args) {
final User u = new User();
//        User u = new User();
    System.out.println(u);
//        u = new User();
    System.out.println(u);
 // u = new User(); 报错指向了新的对象，地址值改变
    u.userName = "张三"; // 可以对象内部修改成员变量
    System.out.println(u.userName);
}
}

成员变量
成员变量涉及到初始化问题，初始化有两种，只能选一个

显示初始化

public class User {
    // 显示初始化
    final String USERNAME = "张三"; 
}

被final修饰的常量名称，一般字母都大写
构造方法初始化

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 具有最大权限，private 最小权限
建议使用权限：
成员变量使用private ，隐藏细节
构造方法使用public，方便创建对象
成员方法使用public，方便调用

不加权限修饰符，其访问能力与default相同

内部类

将类A定义在另一个类B中，里面的类A就是内部类， B是外部类

成员内部类：定义在类中方法外的类
格式：

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

在描述事物时，若一个事物内部还包含其他事物，就可以使用内部类这种结构，比如Car中包含Engine， Engine就可以使用内部类来描述

class Car{
    class Engine{
}
}

访问特点

内部类可以直接访问外部类的成员，包括私有成员。
外部类要访问内部类成员，必须要建立内部类对象
创建内部类对象的格式

外部类名.内部类名 对象名  = new 外部类型（）.new 内部类型（）；

匿名内部类

匿名内部类: 是内部类的简化写法，它本质是一个带具体实现的父类或者父接口的匿名子类对象。开发中，最常用到的内部类就是匿名内部类
以接口为例，当你使用一个接口时，似乎需要如下几步：

定义子类
重写接口中所有的方法
创建子类对象
调用重写后的方法
我们的目的是调用方法，那能否简化一下呢？将四个步骤合为一步呢？
匿名内部类就可以实现
前提匿名内部类必须继承一个父类或者实现一个父接口
格式

new 父类名或父接口（）{
    // 方法重写
  @  Override
  public void method(){
    // 执行语句
}
}

public abstract class FlyAble {
    public abstract  void fly();
}

public class InnerDemo {
    public static void main(String[] args) {
        /**
         * 等号左边：是多态赋值， （抽象类）接口类型引用指向子类对象
         * 等号右边：是匿名内部类， 定义并创建该接口的子类对象
         */

        FlyAble f  =  new FlyAble() {
            @Override
            public void fly() {
                System.out.println("嗷嗷飞");
            }
        };
        System.out.println(f);
        f.fly();
    }
}

通常在方法的形参是接口或者抽象的时候，也可以讲匿名内部类作为参数传递

public class InnerDemo {
    public static void main(String[] args) {

        /**
         * 等号左边：是多态赋值， （抽象类）接口类型引用指向子类对象
         * 等号右边：是匿名内部类， 定义并创建该接口的子类对象
         */

        FlyAble f  =  new FlyAble() {
            @Override
            public void fly() {
                System.out.println("嗷嗷飞");
            }
        };
        System.out.println(f);

        showFly(f);

    }

    public static void showFly(FlyAble flyAble){
        flyAble.fly();
    }

}

简化

package com.neusoft.day11.InnerClassDemo2;

/**
 * @author Eric Lee
 * @date 2020/7/25 11:14
 */
public class InnerDemo2 {
    public static void main(String[] args) {

        showFly(new FlyAble() {
            @Override
            public void fly() {
                System.out.println("嗷嗷飞");
            }
        });

    }

    public static void showFly(FlyAble flyAble){
        flyAble.fly();
    }
}