eightDay_java final与内部类

1、final关键字

final:不可变的,最终的 常见的四种用法：

1> 用来修饰一个类

2> 用来修饰一个方法

3> 用来修饰局部变量

4> 用来修饰成员变量

2、修饰类

*final 用来修饰一个类的时候

格式：public final class 类名称(){ .... }

含义：当前这个类不能有任何子类(太监类，可以有父类但不能有子类)

3、修饰方法

当用final修饰一个方法的时候，这个方法是最终类，不能被覆盖重写

格式：public final 返回值类型 方法名称（参数列表）{...}

注意事项：abstract与final不能同时写，二者互相矛盾。

4、修饰局部变量

一次赋值，终生不变 对于基本变量，不可变的是变量里的数据 对于引用变量，不可变的是变量里的地址值

public static void main(String[] args) {
    final int num;
    
    num=90;//或者直接 final int num=90;
    
    //num=80;//错误写法 num变量中的数据不可变
    
    final StudentFinal stu =new StudentFinal("张三");
    
    System.out.println(stu.getName());//张三
    
   // stu=new StudentFinal("lisi");//错误，stu里的地址值不可变 但是保存的”张三“数据可以变
​
}

5、修饰成员变量

一次赋值，终生不变

但是成员变量具有默认值，故一定要手动先赋值

赋值方法 直接赋值 private final String name="张三";

通过构造方法进行赋值，然后把set方法去掉

final String name;
public StudentFinal(String name) {
    this.name = name;
}
public StudentFinal() {
    name="李四";
}

6、权限修饰符作用范围

public >protected>(default)>private

• 同一个类(A类)中，无论哪种修饰符修饰成员变量都可被访问

• A类与B类在同一个包中，除private修饰的变量或方法不能被访问，其他都可

• A类与B类不在同一包中，B类继承A类，除private,default,其余都可

• A类与B类不在同一个包中，无继承关系，除public修饰的可被访问，其余不可。

7、内部类

一个类包含另一个类，如：身体与心脏 分类：

1>、成员内部类

2>、局部内部类（包含匿名内部类）

8、成员内部类

格式： 修饰符 class 外部类名称{

修饰符 class 内部类名称{...}

...

}

//外部类
public class body {
    //内部类
    public  class  head{
        //内部类方法
        public void beat() {
            System.out.println("心脏跳动！");
            //访问外部类私有变量
            System.out.println(num);
        }
    }
    //外部类变量
    private int num;
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }
    //外部类方法
    public void method(){
        System.out.println("外部类方法！");
    }
}

9、访问内部类方式、

1>、间接方式，在外部类方法中使用内部类，然后main调用外部类方法

body mybody=new body(); mybody.method();

2>、直接调用 外部类名称.内部类名称 对象名=new 外部类名称().new 内部类名称();

body.head myhead=new body().new head();

10、内部类的同名变量的访问

public void beat() {
    int num=10;
    System.out.println("心脏跳动！");
    //访问外部类私有变量
    System.out.println(num);//访问本方法的num
    System.out.println(this.num);//访问内部类的num
    System.out.println(body.this.num);//访问外部类的num
}

11、局部内部类

格式：
权限修饰符 class 外部类名称{
    权限修饰符 返回值类型 外部类方法名称(){
        class 内部类名称{
            ....
            }
        内部类名称  内部类对象=new 内部类名称();
        内部类对象.内部类方法/变量;
     }
 }
 使用方法：
 创建外部类对象.外部类方法名称

//外部类
public class Outer {
    //外部类方法
    public void method(){
        //局部类定义
        class inner{
            //局部类方法
            public void inMethod(){
                System.out.println("内部类方法");
            }
        }
        //创建局部类对象
        inner in=new inner();
        in.inMethod();
    }
}

注意事项： 定义一个类的时候，权限修饰符规则

1> 外部类：可以写 public/(default)

2> 成员内部类：可以写 public/protected/(default)/private

3> 局部内部类：什么都不写

12、局部类访问所在方法的局部变量

//局部变量
int num=100;//final int num=100;
//局部类定义
class inner{
    //局部类方法
    public void inMethod(){
        System.out.println("内部类方法"+num);
    }
}

局部内部类，如果希望访问所在方法的局部变量，则局部变量一定是有效的final

备注：从Java8开始，只要局部变量不变，那么final可以省略

原因：new出来的对象是存在堆里面的，成员方法是在栈里面的，成员方法的局部变量跟随着方法，用完即灭。

而在堆里面的对象要等待垃圾回收机制处理，生命周期比变量长，故当变量消失，对象依旧需要变量的值，所以变量必须是final的。

13、匿名内部类

如果接口的实现类只需要写一次，则可以使用匿名内部类

格式： 接口名称 对象名 =new 接口名称(){ //重写所有抽象类 };

代码：

//接口MyInterface与MyInterfaceImpl实现类

public interface MyInterface {
    void method();//抽象方法
}

public class MyInterfaceImpl {
    public static void main(String[] args) {
        MyInterface obj=new MyInterface() {
            @Override
            public void method() {
                System.out.println("匿名内部类");
            }
        };
    }
}