java.final关键字、权限修饰符、内部类

final关键字

final关键字用于修饰不可改变的内容

final：不可改变。可以用于修饰类、方法和变量

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

修饰类

final class 类名{
}

修饰方法

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

修饰变量

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

public class Demo01 {    
    public static void main(String[] args) { 
        //声明变量，使用final修饰        
        final int a;        
        //第一次赋值        
        a = 10;       
        //第二次赋值       
        //a = 20; //报错，不可重新赋值        
        
        //声明变量，直接赋值，使用final修饰        
        final int b = 10;        
        //第二次赋值        
        b = 20;//报错，不可重复赋值    
    }
}

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

public class Demo02 {
    public static void main(String[] args) {
        //创建user对象        
        final User u = new User();        
        //创建另一个User对象        
        //u = new User();  // 报错，指向了新对象，地址值改变        
        //调用setName方法        
        u.setName("leesin");    
    }
}

3、成员变量
成员变量设计到初始化问题，初始化方式有两种，只能二选一

• 显示初始化

public class User{
    final String USERNAME = "leesin"
    private int age;
}

• 构造方法初始化

public class User{
    final String USERNAME;
    private int age;
    public User(String username, int age){
        this.USERNAME = username;
        this.age = age
    }
}

被final修饰的常量名称，一般都有书写规范，所有的字母都大写

权限修饰符

概述

在java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限

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

	public	protected	default（默认不写）	private
同一类中	√	√	√	√
同一包中（子类与无关类）	√	√	√
不同包的子类	√	√
不同包中的无关类	√

public具有最大权限。private则最小权限
编写代码时，如果没有特殊考虑，建议这样使用权限：

• 成员变量使用private，隐藏细节
• 构造方法使用public，方便创建对象
• 成员方法使用public，方便调用方法

内部类

将一个类A定义在另一个类B里面，里面的那个类A就称为内部类，B则成为外部类。

定义格式：

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

在描述事物时，若一个事物内部包含其他事物，就可以使用内部类，比如，汽车car中包含发动机类Engine，这是Engine就可以使用内部类来描述，定义在成员位置

class Car{ //外部类
    class Engine{ //内部类
    
    }
}

访问特点

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

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

访问演示，代码如下：
定义类

public class Person {
    private boolean live = true;    
    class Heart {
        public void jump(){
            //访问外部类成员            
            if (live){
                System.out.println("心脏在跳动");
                }else {
                    System.out.println("心脏不跳了"); 
                    }        
                }    
           }    
           
    public boolean isLive(){
        return live;    
    }   
            
    public void setLive(boolean live){ 
        this.live = live;    
    }
 }

测试类：

public class Demo {
    public static void main(String[] args) {
        // 创建外部类对象
        Person p = new Person();    
        //创建内部类对象
        Person.Heart heart = p.new Heart();  
        
        //调用内部类方法
        heart.jump();  
        //调用
        p.setLive(false);        
        heart.jump();    
    }
}

输出结果：
心脏在跳动
心脏不跳了

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

比如，Person$Heart.class

匿名内部类

是内部类的简化写法。他的本职是一个带具体实现的 父类或父类接口的 匿名的 子类对象。
开发中，最常用的内部类就是匿名内部类。以接口举例，当你使用一个接口时，似乎做得如下几步操作

• 定义子类
  

• 重写接口中的方法
  

• 创建子类对象
  

• 调用重写后的方法
  

最终目的只是为了调用方法，匿名内部类就是将四步合一    

格式：

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

使用方式

以接口为例，匿名内部类的使用，代码如下：
定义接口：

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

创建匿名内部类，并调用：

public class InnerDemo{
    public static void main (String [] args){
        /*
        1、等号右边：是匿名内部类，定义并创建该接口的子类对象
        2、等号左边：是多态赋值，接口类型引用指向子类对象
        */
        FlyAble f = new FlyAble(){
            public void fly(){
                System.out.println("起飞了")；
             }
         };
        //调用fly方法，执行重写后的方法
        f.fly();
    }
}

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

public class InnerDemo2{
    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 InnerDemo3{
    public static void main(String[] args){
        /*
        创建匿名内部类，直接传递给showFly(FlyAble f)
        */
        showFly(new FlyAble(){
            public void sly(){
                System.out.println("起飞了);
            }
        });
    }
    public static void showFly(FlyAble f){
        f.fly();
    }
}