【Java入门】final关键字、static关键字、内部类的认识

TorlesseLiang

已于 2023-06-27 00:05:07 修改

阅读量663

点赞数

文章标签： java 开发语言

于 2023-06-27 00:01:34 首次发布

本文链接：https://blog.csdn.net/NeverFG/article/details/131404841

版权

前言：

final关键字是Java中的一个修饰符，用于表示某个变量、方法或者类不能被修改。final可以用于修饰类、方法和变量(局部变量，成员变量)。被final所修饰的类不能被继承，被final所修饰的方法不能被重写，被final所修饰的变量，不能被重新赋值。
static关键字是Java中的一个关键字，用于表示某个对象属于类本身而不是属于类的实例。在Java中，所有的静态字段和静态方法都是属于类本身的，而不是属于类的实例。静态字段和静态方法可以直接通过类名来访问，而不需要创建类的实例。
内部类是指在一个类中定义的另一个类。内部类可以访问外部类的私有成员，但是不能访问外部类的公有成员。内部类分为四种类型：普通内部类、匿名内部类、局部内部类和成员内部类.

接下来分别学习final关键字、static关键字、内部类，三者的特点和用法。

final关键字的使用

final：不可改变的，最终的。可以用于修饰类、方法和变量（局部变量，成员变量）。

被修饰的类不能被继承
被修饰的方法不能被重写
被修饰的变量，不能被重新赋值
1、被final所修饰的局部变量只能够进行一次赋值操作，随后不能改变
2、引用类型的局部变量被final修饰后，只能指向同一个对象，地址值不能发生改变
3、final对成员变量的初始化的两种方法

class User{
    //第一种初始化数变量方法
    final String NAME="张三";

    /*第二种初始化则在构造函数里面
    final String NAME;
    public User(String name){
        this.NAME = name;
    }*/

    public void run(){
        System.out.println("run");
    }
}

public class FinalUsing {
    public static void main(String[] args) {
        final int a = 10;
        //a=20; // 报错,被final修饰的变量不能进行二次赋值
        System.out.println(a);

        //引用类型的局部变量被final修饰后，只能指向同一个对象，地址值不能发生改变
        final User u = new User();
        //下面这行新创建了一个相同对象，但是地址值不一样
        //User u = new User(); 报错
        u.run();
    }
}

static关键字的使用

Static使用方法：

当static修饰成员变量时，该变量为类变量（习惯称为静态变量）。每个对象都共用一个类变量，
即任何对象都可以改变类变量的值。被其修饰的成员可以作为共享数据。

注意：被static修饰的成员，属于类，不属于对象

static修饰的成员在进入内存的时候，会优先于对象存在

public class Stu {
    String stuName;
    int age;
    static String classRoom;
//...get set 方法
}

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

        Stu.classRoom ="魔法学院001";
        //对于同一个班的学生 教室都是一致的
        Stu stu =new Stu();
        stu.setStuName("小红");
        stu.setAge(20);
        System.out.println(stu.getStuName());
        System.out.println(stu.getAge());
        System.out.println(stu.getClassRoom());

        Stu stu1 =new Stu();
        stu1.setStuName("小白");
        stu1.setAge(19);
        System.out.println(stu1.getStuName());
        System.out.println(stu1.getAge());
        System.out.println(stu1.getClassRoom());

    }
}

当static修饰成员方法时，该方法为类方法（习惯称为静态方法）。该方法的调用不需要创建对象，直接类名加方法名就可以调用。
访问静态方法的特点：

1、静态的不能直接访问非静态的（因为静态属于类，非静态输入对象，类一旦加载，那么静态的就会跟着类直接进入内存，是优先于对象存在的）

2、静态可以访问静态的

3、非静态的可以访问静态的

public class Test {

    public static void main(String[] args) {
        method();//报错
     /*   //非静态调用，创建对象然后调用
        Test test = new Test();
        test.method();
        test.method3();*/
     
     method1();


    }

    public void method() {
        System.out.println("非静态方法");
    }
    
    public static void method1(){
        System.out.println("静态方法");
    }

    //非静态方法访问静态方法
    public void method3(){
        method();
    }
}

static静态代码块，在类的加载中首先执行的就是静态代码块里面的指令，优先于main方法便于初始化数据等作用，且只加载一次

public class Static {

    static{
        System.out.println("我是静态代码块");

    }

    public static void main(String[] args) {
   

    }
}

内部类的认识及其使用

1、内部类即类中方法体外包含的其他类
2、内部类可以随意掉用外部类的方法以及成员变量
3、外部类如果要调用内部类方法或者成员变量的话

创建内部类对象格式：
外部类名.内部类名对象名 = new 外部类名().new 内部类名();

注意：

内部类可以直接使用外部类的成员

外部类不能直接使用内部类的成员

class A{
    public int a = 10;
    public void run(){
        System.out.println("外部类A的方法");
    }
    class B{
        public int b= 20;
        public void run1(){
            System.out.println("内部类B的方法");

            //内部类可以直接使用外部类的成员
            System.out.println(a);
            run();
        }
    }

    public void test(){
        
        //外部类不能直接使用内部类的成员
        /*System.out.println(b);//报错
        run1();//报错*/
    }
}


public class NBlei {
    public static void main(String[] args) {
        //外部类创建对象并调用方法
        A a = new A();
        a.run();

        //内部类创建对象并调用方法
        A.B b = new A().new B();
        b.run1();

        //等效于上面的创建内部类对象
        A.B b1 = a.new B();
        b1.run1();

    }
}

匿名内部类：

使用场景：一个抽象类或者一个接口中的方法只调用一次

格式1： new 父类/接口（）{

重写方法；}.重写方法名

格式2：类名对象名 = new 类名（）{

重写方法}

对象名.重写方法名

abstract class A {
    abstract void run();

}  

public class NMlei {
    public static void main(String[] args) {
        //格式一
     /*  new A(){
           @Override
           void run() {
               System.out.println("方法");
           }
       }.run();*/
     
     //格式二
        A a = new A(){

            @Override
            void run() {
                System.out.println("方法");
            }
        };
        a.run();
    }
}

注意事项

final关键字、static关键字和内部类是Java中常用的关键字和特性，使用时需要注意以下几点：

final关键字用于修饰类、方法和变量，表示不能被修改。如果一个类被final修饰，那么它不能被继承；如果一个方法被final修饰，那么它不能被重写；如果一个变量被final修饰，那么它不能被重新赋值。因此，在使用final关键字时需要谨慎，确保不会影响程序的正确性。
static关键字用于修饰类或方法，表示属于类本身而不是属于类的实例。静态成员可以在不创建类的实例的情况下直接访问，而实例成员必须在创建实例后才能访问。因此，在使用static关键字时需要考虑是否需要使用静态成员。
内部类是指在一个类中定义的另一个类。内部类可以访问外部类的私有成员，但是不能访问外部类的公有成员。在使用内部类时需要注意访问权限的问题，避免出现安全漏洞。
在Java中，所有的对象都是通过引用来访问的。当一个对象被final修饰时，它的引用只能指向一个特定的对象，不能再指向其他的对象。因此，在使用final关键字时需要注意对象引用的问题，避免出现内存泄漏等问题。
在Java中，所有的静态成员都共享同一个内存空间。当多个静态成员同时被修改时，可能会导致数据不一致的问题。因此，在使用static关键字时需要注意线程安全的问题，避免出现并发访问导致的数据不一致问题。