Kelas, jenis kelas bersarang dengan contoh

Hai semua. Dalam topik ini, saya ingin bercakap secara terperinci tentang kelas Java dan jenisnya untuk membantu pemula memahami topik ini, dan mungkin bukan baru mempelajari sesuatu yang baharu. Jika boleh, semuanya akan ditunjukkan menggunakan contoh kehidupan sebenar dengan contoh kod yang disertakan. Mari kita mulakan. Dan saya ingin ambil perhatian bahawa perkara utama ialah memahami dua jenis kelas pertama, dan tempatan dan tanpa nama hanyalah subtipe kelas dalam.

Apa itu kelas?

Kelas ialah perihalan logik tentang sesuatu, templat yang dengannya anda boleh membuat contoh sebenar perkara itu. Dalam erti kata lain, ini hanyalah penerangan tentang sifat entiti yang dicipta: apakah sifat dan kaedah yang sepatutnya ada. Sifat ialah ciri entiti, kaedah ialah tindakan yang boleh dilakukannya. Contoh kelas yang baik dari kehidupan sebenar, yang memberikan pemahaman tentang apa itu kelas, boleh dianggap sebagai lukisan: lukisan digunakan untuk menggambarkan struktur (lastik, pemutar skru), tetapi lukisan bukan reka bentuk. Sama seperti jurutera menggunakan cetak biru untuk mencipta reka bentuk, pengaturcaraan menggunakan kelas untuk mencipta objek yang telah menerangkan sifat dan kaedah.

public class Student {
    private String name, group, specialty;

    public Student(String name, String group, String specialty) {
       this.name = name;
       this.group = group;
       this.specialty = specialty;
   }

   // getters/setters
}

Dalam contoh ini, kami mencipta kelas Java yang menerangkan entiti "pelajar": setiap pelajar mempunyai nama, kumpulan dan kepakaran. Sekarang, di tempat lain dalam program, kita boleh mencipta contoh sebenar kelas ini. Dalam erti kata lain: jika kelas Studentadalah potret tentang pelajar yang sepatutnya, maka contoh yang dibuat ialah pelajar sebenar itu sendiri. Contoh mencipta pelajar baharu: new Student("Ivan", "KI-17-2", "Computer Engineering");Operator newmencari kelas Studentdan kemudian memanggil kaedah khas (pembina) kelas ini. Pembina mengembalikan objek kelas yang sudah siap Student- pelajar kami yang tersayang, lapar tanpa biasiswa :))

Jenis kelas di Jawa

Di Jawa terdapat 4 jenis kelas di dalam kelas lain:

1. Kelas dalam bersarang ialah kelas bukan statik di dalam kelas luar.

2. Kelas statik bersarang ialah kelas statik di dalam kelas luar.

3. Kelas tempatan Java ialah kelas dalam kaedah.

4. Kelas Java tanpa nama ialah kelas yang dibuat dengan cepat.

Kami akan bercakap tentang setiap daripada mereka secara berasingan.

Kelas bukan statik di dalam kelas luar

Pertama, saya mahu anda memahami perkara ini dengan contoh sebenar, kerana ia menjadikannya lebih mudah untuk difahami. Jadi sekarang kita akan memecahkan perkara yang besar sebenar kepada komponen yang lebih kecil, dan kita akan membuka kapal terbang! Walau bagaimanapun, demi contoh, ia akan cukup untuk menunjukkan sedikit; kami tidak akan memecahkannya sepenuhnya. Untuk menggambarkan proses ini, kami akan menggunakan gambar rajah kapal terbang. Pertama, kita perlu membuat kelas Airplanedi mana kita boleh menambah sedikit penerangan: nama pesawat, kod pengenalan, penerbangan.

public class Airplane {
    private String name, id, flight;

    public Airplane(String name, String id, String flight) {
        this.name = name;
        this.id = id;
        this.flight = flight;
    }

    // getters/setters
}

Sekarang kami mahu menambah sayap. Buat kelas berasingan? Mungkin inilah logiknya jika kita mempunyai program yang kompleks untuk mereka bentuk kapal terbang, dan di mana kita perlu mencipta sejumlah besar kelas terbitan (kelas yang mempunyai logik yang sama dengan kelas induk, iaitu kelas yang mereka warisi, tetapi jadi mereka memanjangkan kelas induk dengan menambahkan logik atau ciri yang lebih terperinci), tetapi bagaimana jika kita hanya mempunyai permainan di mana kita mempunyai satu pesawat? Maka lebih rasional untuk kita menyiapkan keseluruhan struktur di satu tempat (dalam satu kelas). Di sinilah kelas bersarang bukan statik dimainkan. Pada asasnya, ini ialah penerangan yang lebih terperinci tentang beberapa butiran kelas luaran kami. Dalam contoh ini, kita perlu mencipta sayap untuk kapal terbang - kiri dan kanan. Jom buat!

public class Airplane {
    private String name, id, flight;
    private Wing leftWing = new Wing("Red", "X3"), rightWing = new Wing("Blue", "X3");

    public Airplane(String name, String id, String flight) {
        this.name = name;
        this.id = id;
        this.flight = flight;
    }

    private class Wing {
        private String color, model;

        private Wing(String color, String model) {
            this.color = color;
            this.model = model;
        }

        // getters/setters
    }

    // getters/setters
}

Jadi kami mencipta kelas bersarang bukan statik Wing(sayap) di dalam kelas Airplane(kapal terbang), dan menambah dua pembolehubah - sayap kiri dan sayap kanan. Dan setiap sayap mempunyai sifat sendiri (warna, model) yang boleh kita ubah. Dengan cara ini anda boleh kakitangan struktur seberapa banyak yang anda perlukan. Dan perhatikan: sebelum ini pada rajah terdapat banyak bahagian untuk pesawat, dan, sebenarnya, kita boleh membahagikan semua bahagian ke dalam kelas dalaman, tetapi proses sedemikian tidak selalu digalakkan. Detik seperti itu perlu dikesan bergantung pada tugas. Anda mungkin tidak memerlukan sayap sama sekali untuk menyelesaikan masalah. Maka tidak perlu melakukannya. Ia seperti memotong kaki, lengan, badan dan kepala seseorang - mungkin, tetapi mengapa jika kelas ini hanya digunakan untuk menyimpan data tentang orang? Ciri kelas Java bersarang bukan statik:

1. Mereka hanya wujud dalam objek, jadi untuk menciptanya anda memerlukan objek. Dalam erti kata lain: kami mereka bentuk sayap kami untuk menjadi sebahagian daripada kapal terbang, jadi untuk mencipta sayap kami memerlukan kapal terbang, jika tidak, kami tidak memerlukannya.
2. Tidak boleh ada pembolehubah statik di dalam kelas Java. Jika anda memerlukan beberapa pemalar atau apa-apa lagi statik, anda perlu mengalihkannya ke kelas luar. Ini disebabkan oleh gandingan rapat kelas bersarang bukan statik ke kelas luar.
3. Kelas mempunyai akses penuh kepada semua medan peribadi kelas luar. Ciri ini berfungsi dalam dua cara.
4. Anda boleh mendapatkan rujukan kepada contoh kelas luaran. Contoh: Kapal terbang.ini pautan ke kapal terbang, ini pautan ke sayap.

Kelas statik di dalam kelas luar

Kelas jenis ini tidak berbeza dengan kelas luar biasa, kecuali satu perkara: untuk mencipta contoh kelas sedemikian, anda perlu menyenaraikan keseluruhan laluan dari kelas luar kepada kelas yang dikehendaki, dipisahkan oleh titik. Contohnya: Building.Plaftorm platform = new Building.Platform(); Kelas statik digunakan untuk meletakkan kelas berkaitan bersebelahan supaya struktur logik lebih mudah untuk digunakan. Sebagai contoh: kita boleh mencipta kelas luaran Building, di mana akan terdapat senarai kelas tertentu yang akan mewakili bangunan tertentu.

public abstract class Building {
    private String name, address, type;

    Building(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public static class Platform extends Building {
        public Platform(String name, String address) {
            super(name, address);
            setType("Platform");
        }

        // some additional logic
    }

    public static class House extends Building {
        public House(String name, String address) {
            super(name, address);
            setType("House");
        }

        // some additional logic
    }

    public static class Shop extends Building {
        public Shop(String name, String address) {
            super(name, address);
            setType("Shop");
        }

        // some additional logic
    }

    // getters/setters
}

Contoh ini menunjukkan cara kelas statik membolehkan anda membungkus struktur logik ke dalam bentuk yang lebih mudah. Jika mereka tidak wujud, kita perlu mencipta 4 kelas yang sama sekali berbeza. Kelebihan pendekatan ini:

1. Bilangan kelas telah berkurangan.
2. Semua kelas berada di dalam kelas induk mereka. Kami dapat mengesan keseluruhan hierarki tanpa membuka setiap kelas secara berasingan.
3. Kita boleh merujuk kepada kelas Bangunan, dan IDE akan menggesa keseluruhan senarai semua subkelas kelas ini. Ini akan memudahkan anda mencari kelas yang anda perlukan dan menunjukkan keseluruhan gambar secara lebih holistik.

Contoh mencipta contoh kelas statik bersarang:Building.Shop myShop = new Building.Shop(“Food & Fun!”, “Kalyaeva 8/53”); Saya juga ingin ambil perhatian bahawa strategi ini digunakan dalam kelas AWT 2D untuk menerangkan bentuk, seperti Line2D, Arc2D, Ellipse2D dan lain-lain.

Kelas tempatan

Kelas ini diisytiharkan dalam kaedah lain. Malah, mereka mempunyai semua sifat kelas bersarang bukan statik, hanya kejadian mereka hanya boleh dibuat dalam kaedah, dan kaedah itu tidak boleh statik (untuk menciptanya, anda memerlukan contoh kelas luar, rujukan kepada contoh objek panggilan secara tersirat dihantar kepada kaedah bukan statik, dan dalam kaedah statik tiada kaedah untuk pautan ini). Tetapi mereka mempunyai ciri-ciri mereka sendiri:

1. Kelas tempatan hanya boleh berfungsi dengan pembolehubah kaedah akhir. Masalahnya ialah contoh kelas tempatan boleh disimpan dalam timbunan selepas kaedah selesai, dan pembolehubah boleh dipadamkan. Jika pembolehubah diisytiharkan muktamad, maka pengkompil boleh menyimpan salinan pembolehubah untuk kegunaan kemudian oleh objek. Dan satu lagi perkara: sejak 8+ versi Java, anda boleh menggunakan pembolehubah bukan akhir dalam kelas tempatan, tetapi hanya dengan syarat ia tidak akan berubah.
2. Kelas tempatan tidak boleh diisytiharkan dengan pengubah suai akses.
3. Kelas tempatan mempunyai akses kepada pembolehubah kaedah.

Kelas tempatan boleh didapati sangat jarang, kerana mereka membuat kod sukar dibaca dan tidak mempunyai sebarang kelebihan, kecuali satu - akses kepada pembolehubah kaedah. Saya tidak tahu apakah contoh kelas tempatan yang boleh diambil yang akan menunjukkan penggunaannya yang berkesan, jadi saya hanya akan menunjukkan contoh saya. Katakan kita mempunyai kelas Person(ia akan diandaikan bahawa ini adalah orang) dengan hartanah street(jalan), house(rumah). Kami ingin mengembalikan beberapa objek untuk mengakses hanya lokasi orang itu. Untuk melakukan ini, kami mencipta antara muka AddressContainer, yang membayangkan penyimpanan data tentang lokasi seseorang.

public class Person {
    private String name, street, house;

    public Person(String name, String street, String house) {
        this.name = name;
        this.street = street;
        this.house = house;
    }

    private interface AddressContainer {
        String getStreet();
        String getHouse();
    }

    public AddressContainer getAddressContainer() {
        class PersonAddressContainer implements AddressContainer {
            final String street = Person.this.street, house = Person.this.house;

            @Override
            public String getStreet() {
                return this.street;
            }

            @Override
            public String getHouse() {
                return this.house;
            }
        }

        return new PersonAddressContainer();
    }

    public static void main(String[] args) {
        Person person = new Person("Nikita", "Sholohova", "17");

        AddressContainer address = person.getAddressContainer();

        System.out.println("Address: street - " + address.getStreet() + ", house - " + address.getHouse());
    }

    // getters/setters
}

Seperti yang anda lihat, di dalam kaedah kami mencipta kelas yang melaksanakan penyimpanan lokasi seseorang, mencipta pembolehubah malar di sana (supaya selepas keluar dari kaedah, pembolehubah disimpan dalam objek) dan melaksanakan kaedah untuk mendapatkan alamat dan rumah. Sekarang kita boleh menggunakan objek ini di tempat lain dalam program untuk mendapatkan lokasi seseorang. Saya faham bahawa contoh ini tidak sesuai dan adalah lebih tepat untuk melakukannya hanya dengan meninggalkan pengambil dalam kelas Person, bagaimanapun, penciptaan kelas ini dan kemungkinan penggunaannya telah ditunjukkan, dan kemudian terpulang kepada anda.

Kelas tanpa nama

Di bawah tudung, kelas tanpa nama hanyalah kelas bersarang bukan statik biasa. Keanehan mereka adalah kemudahan penggunaannya. Anda boleh menulis kelas anda secara langsung apabila membuat contoh kelas lain.

public class Animal {
    public void meow() {
        System.out.println("Meow!");
    }

    public static void main(String[] args) {
        Animal anonTiger = new Animal() {
            @Override
            public void meow() {
                System.out.println("Raaar!");
            }
        };

        Animal notAnonTiger = new Animal().new Tiger();

        anonTiger.meow(); // будет выведено Raaar!
        notAnonTiger.meow(); // будет выведено Raaar!
    }

    private class Tiger extends Animal {
        @Override
        public void meow() {
            System.out.println("Raaar!");
        }
    }
}

Pada asasnya, kami hanya menggabungkan dua perkara di satu tempat: mencipta tika satu kelas ( Animal) dan mencipta tika kelas dalam pewarisnya ( Tiger). Jika tidak, kita perlu mencipta kelas secara berasingan dan menggunakan binaan yang lebih panjang untuk mencapai hasil yang sama. Penggunaan kelas tanpa nama adalah wajar dalam banyak kes, khususnya apabila:

• badan kelas sangat pendek;
• hanya satu contoh kelas diperlukan;
• kelas digunakan di tempat ia dicipta atau sejurus selepasnya;
• Nama kelas tidak penting dan tidak menjadikan kod lebih mudah difahami.

Kelas tanpa nama sering digunakan dalam GUI untuk mencipta pengendali acara. Contohnya, untuk membuat butang dan bertindak balas terhadap kliknya:

JButton b2 = new JButton("Click");
b2.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        System.out.println("Кнопка нажата!");
    }
});

Walau bagaimanapun, selepas Java 8 mereka mula menggunakan ungkapan lambda, tetapi masih banyak kod telah ditulis sebelum versi 8 dan anda mungkin menghadapi (dan akan ditemui semasa latihan anda dalam JavaRush) inskripsi sedemikian.\ Analog dengan lambdas:

JButton b2 = new JButton("Click");
b2.addActionListener(e -> System.out.println("Кнопка нажата!"));

Akhir artikel Terima kasih atas perhatian anda semua dan saya berharap anda mempelajari sesuatu yang baru atau memahami sesuatu yang anda tidak faham sebelum ini. Saya juga ingin menjelaskan bahawa artikel ini tergolong dalam kategori "perhatian terhadap perincian" . Ini adalah karya pertama saya, jadi saya harap ia berguna kepada seseorang. Dalam masa terdekat ini, apabila idea baru datang, saya akan cuba menulis sesuatu yang lain, saya hanya ada satu idea... Semoga berjaya untuk semua dan berjaya dalam pengaturcaraan :)