Java—final关键字、权限修饰符、内部类

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

• final关键字使用方法
• • 修饰类
  • 修饰方法
  • 修饰变量
• 权限修饰符
• 内部类

final关键字使用方法

学习了继承以后，我们知道，我们的子类可以在父类基础的上修改父类方法内容，方法的重写我们能不能随意继承api中的类，明显不能去修改人家的，为了避免我们人为的去随意改写我们的api中的类，我们java提供了一个关键字就是我们的final，用来修饰不可修改的内容。
final:不可以改变，可修饰我们的类，方法和变量。
类：被修饰的类，不能被继承
方法：被修的方法，不能被重写
变量：被修饰的变量，不能被重新赋值

修饰类

final class 类名{
}
在我们的api中的有哪些，我们去看看： public final class String，public final class Math等等
在api中的很多我们学过的类，都是被final修饰的，目的就是提供给我们使用，但是不让我们改变其内容。

修饰方法

修饰符 final 返回值类型 方法名(参数列表){
//方法体
}
重写被final修饰的方法，编译会报错。

修饰变量

局部变量----基本类型

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

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

public class Demo {
    public static void main(String[] args) {
        final  int c=0;
        for (int i = 0; i <10; i++) {
        //多次赋值报错
            c=i;
            System.out.println(c);
        }
    }
}

public class Demo {
    public static void main(String[] args) {
        for (int i = 0; i <10; i++) {
             final  int c=i;
            System.out.println(c);
        }
    }
}

局部变量—引用类型

public class Demo {
    public static void main(String[] args) {
        final Mouse mous=new Mouse();
        //mous =new Mouse();//多次赋值地址，所以报错
        mous.name="zhangsan";
        mous.name="zhangsan";
        //可以修改里面的内容，但是不可以修改我们的对象的地址
        }
    }

成员变量

成员变量初始化，有两种，只能二选一

public class Mouse {
        final String name="wang";
        private  int age;
    }

public class Mouse {
        final String name;
        int age;
        public Mouse(String name,int age0{
        this.name=name;//初始化方式
        this.age=age;
    }

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

权限修饰符

在java中提供了四个权限修饰符，使用不同的权限修饰符在修饰时候，被修饰的内容会不有不同的权限。
Public 公共的
Protected：受保护
Default：默认的权限
Private：私有的

内部类

什么叫内容类：
在一个类中定义了另外一个类，在b类中的我又定义了一个a类这个时候，我们b类就是一个外部类，a类就是一个内容

成员内部类

class 外部类{
//成员内部类
Class 内部类{
}
}
在描述事物的时候，如果一个事物内部包含了另外一个事物，就可以使用我们的内部类，比如：汽车类Car中的发动类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 test01 {
    public static void main(String[] args) {
        PERSON.Heart p=new PERSON().new Heart();
        p.jump();
    }
}

匿名内部类：

public class test01 {
    public static void main(String[] args) {
       Usb usb=new Usb() {
           @Override
           public void open() {
               
           }
           @Override
           public void close() {

           }
       };
       usb.close();
       usb.open();
    }
}

本文地址：https://blog.csdn.net/weixin_44051191/article/details/109813805