Bercakap secara ringkas tentang berorientasikan objek Java

Artikel ini membawa anda pengetahuan yang berkaitan tentang java, yang terutamanya memperkenalkan isu berkaitan berorientasikan objek Java, termasuk ciri asas berorientasikan objek, hubungan antara objek, dsb. , harap ia membantu semua orang.

Pembelajaran yang disyorkan: "tutorial java"

1. Seks Mudah

Orang ramai ingin membina sistem yang boleh diprogramkan tanpa latihan profesional esoterik dan yang mematuhi amalan standard hari ini. Oleh itu, walaupun orang mendapati bahawa C tidak sesuai, Java direka bentuk sedekat mungkin dengan C supaya sistem lebih mudah difahami Java menghapuskan banyak ciri yang jarang digunakan, sukar difahami dan mengelirukan C. Pada masa ini, ciri-ciri ini menyebabkan lebih banyak masalah daripada kebaikan.

Sememangnya, sintaks Java ialah versi "tulen" sintaks C. Tiada fail pengepala, aritmetik penuding (atau pun sintaks penuding), struktur, kesatuan, pembebanan operator, kelas asas maya, dsb. Walau bagaimanapun, pereka bentuk tidak cuba untuk menghapuskan semua ciri yang tidak sesuai dalam C. Sebagai contoh, sintaks pernyataan suis tidak berubah dalam Java. Jika anda tahu C, anda akan mendapati mudah untuk menukar kepada sintaks Java.

Apabila Java dikeluarkan, C sebenarnya bukan bahasa pengaturcaraan yang paling biasa digunakan. Ramai pembangun menggunakan Visual Basic dan persekitaran pengaturcaraan drag-and-dropnya. Pembangun ini tidak mendapati Java mudah. Ia mengambil masa bertahun-tahun untuk persekitaran pembangunan Java untuk mengejar. Hari ini, persekitaran pembangunan Java telah berkembang jauh melebihi kebanyakan bahasa pengaturcaraan lain.

Satu lagi aspek kesederhanaan ialah menjadi kecil. Salah satu matlamat Java adalah untuk menyokong pembangunan perisian yang boleh berjalan secara bebas pada mesin kecil. Jurubahasa asas dan sokongan kelas hanya kira-kira 40KB ditambah perpustakaan kelas standard asas dan sokongan benang (pada asasnya mikrokernel serba lengkap) menambah kira-kira 175KB.

Pada masa itu, ini adalah pencapaian yang luar biasa. Sudah tentu, disebabkan pengembangan berterusan, perpustakaan kelas sudah agak besar. Kini terdapat Java Micro Edition (JavaMicroEdition) yang berasingan dengan perpustakaan kelas yang lebih kecil, yang sesuai untuk peranti terbenam.

2. Berorientasikan objek

Berorientasikan objek ialah kaedah pengaturcaraan yang baru muncul, atau spesifikasi pengaturcaraan baharu ialah menggunakan objek, konsep asas seperti kelas, pewarisan, enkapsulasi, dan polimorfisme digunakan untuk pengaturcaraan. Bina sistem perisian berdasarkan perkara sedia ada secara objektif (iaitu objek) di dunia nyata, dan gunakan pemikiran semula jadi manusia sebanyak mungkin dalam pembinaan sistem.

3. Diedarkan

Bagi pengguna, sistem yang diedarkan hanyalah pelayan yang menyediakan perkhidmatan yang diperlukan oleh pengguna daripada banyak pelayan di belakangnya, jadi sistem yang diedarkan kelihatan seperti superkomputer.

4. Keteguhan

Persekitaran berbilang platform Web mempunyai keperluan khas untuk program, kerana program mesti dilaksanakan dengan pasti dalam pelbagai sistem. Oleh itu, keupayaan untuk mencipta program yang mantap diberi keutamaan yang tinggi semasa mereka bentuk Java. Untuk mencapai kebolehpercayaan, Java mengenakan sekatan dalam beberapa bidang utama, sekali gus memaksa pengaturcara untuk mengesan ralat awal dalam pembangunan program. Pada masa yang sama, pengaturcara tidak lagi perlu bimbang tentang banyak masalah yang paling biasa yang menyebabkan ralat pengaturcaraan. Oleh kerana Java ialah bahasa yang ditaip dengan kuat, ia menyemak kod pada masa penyusunan. Sudah tentu, tidak kira apa, kod itu juga disemak semasa runtime. Banyak pepijat yang sukar dijejaki selalunya sukar untuk dihasilkan semula pada masa jalanan, yang hampir mustahil berlaku di Jawa. Kerana menjadikan program bertulis berjalan dengan cara yang boleh diramal di bawah keadaan operasi yang berbeza adalah salah satu ciri utama Java. Untuk lebih memahami betapa teguhnya Java, mari kita analisa dua punca utama kegagalan program: ralat pengurusan memori dan pengecualian tidak terkendali (iaitu, ralat masa jalan). Dalam persekitaran pengaturcaraan tradisional, pengurusan memori adalah tugas yang sukar dan membosankan. Sebagai contoh, dalam C/C, pengaturcara mesti memperuntukkan dan membebaskan semua memori dinamik secara manual. Kadangkala ini boleh menyebabkan masalah, kerana pengaturcara mungkin terlupa untuk mengosongkan memori yang diperuntukkan sebelum ini, atau lebih teruk, cuba mengosongkan memori yang masih digunakan oleh bahagian lain program. Java pada dasarnya boleh menghapuskan masalah ini dengan menguruskan peruntukan dan deallocation memori untuk anda (sebenarnya, membebaskan memori adalah automatik sepenuhnya, kerana Java menyediakan pengumpulan sampah untuk objek yang tidak lagi digunakan). Pengecualian dalam persekitaran tradisional selalunya disebabkan oleh ralat "bahagi dengan sifar" atau "fail tidak ditemui", dan ia mesti diurus menggunakan struktur yang kekok dan sukar difahami. Java membantu dalam bidang ini dengan menyediakan keupayaan pengendalian pengecualian berorientasikan objek. Dalam program Java yang ditulis dengan baik, semua ralat masa jalan boleh dan harus diuruskan oleh program tersebut.

5. Keselamatan

Java telah membatalkan petunjuk yang kuat tetapi berbahaya dan menggantikannya dengan rujukan. Memandangkan penunjuk boleh melakukan operasi bergerak, penunjuk boleh menunjuk ke mana-mana kawasan memori tidak kira sama ada kawasan ini tersedia Ini berbahaya kerana ternyata alamat memori ini mungkin menyimpan data penting atau diduduki oleh program lain, dan menggunakan penunjuk Ia juga. mudah untuk tatasusunan untuk keluar dari sempadan.

Mekanisme pengumpulan sampah: Pengaturcara tidak perlu mengawal terus kitar semula memori Pengumpul sampah secara automatik menuntut semula memori yang tidak digunakan di latar belakang. Elakkan program daripada terlupa mengitar semula dalam masa, menyebabkan kebocoran memori. Elakkan ralat program dalam mengitar semula memori perpustakaan kelas teras program, menyebabkan ranap sistem.

Mekanisme pengendalian pengecualian: Mekanisme pengecualian Java bergantung terutamanya pada lima kata kunci cuba, tangkap, akhirnya, balingan dan balingan.

Penukaran jenis paksa: Penukaran paksa hanya boleh berjaya jika peraturan penukaran paksa dipenuhi.

Java menggunakan penyulitan kunci awam (PKC) semasa penghantaran kod bait.

Menyediakan mekanisme keselamatan empat peringkat dalam persekitaran berjalan: pengesah kod byte - pemuat kelas - susun atur memori masa jalan - sekatan akses fail.

6. Berkecuali seni bina

Pengkompil menjana format fail objek neutral seni bina, yang merupakan kod yang disusun, selagi terdapat sistem masa jalan Java , ia boleh dijalankan pada banyak pemproses. Pengkompil Java mencapai ciri ini dengan menjana arahan bytecode yang bebas daripada seni bina komputer tertentu. Bytecode yang direka dengan baik bukan sahaja boleh ditafsir dan dilaksanakan dengan mudah pada mana-mana mesin, tetapi juga boleh diterjemahkan dengan cepat ke dalam kod mesin tempatan.
Bytecode ialah struktur neutral dan tiada kaitan dengan struktur komputer.

7. Kemudahalihan

Ciri terbesar bahasa Java ialah sokongan kemudahalihannya Maksudnya program yang sama boleh digunakan dalam sistem pengendalian yang berbeza akan, yang mengurangkan kesukaran pembangunan Jika anda ingin mencapai kawalan mudah alih di Jawa, anda bergantung terutamanya pada JVM (Java Virtual Machine). Mesin maya Java ialah komputer yang disimulasikan oleh perisian dan perkakasan Semua program boleh dilaksanakan selagi ia disokong oleh mesin maya Java, dan versi JVM yang berbeza wujud pada sistem pengendalian yang berbeza, supaya Dayakan mudah alih.
Hak cipta milik pengarang. Untuk pencetakan semula komersial, sila hubungi pengarang untuk mendapatkan kebenaran Untuk pencetakan semula bukan komersial, sila nyatakan sumbernya.

8. Kebolehtafsiran

Sesetengah orang mengatakan bahawa Java disusun. Kerana semua kod Java mesti disusun, .java tidak boleh dilaksanakan tanpa penyusunan. Sesetengah orang juga mengatakan bahawa Java ditafsirkan. Oleh kerana kod Java tidak boleh dijalankan secara langsung selepas penyusunan, ia ditafsirkan dan dijalankan pada JVM, jadi ia ditafsirkan.

9. Prestasi tinggi

Pengkompil tepat masa boleh memantau kod yang kerap dilaksanakan dan mengoptimumkannya untuk meningkatkan kelajuan. Pengoptimuman yang lebih kompleks adalah untuk menghapuskan panggilan fungsi (iaitu inlining). Pengkompil tepat dalam masa mengetahui kelas mana yang telah dimuatkan. Inlining boleh digunakan jika fungsi tertentu tidak akan ditindih berdasarkan set kelas yang sedang dimuatkan. Pengoptimuman juga boleh dibuat asal jika perlu.

10. Multi-threading

bermaksud program ini (suatu proses) menjana lebih daripada satu thread semasa ia dijalankan.

11. Dinamik

Java pada dasarnya adalah bahasa statik, bukan bahasa dinamik. Ciri luar biasa bahasa dinamik ialah struktur atur cara atau jenis pembolehubah boleh diubah apabila program dijalankan. Java bukan bahasa dinamik, tetapi Java mempunyai tahap dinamik tertentu, yang dicerminkan dalam aspek berikut:

1. mekanisme pantulan
2. operasi kod bait dinamik; 🎜> Kompilasi dinamik;
3. Laksanakan kod skrip lain;
4. 2. Objek

Objek ialah entiti yang digunakan untuk menerangkan perkara objektif dalam sistem, dan ia membentuk sistem Satu unit asas. Objek terdiri daripada satu set sifat dan satu set perkhidmatan yang beroperasi pada set sifat.

Instasiasi kelas boleh menjana objek Kitaran hayat objek merangkumi tiga peringkat: penjanaan, penggunaan dan penyingkiran.

Apabila tiada rujukan kepada objek, objek tersebut menjadi objek yang tidak berguna. Pengumpul sampah Java secara automatik mengimbas kawasan memori dinamik objek, mengumpul dan melepaskan objek yang tidak dirujuk sebagai sampah. Apabila sistem kehabisan memori atau memanggil System.gc() untuk memerlukan kutipan sampah, benang kutipan sampah berjalan serentak dengan sistem.

3. Kelas

Kelas ialah koleksi objek dengan atribut dan kaedah yang sama bahagian utama. Dalam bahasa pengaturcaraan berorientasikan objek, kelas ialah unit program bebas Ia harus mempunyai nama kelas dan termasuk dua bahagian utama: atribut dan kaedah.

Pelaksanaan kelas di Java terdiri daripada dua bahagian: pengisytiharan kelas dan badan kelas.

1. Pengisytiharan kelas

[public][abstract|final] class className [extends superclassName] [implements interfaceNameList]{……}

Antaranya, pengubah umum, abstrak dan akhir menerangkan atribut kelas, className ialah nama kelas dan superclassName ialah induk kelas Nama kelas, interfaceNameList ialah senarai antara muka yang dilaksanakan oleh kelas.

2. Isi kelas

class className{
    [public | protected | private ] [static] [final] [transient] [volatile] type variableName;//成员变量
    [public | protected | private ] [static] [final | abstract] [native] [synchronized] returnType methodName([paramList]) [throws exceptionList]{
        statements
    }//成员方法
}

Maksud kelayakan pembolehubah ahli:

• statik: pembolehubah statik (pembolehubah kelas)
• statik: kaedah kelas, yang boleh dipanggil terus melalui nama kelas
• abstrak: kaedah abstrak, tiada badan kaedah

akhir: kaedah tidak boleh ditindih Untuk jenis data ringkas, Java melaksanakan pemindahan nilai Kaedah menerima nilai parameter, tetapi tidak boleh mengubah nilai parameter ini. Jika anda ingin menukar nilai parameter, gunakan jenis data rujukan, kerana jenis data rujukan menghantar kepada kaedah alamat data dalam ingatan, dan operasi pada data dalam kaedah boleh menukar nilai data .

• 3. Badan kaedah
• Badan kaedah ialah pelaksanaan kaedah, yang merangkumi pengisytiharan pembolehubah tempatan dan semua arahan Java yang sah. Skop pembolehubah tempatan yang diisytiharkan dalam badan kaedah adalah dalam kaedah. Jika pembolehubah tempatan mempunyai nama yang sama dengan pembolehubah ahli kelas, pembolehubah ahli kelas disembunyikan.
• Untuk membezakan parameter daripada pembolehubah ahli kelas, kita mesti menggunakan ini. ini digunakan dalam kaedah untuk merujuk kepada objek semasa, dan nilainya ialah objek yang dipanggil kaedah. Nilai pulangan mesti konsisten dengan jenis pulangan, atau sama persis, atau subkelasnya. Apabila jenis pulangan ialah antara muka, nilai pulangan mesti melaksanakan antara muka.
• 4. Kaedah pembinaan

Kaedah pembinaan adalah kaedah khas. Setiap kelas dalam Java mempunyai kaedah pembina yang memulakan objek kelas itu.

Pembina mempunyai nama yang sama dengan nama kelas dan tidak mengembalikan sebarang jenis data.

Lebih muatan sering digunakan untuk pembina.

Pembina hanya boleh dipanggil oleh operator baharu

5 Ulasan

Ulasan dalam Java digunakan untuk menerangkan kod anda , Anotasi Java tidak akan dilaksanakan, jadi jangan ragu untuk menambah anotasi.
• Ulasan baris bila//
• Ulasan berbilang baris/**/

6 Parameter tersirat dan parameter eksplisit

(1) Parameter eksplisit ialah parameter antara kurungan nama kaedah.

(2) Parameter tersirat ialah medan contoh kelas yang dipanggil dalam kaedah kelas. Medan contoh yang dipanggil ialah parameter tersirat.

(3) Contoh kod
• x ialah parameter eksplisit

skor ialah parameter tersirat

Jika dalam Tambahkan ini di hadapan parameter tersirat untuk menjadikan parameter tersirat lebih jelas.

Adalah disyorkan untuk menambah operator ini di hadapan parameter tersirat Operator ini mewakili kelas ini.

7 Kaedah dengan parameter boleh ubah

package com.nezha.javase;

public class Test1107 {
    private int score;

    /**
     * x为显式参数
     * score为隐式参数
     * @param x
     */
    public void addScore(int x){
        int temp = this.score + x;
        score += temp;
    }
}

Sebelum jdk5, setiap kaedah java mempunyai bilangan parameter tetap Walau bagaimanapun, versi semasa menyediakan Cara menukar parameter.
• Ambil sout yang paling biasa digunakan sebagai contoh.
• println secara dalaman memanggil

Objek... Jenis parameter adalah betul-betul sama dengan Object[], yang bermaksud anda boleh menggunakan... kaedah pengisytiharan ini untuk menerima tatasusunan jenis yang sama, tetapi tidak ada saiz tetap tatasusunan, kerana ini ialah parameter pembolehubah.

Ellipsis di sini... adalah sebahagian daripada kod Java yang menunjukkan bahawa kaedah ini boleh menerima sebarang bilangan objek.

Sebenarnya, kaedah printf menerima dua parameter, satu ialah rentetan format, dan satu lagi ialah tatasusunan Object[], yang menyimpan semua parameter (jika parameter adalah jenis asas, autoboxing akan menukarnya menjadi objek).

Pengkompil perlu menukar setiap panggilan kepada printf untuk mengikat argumen kepada tatasusunan dan autokotaknya jika perlu. 4. Ciri-ciri asas berorientasikan objek

1. membentuk sempadan ke luar Hanya antara muka dan kaedah yang terhad dikhaskan untuk berinteraksi dengan dunia luar. Prinsip enkapsulasi adalah untuk menghalang bahagian selain objek daripada mengakses dan mengendalikan sifat dalaman objek sesuka hati, dengan itu menghalang dunia luar daripada merosakkan sifat dalaman objek.

（1）可以通过对类的成员设置一定的访问权限，实现类中成员的信息隐藏。

• private：类中限定为private的成员，只能被这个类本身访问。
• default：类中不加任何访问权限限定的成员属于缺省的（default）访问状态，可以被这个类本身和同一个包中的类所访问。
• protected：类中限定为protected的成员，可以被这个类本身、它的子类（包括同一个包中以及不同包中的子类）和同一个包中的所有其他的类访问。
• public：类中限定为public的成员，可以被所有的类访问。

（2）封装的优点

1. 良好的封装能够减少耦合
2. 类内部的结构可以自由修改
3. 可以对成员变量进行更精确的控制
4. 隐藏信息，实现细节

（3）代码实例

1. 将 id、name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
2. 提供set方法进行赋值，提供get方法进行取值。
3. 赋值方法set中的this的作用是解决显式参数与局部变量同名的问题。

package com.nezha.javase;

public class Student {
    //将 id、name 和 age 属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。
    private Integer id;
    private String name;
    private Integer age;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

2、继承

子类的对象拥有父类的全部属性与方法，称作子类对父类的继承。

• Java中父类可以拥有多个子类，但是子类只能继承一个父类，称为单继承。
• 继承实现了代码的复用。
• Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。
• 子类不能继承父类中访问权限为private的成员变量和方法。
• 子类可以重写父类的方法，即命名与父类同名的成员变量。

Java中通过super来实现对父类成员的访问，super用来引用当前对象的父类。super 的使用有三种情况：

• 访问父类被隐藏的成员变量
• 调用父类中被重写的方法
• 调用父类的构造函数

3、多态

对象的多态性是指在父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各个子类中具有不同的语义。

Java的多态性体现在两个方面：由方法重载实现的静态多态性（编译时多态）和方法重写实现的动态多态性（运行时多态）。

• 编译时多态：在编译阶段，具体调用哪个被重载的方法，编译器会根据参数的不同来静态确定调用相应的方法。
• 运行时多态：由于子类继承了父类所有的属性（私有的除外），所以子类对象可以作为父类对象使用。程序中凡是使用父类对象的地方，都可以用子类对象来代替。一个对象可以通过引用子类的实例来调用子类的方法。

4、重载

• 方法重载是让类以统一的方式处理不同数据类型的手段。
• 一个类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法。
• 返回值类型可以相同也可以不相同，无法以返回型别作为重载函数的区分标准。

5、重写

• 子类对父类的方法进行重新编写。如果在子类中的方法与其父类有相同的的方法名、返回类型和参数表，我们说该方法被重写 (Overriding)。
• 如需父类中原有的方法，可使用super关键字，该关键字引用了当前类的父类。
• 子类函数的访问修饰权限不能低于父类的。

五、对象间的四种关系

1、依赖

依赖关系表示一个类依赖于另一个类的定义。例如，一个人(Person)可以买车(car)和房子(House)，Person类依赖于Car类和House类的定义，因为Person类引用了Car和House。与关联不同的是，Person类里并没有Car和House类型的属性，Car和House的实例是以参量的方式传入到buy()方法中去的。一般而言，依赖关系在Java语言中体现为局域变量、方法的形参，或者对静态方法的调用。 

2、关联

关联(Association）关系是类与类之间的联接，它使一个类知道另一个类的属性和方法。关联可以是双向的，也可以是单向的。在Java语言中，关联关系一般使用成员变量来实现。

3. Agregasi

Agregasi ialah sejenis persatuan dan merupakan persatuan yang kuat. Agregasi ialah hubungan antara keseluruhan dan individu. Sebagai contoh, hubungan antara kategori kereta dan kategori enjin, kategori tayar dan kategori bahagian lain ialah hubungan antara keseluruhan dan individu. Seperti perhubungan persatuan, perhubungan pengagregatan juga dilaksanakan melalui pembolehubah contoh. Walau bagaimanapun, kedua-dua kelas yang terlibat dalam hubungan persatuan berada pada tahap yang sama, manakala dalam hubungan pengagregatan, kedua-dua kelas berada pada tahap yang tidak sama, satu mewakili keseluruhan dan satu lagi mewakili bahagian.

4. Gabungan

Perhubungan Komposisi (Komposisi) ialah sejenis perhubungan persatuan dan merupakan perhubungan yang lebih kuat daripada perhubungan pengagregatan. Ia memerlukan objek yang mewakili keseluruhan dalam hubungan pengagregatan biasa bertanggungjawab untuk mewakili kitaran hayat sebahagian objek, dan hubungan gabungan tidak boleh dikongsi. Objek yang mewakili keseluruhan perlu bertanggungjawab untuk memastikan objek bahagian itu hidup dan dalam beberapa kes memusnahkan objek yang bertanggungjawab untuk bahagian tersebut. Objek yang mewakili keseluruhan boleh menghantar objek yang mewakili bahagian kepada objek lain, yang bertanggungjawab untuk kitaran hayat objek ini. Dalam erti kata lain, objek yang mewakili bahagian itu hanya boleh digabungkan dengan satu objek pada setiap saat, dan yang terakhir bertanggungjawab secara eksklusif untuk kitaran hayat. Bahagian mempunyai kitaran hayat yang sama seperti keseluruhan.

Pembelajaran yang disyorkan: "Tutorial pembelajaran java"

Atas ialah kandungan terperinci Bercakap secara ringkas tentang berorientasikan objek Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!