Penjelasan terperinci tentang penggunaan kata kunci statik dan kelas dalaman dalam Java

Artikel ini membawakan anda pengetahuan yang berkaitan tentang java, dan memperkenalkan penggunaan kata kunci statik dan kelas dalaman dalam Java secara terperinci ia membantu semua orang.

Pembelajaran yang disyorkan: "tutorial video java"

1. Kata kunci statik

dalam Java, Ahli diubah suai secara statik dipanggil ahli statik atau ahli kelas Mereka tidak tergolong dalam objek tertentu dan dikongsi oleh semua objek.

1. Pembolehubah ahli diubah suai statik

Pembolehubah ahli diubah suai statik dipanggil pembolehubah ahli statik

[Ciri-ciri pembolehubah ahli statik]:

• bukan milik objek tertentu Ia adalah atribut kelas Ia dikongsi oleh semua objek dan tidak disimpan dalam ruang objek
• boleh diakses melalui rujukan objek (tidak disyorkan) ), juga boleh diakses melalui nama kelas, tetapi secara amnya disyorkan untuk menggunakan nama kelas untuk mengakses
• Pembolehubah kelas disimpan dalam kawasan kaedah
• Kitaran hayat mengiringi hayat kelas (iaitu, ia berubah dengan pemuatan kelas Dicipta dan dimusnahkan apabila kelas dipunggah)

public class Student{
    public String name;
    public String gender;
    public int age;
    public double score;
    public static String classRoom = "rj2104";

    public Student(String name, String gender, int age, double score) {
        this.name = name;
        this.gender = gender;
        this.age = age;
        this.score = score;
    }

    // ...
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
        
        Student s1 = new Student("Li leilei", "男", 18, 3.8);
        Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
        Student s3 = new Student("Jim", "男", 18, 2.6);
        
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);

    }
}

2 kaedah ahli yang diubah suai statik >

Ahli data dalam kelas umum ditetapkan kepada peribadi Kaedah ahli ditetapkan kepada awam

Di Java, kaedah ahli yang diubah suai oleh statik dipanggil kaedah ahli statik kaedah kelas dan bukan unik kepada objek.

Ahli statik biasanya diakses melalui kaedah statik.

public class Student2{
    // ...
    private static String classRoom = "rj2104";
    // ...
    public static String getClassRoom(){
        return classRoom;
    }
}

class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student2.getClassRoom());
    }
}

[Ciri kaedah statik]:

bukan milik objek tertentu, ia adalah kaedah kelas
boleh dipanggil melalui objek atau melalui Nama kelas Nama kaedah statik (...) dipanggil, dan lebih disyorkan untuk menggunakan yang terakhir
Anda tidak boleh mengakses sebarang pembolehubah ahli bukan statik dan kaedah ahli bukan statik dalam kaedah statik; kerana kaedah bukan statik mempunyai parameter ini secara lalai, tetapi Rujukan ini tidak boleh diluluskan apabila memanggil dalam kaedah statik melainkan objek baharu dicipta dalam kaedah statik, dan kemudian objek itu diakses melalui rujukan objek
Kaedah statik tidak boleh ditindih dan tidak boleh digunakan untuk melaksanakan polimorfisme

3 Permulaan pembolehubah ahli statik

Pembolehubah ahli statik biasanya tidak dimulakan dalam pembina. Apa yang dimulakan dalam pembina ialah contoh yang berkaitan dengan objek Terdapat dua jenis pemula untuk atribut

pembolehubah ahli statik: pemulaan di tempat dan pemulaan blok kod statik.

Pemulaan di tempat: berikan nilai awal secara langsung apabila mentakrifkan

public class Student2{
    // ...
    //就地初始化
    private static String classRoom = "rj2104";
    //...
}

Gunakan blok kod statik untuk melengkapkan permulaan

public class Student2{
    // ...
    private static String classRoom;
    
    //静态代码块初始化
    static {
        classRoom = "rj2104";
    }

    // ...
}

2. Kelas dalaman

Di Java, kelas boleh ditakrifkan di dalam kelas lain atau kaedah yang pertama dipanggil kelas dalam dan yang terakhir dipanggil kelas luar. Kelas dalaman juga merupakan manifestasi enkapsulasi.

Kelas dalaman dan kelas luaran berkongsi fail sumber java yang sama, tetapi selepas penyusunan, kelas dalaman akan membentuk fail bytecode yang berasingan Secara amnya, nama fail bytecode ialah: nama kelas luaran $ nama kelas dalaman.

public class OutClass {
    class InnerClass{
    }
}
// OutClass是外部类
// InnerClass是内部类

Mengikut lokasi di mana kelas dalaman ditakrifkan, ia secara amnya boleh dibahagikan kepada bentuk berikut:

1. Kelas dalaman biasa)

Kelas dalam contoh: kelas dalaman ahli yang tidak diubah suai secara statik

Kelas dalaman statik: kelas dalaman ahli yang diubah suai secara statik

2

3. Kelas dalaman tanpa nama

1. Kelas dalaman contoh

ialah kelas dalaman ahli yang belum diubah suai secara statik.

[Nota]:

Mana-mana ahli dalam kelas luaran boleh diakses terus dalam kaedah kelas dalaman contoh
Tidak boleh statik dalam kelas dalaman contoh Pembolehubah ahli; jika ia mesti ditakrifkan, ia hanya boleh menjadi pemalar statik diubah suai oleh akhir statik Pemalar ditentukan apabila atur cara disusun
Lokasi kelas dalam contoh adalah sama dengan lokasi. daripada ahli kelas luar, jadi Juga tertakluk kepada kelayakan akses seperti awam dan peribadi
Objek kelas dalaman contoh mesti terlebih dahulu mempunyai objek kelas luaran sebelum ia boleh dibuat
Kaedah bukan statik untuk kelas dalaman contoh mengandungi kaedah lalai Rujukan kepada objek kelas luaran dan rujukan kepada objek kelas dalaman bagi contoh sendiri
Apabila mengakses ahli dengan nama yang sama dalam kaedah kelas dalaman contoh, akses anda miliki dahulu. Jika anda ingin mengakses ahli kelas luar dengan nama yang sama, anda mesti: Nama kelas luar. ini digunakan untuk mengakses
dalam kelas luar kelas dalaman contoh tidak boleh diakses secara langsung Jika anda ingin mengakses, anda mesti mencipta objek kelas dalaman terlebih dahulu.

public class OutClass {
    private int a;
    static int b;
    int c;

    public void methodA() {
        a = 10;
        System.out.println(a);
    }

    public static void methodB() {
        System.out.println(b);
    }

    // 实例内部类：未被static修饰
    class InnerClass {
        int c;
//实例内部类当中 不能有静态的成员变量. 非要定义，那么只能是被static final修饰的
        public static final int d = 6;

        public void methodInner() {
// 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
            a = 100;
            b = 200;
            methodA();
            methodB();
            System.out.println(d);
// 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
            c = 300;
            System.out.println(c);
// 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
            OutClass.this.c = 400;
            System.out.println(OutClass.this.c);
        }
    }

    public static void main(String[] args) {
// 外部类：对象创建 以及 成员访问
        OutClass outClass = new OutClass();

        System.out.println(outClass.a);
        System.out.println(outClass.b);
        System.out.println(outClass.c);
        outClass.methodA();
        outClass.methodB();
        System.out.println("=============实例内部类的访问=============");
// 要访问实例内部类中成员，必须要创建实例内部类的对象
// 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
// 创建实例内部类对象
        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
        innerClass1.methodInner();
// 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
        innerClass2.methodInner();
    }
}

2. Kelas dalaman statik

Kelas ahli dalaman yang diubah suai oleh statik dipanggil kelas dalaman statik. ,

[Nota]:

Dalam kelas dalaman statik, anda hanya boleh mengakses ahli statik dalam kelas luar, melainkan anda mencipta objek baharu kelas luar dalam kelas dalam, melalui objek kelas luar Rujukan untuk mengakses ahli bukan statik.

Apabila mencipta objek kelas dalaman statik, tidak perlu mencipta objek kelas luar dahulu

public class OuterClass2 {
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;

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

    // 静态内部类：被static修饰的成员内部类
    static class InnerClass2 {
        public int data4 = 4;
        int data5 = 5;
        public static int data6 = 6;

        public void func() {
            System.out.println("out::func()");

            //test();
            // 编译失败，在静态内部类中不能直接访问外部类中的非静态成员
            //System.out.println(data1);
            //System.out.println(data2);

            //外部类的非静态成员，需要通过外部类的对象的引用才能访问。
            OuterClass2 outerClass = new OuterClass2();
            System.out.println(outerClass.data1);
            System.out.println(outerClass.data2);
            outerClass.test();

            // 在静态内部类中只能访问外部类的静态成员
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);
            System.out.println(data5);
            System.out.println(data6);

        }
    }
    public static void main(String[] args) {
        // 静态内部类对象创建 和 成员访问
        OuterClass2.InnerClass2 innerClass2 = new OuterClass2.InnerClass2();
        innerClass2.func();

    }
}

3 Kelas dalaman tempatan

ditakrifkan dalam kaedah badan kelas luar atau { } , biasanya digunakan sangat jarang.

【Nota】

局部内部类只能在所定义的方法体内部使用

不能被public、static等修饰符修饰

局部内部类生成的字节码文件稍有区别：外部类名字$数字内部类名字.class

ppublic class OutClass {
    int a = 10;
    
    public void method(){
        int b = 10;
        // 局部内部类：定义在方法体内部
        // 不能被public、static等访问限定符修饰
        class InnerClass{
            public void methodInnerClass(){
                System.out.println(a);
                System.out.println(b);
            }
        }
        // 只能在该方法体内部使用，其他位置都不能用
        InnerClass innerClass = new InnerClass();
        innerClass.methodInnerClass();
    }
    
    public static void main(String[] args) {
    // OutClass.InnerClass innerClass = null; 编译失败
    }
}

4. 匿名内部类

匿名内部类，就是没有名字的一种嵌套类

匿名内部类形成的字节码文件文件名为：外部类名字$数字.class

4.1 使用匿名内部的好处与演示

在实际开发中，我们会遇到下面的情况：

一个接口/类的方法的某个执行过程在程序中只会执行一次，但为了使用它，我们需要创建它的实现类/子类去实现/重写方法。

代码中为了这一次的使用去创建一个类，未免太过麻烦，此时就可以使用匿名内部类来解决这个问题

首先来看我们正常的实现逻辑，假设有一个接口，接口当中只有一个方法

public interface Interface {
    void show();
}

为了使用该接口的show方法，我们需要去创建一个实现类，重写show方法的具体实现

public class Test implements Interface{
    @Override
    public void show() {
        System.out.println("只执行一次show()");
    }
}

public class Main {
    public static void main(String[] args) {
        Test test = new Test();
        test.show();
    }
}

如果实现类Test在程序中只使用一次，那么为了这一次的使用去创建一个类太过繁琐，这种情况下就可以用匿名内部类来实现，无需创建新的类，减少代码冗余，

看下面代码：

class Main {
    public static void main(String[] args) {
        //写法一
        Interface in = new Interface() {
            @Override
            public void show() {
                System.out.println("匿名内部类中重写show()");
            }
        };
        //调用接口方法
        in.show();
        
        //写法二
        new Interface() {
            @Override
            public void show() {
                System.out.println("匿名内部类中重写show()");
            }
        }.show();//调用接口方法
    }
}

4.2 匿名内部类的定义格式和使用

定义格式1：

接口名称 引用名 = new 接口名称() {
// 覆盖重写所有抽象方法
};

引用名.方法调用

定义格式2：

new 接口名称() {
// 覆盖重写所有抽象方法
}.方法调用;

对格式“new 接口名称() {…}”的理解：

new代表创建一个新的对象对象

接口名称就是匿名内部类需要实现哪个接口

{…}中是匿名内部类的内容

【注意事项】：

• 匿名内部类，在【创建对象】的时候，只能使用唯一 一次。
• 匿名对象，在【调用方法】的时候，只能调用唯一 一次。
• 匿名内部类是省略了【实现类/子类名称】，但是匿名对象是省略了【对象名称】
• 匿名内部类可以用在具体类、抽象类、接口上，且对方法个数没有要求。

public class Class {
    public void show(String s){
        System.out.println("Class::show()");
    }
}

public abstract class AbstractClass {
    abstract void show(String s);
}

public interface Interface {
    void show(String s);
}

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

        //重写普通类的方法
        new Class(){
            @Override
            public void show(String s) {
                System.out.println(s);
            }
        }.show("普通类");

        //重写抽象类的抽象方法
        new AbstractClass(){
            @Override
            void show(String s) {
                System.out.println(s);
            }
        }.show("抽象类");

        //实现接口的抽象方法
        new Interface(){
            @Override
            public void show(String s) {
                System.out.println(s);
            }
        }.show("接口");

    }
}

执行结果：

推荐学习：《java视频教程》

Atas ialah kandungan terperinci Penjelasan terperinci tentang penggunaan kata kunci statik dan kelas dalaman dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!