Secara pribadi, apa yang disebut kelas dalam pemrograman adalah konsep yang sama dengan kelas-kelas di dunia nyata yang mengklasifikasikan objek, tetapi mereka dipinjam dalam pemrograman. Kelas mewakili hal -hal yang memiliki serangkaian kesamaan dan operasi atau tindakan yang sama, yang merupakan tipe data abstrak dalam pemrograman. Setiap individu tertentu (di dunia nyata) dan variabel instance (untuk pemrograman) adalah objek.
Kelas adalah representasi dari fitur umum (atribut dan operasi) dari objek tertentu di dunia nyata, dan suatu objek adalah instance dari suatu kelas.
Atribut Kelas: adalah singkatan dari atribut statis suatu kelas, yang mengacu pada berbagai data yang terkandung dalam kelas, seperti variabel atau objek kelas lainnya;
Layanan kelas: disebut fungsi atau metode anggota.
¨
Bentuk definisi kelas di Java adalah sebagai berikut:
[Modifier] Nama kelas kelas [Extends Parent Class] [Implements Name Antarmuka] {Kelas Variabel Anggota Deklarasi Metode Deklarasi}Mari kita bicara tentang setiap bagian dari ini secara detail:
Sebelum kata kunci kelas, pengubah kelas umumnya dibagi menjadi tiga jenis: pengubah akses kelas publik, pengubah akhir (spesifikasi kelas akhir) dan pengubah abstrak (spesifikasi kelas abstrak)
Di antara mereka, pengubah izin hanya dapat bersifat publik atau default (mis. Kosong, tidak ada, yang menunjukkan bahwa itu didefinisikan sebagai ramah), dan publik berarti bahwa kelas dapat digunakan dan diakses di mana saja (selama program dapat menemukan lokasi kelas), baik dalam paket yang sama atau dalam paket yang berbeda. Perhatikan bahwa ini berbeda dari C ++. C ++ tidak memiliki pengubah untuk membatasi hak akses ke kelas, tetapi memiliki hak akses untuk hubungan warisan antar kelas. Selain itu, mereka semua memiliki hak akses ke atribut dan metode kelas. Izin akses default (mis., Didefinisikan sebagai ramah) berarti bahwa itu hanya dapat dirujuk dan diakses oleh kelas dalam paket yang sama, tetapi tidak dapat diakses dan direferensikan oleh kelas dalam paket lain, bahkan jika diimpor.
Ini juga akan disebutkan nanti: Ketika pengubah default dari atribut dan metode kelas digunakan, ia juga dinyatakan bahwa ia hanya dapat dirujuk dan diakses oleh kelas dalam paket yang sama.
Warisan berganda tidak diperbolehkan dalam Java, yang berbeda dari C ++. Untuk menebus kekurangan ini, Java telah memperkenalkan konsep antarmuka.
Dalam definisi kelas di atas, badan kelas terutama berisi konten spesifik kelas, termasuk atribut kelas dan metode kelas. Properti kelas dapat berupa variabel sederhana atau contoh kelas tertentu. Jika itu adalah instance dari suatu kelas, itu dapat didefinisikan sebagai berikut:
[Pengubah] Nama kelas Nama objek = Nama kelas baru (daftar parameter);
Saat mendeklarasikan objek dan variabel kompleks, Anda tidak dapat menggunakan kreasi selama deklarasi, tetapi dapat dibuat di konstruktor mendatang.
Metode yang didefinisikan dalam kelas biasanya memainkan dua peran: satu adalah untuk melakukan berbagai operasi di sekitar atribut kelas; Yang lainnya adalah melakukan pertukaran data, pengiriman pesan, dan operasi lain dengan kelas atau objek lain.
Sintaks untuk menyatakan metode di Java adalah sebagai berikut:
[Modifier] Return Value Tipe Metode Nama (Daftar Parameter) Melempar Nama Pengecuali 1, Nama Pengecuali 2, ... {Method Body: Deklarasi Variabel Lokal; urutan pernyataan;}Metode kelas, juga dikenal sebagai fungsi anggota, digunakan untuk menentukan operasi pada atribut kelas dan mengimplementasikan fungsi internal kelas. Mereka juga merupakan jendela penting bagi kelas untuk berinteraksi dengan dunia luar.
Pemrogram Java fokus pada pembuatan tipe yang ditentukan pengguna yang disebut kelas. Kelas juga disebut tipe yang ditentukan oleh programmer. Setiap kelas berisi data dan serangkaian metode untuk memanipulasi data. Bagian data dalam kelas disebut variabel instance. Sebuah instance dari tipe yang ditentukan pengguna (mis., Kelas) disebut objek.
Objek adalah instance dari kelas. Kelas adalah abstraksi dari jenis objek yang sama dan templat untuk membuat objek. Membuat objek dalam program akan membuka ruang dalam memori, termasuk properti dan metode objek. Buat objek menggunakan operator kata kunci baru.
Konstruktor (dapat dibandingkan dengan C ++, yang hampir sama dengan C ++)
Buat konstruktor Anda sendiri
• Nama konstruktor dan nama kelasnya sama. Saat membangun objek kelas karyawan, konstruktor ini dimulai dan bidang instance diberi nilai awal. Dalam Java, definisi dan inisialisasi disatukan - keduanya sangat diperlukan.
Misalnya, saat membuat instance kelas karyawan dengan kode berikut,
NewEmployee ("James Bond", 100000.1950,1,1);
Karakteristik konstruktor adalah:
(1) Konstruktor dan kelas memiliki nama yang sama.
(2) Kelas dapat memiliki beberapa konstruktor.
(3) Konstruktor dapat memiliki 0, 1 atau lebih parameter.
(4) Konstruktor tidak memiliki nilai pengembalian.
(5) Konstruktor selalu dipanggil dengan operator baru.
Peran Konstruktor
(1) Inisialisasi objek
(2) memperkenalkan lebih banyak fleksibilitas (penugasan variabel atau operasi yang lebih kompleks)
(3) Konstruktor tidak dapat didefinisikan dalam Java
Konstruktor tidak dapat didefinisikan dalam Java, dan sistem akan secara otomatis menghasilkan konstruktor default untuk sistem. Nama konstruktor ini sama dengan nama kelas, tidak memiliki parameter formal dan tidak melakukan operasi apa pun.
Tinjauan Metode
Program Java terdiri dari definisi kelas, dan kelas memiliki dua bagian: properti dan metode. Apa itu kelas deskripsi atribut, dan apa yang dilakukan kelas deskripsi metode. Objek apa pun memiliki memori independen untuk menyimpan propertinya. Semua objek kelas berbagi metode yang disimpan dalam memori.
Dengan kata lain: Metode adalah komponen utama kelas. Dalam kelas, peran program tercermin dalam metode ini.
Metode ini adalah membuat subrutin bernama oleh Java. Metode utama dan beberapa sub-metode. Metode utama memanggil metode lain, dan metode lain juga dapat dipanggil satu sama lain, dan metode yang sama dapat dipanggil kapan saja dengan satu atau lebih metode.
Mendefinisikan metode lain dalam satu metode akan menghasilkan kesalahan sintaksis.
(1) Yang terbaik adalah menghindari variabel variabel "mask" lokal. Ini dapat dilakukan tanpa menggunakan pengidentifikasi dengan nama yang sama di kelas; Parameter dalam panggilan metode digunakan untuk meneruskan nilai dan referensi numerik, dan metode juga dapat dipanggil dalam bersarang dan secara rekursif.
(2) Jika tipe nilai pengembalian non-void ditentukan dalam badan metode, metode harus menyertakan pernyataan pengembalian untuk memastikan bahwa ada nilai pengembalian dalam kasus apa pun, dan pernyataan pengembalian tidak dapat diikuti oleh ekspresi apa pun;
Struktur dasar program Java adalah sebagai berikut:
Perkenalkan Perpustakaan Kelas Java; Tentukan Kelas Pengguna 1 {Tentukan beberapa variabel atau objek Kelas 1: Tentukan Metode 1 dari Kelas 1; Tentukan Metode 2 dari Kelas 1; … Tentukan metode M1 dari Kelas 1; } Tentukan kelas pengguna 2 {tentukan beberapa variabel atau objek kelas 2: tentukan metode 1 dari kelas 2; Tentukan Metode 2 dari Kelas 2; … Tentukan Metode M2 dari Kelas 2}Java memperkenalkan konsep "pengubah kontrol akses" yang memungkinkan pencipta perpustakaan untuk mendeklarasikan apa yang dapat digunakan oleh programmer klien dan apa yang tidak dapat digunakan.
Tingkat kontrol akses ini adalah antara kisaran "akses maksimum" dan "akses minimum", termasuk: publik, "default" (tidak ada kata kunci), dilindungi dan pribadi. Daftar berikut menjelaskan arti pengubah kontrol akses:
Karakter Kontrol Akses Publik
Untuk kelas:
Hanya ada satu pengontrol akses untuk kelas di Java: publik, yaitu publik. Kelas dinyatakan sebagai kelas publik, menunjukkan bahwa ia dapat diakses dan dirujuk oleh semua kelas lainnya. Akses dan referensi di sini mengacu pada kelas yang terlihat dan dapat digunakan secara keseluruhan. Bagian lain dari program ini dapat membuat objek kelas ini, mengakses variabel anggota yang terlihat di dalam kelas, dan menyebut metode yang terlihat.
Kelas terlihat oleh bagian lain dari program secara keseluruhan, dan tidak menyatakan bahwa semua properti dan metode di kelas juga terlihat oleh bagian lain dari program. Yang pertama hanyalah kondisi yang diperlukan untuk yang terakhir. Apakah properti dan metode kelas dapat diakses oleh semua kelas lain tergantung pada karakter kontrol akses dari properti dan metode ini.
Digunakan untuk properti di kelas:
Atribut di dalam kelas yang dimodifikasi dengan publik disebut atribut publik. Jika kelas ini adalah kelas publik, ia dapat diakses oleh semua kelas lainnya.
Kontrol akses default
Digunakan untuk kelas
Jika suatu kelas tidak memiliki karakter kontrol akses, itu berarti memiliki karakteristik kontrol akses default. Kontrol akses default ini menetapkan bahwa kelas hanya dapat diakses dan dirujuk oleh kelas dalam paket yang sama, dan tidak dapat digunakan oleh kelas dalam paket lain. Fitur akses ini disebut paket aksesibilitas. Dengan mendeklarasikan karakter kontrol akses kelas, seluruh struktur program dapat jelas dan ketat, mengurangi kemungkinan gangguan antar kelas dan kesalahan.
Digunakan untuk atribut kelas
Jika properti dan metode dalam kelas tidak dibatasi oleh simbol kontrol akses, mereka juga menunjukkan bahwa mereka adalah aksesibilitas paket.
3 Karakter Kontrol Akses Pribadi Pribadi
Atribut atau metode yang dimodifikasi dengan pribadi hanya dapat diakses dan dimodifikasi oleh kelas itu sendiri, dan tidak dapat diperoleh dan direferensikan oleh kelas lain, termasuk subkelas kelas.
1). Data pribadi, misalnya, memiliki tiga bidang instance, yang berisi data yang dioperasikan di dalam contoh kelas karyawan.
nama string pribadi;
gaji ganda pribadi;
kencan pribadi sewa;
Kata kunci pribadi digunakan untuk memastikan bahwa bidang instance ini hanya dapat diakses oleh kelas karyawan itu sendiri.
2). Metode Private Saat mengimplementasikan kelas, kami membuat semua bidang data pribadi karena data publik berbahaya. Apa situasi dengan metode ini? Meskipun sebagian besar metode bersifat publik, metode pribadi juga sering digunakan. Metode ini hanya dapat dipisahkan dengan metode yang sama.
Singkatnya, metode pribadi dapat dipilih dalam kasus -kasus berikut:
(1) Metode -metode yang tidak terkait dengan pengguna kelas.
(2) Metode -metode yang tidak mudah dipertahankan jika implementasi kelas diubah.
Karakter Kontrol Akses Lindung Dilindungi
Variabel anggota yang dimodifikasi dengan dilindungi dapat dirujuk oleh tiga jenis: kelas itu sendiri, kelas lain dalam paket yang sama seperti itu, dan subclass kelas dalam paket lain. Tujuan utama menggunakan pengubah yang dilindungi adalah untuk memungkinkan subkelasnya di paket lain untuk mengakses properti spesifik dari kelas induk.
Kata kunci yang dilindungi memperkenalkan kita pada konsep yang disebut "warisan", yang didasarkan pada kelas yang ada dan menambahkan anggota baru ke dalamnya tanpa mempengaruhi kelas yang ada - kami menyebut ini kelas dasar "kelas dasar" atau "kelas dasar". Itu juga dapat mengubah perilaku anggota yang ada dari kelas itu. Untuk warisan dari kelas yang sudah ada, kami mengatakan bahwa kelas baru kami "memperluas" kelas yang sudah ada
Karakter Kontrol Akses Lindung Pribadi Dilindungi Pribadi
Pribadi dan terlindungi digunakan secara berurutan untuk membentuk karakter kontrol akses lengkap: Karakter Kontrol Akses Perlindungan Pribadi. Variabel anggota yang dimodifikasi dengan Private -Protected dapat diakses dan direferensikan oleh dua kelas, satu adalah kelas itu sendiri, dan yang lainnya adalah semua subclass dari kelas, apakah subkelas ini berada dalam paket yang sama dengan kelas atau dalam paket lain.
Dibandingkan dengan yang dilindungi, pengubah yang dilindungi swasta tidak termasuk non-subkelas dalam paket yang sama dari ruang lingkup yang dapat diakses, membuat variabel anggota lebih eksklusif ke kelas dengan hubungan warisan eksplisit daripada paket yang dikelompokkan secara longgar bersama.
Pengubah statis
Statis disebut pengubah statis, yang memodifikasi sifat dan metode di kelas.
Menggunakan kata kunci statis dapat memenuhi dua persyaratan:
(1) Satu situasi adalah Anda hanya ingin menggunakan area penyimpanan untuk menyimpan data tertentu - tidak peduli berapa banyak objek yang ingin Anda buat, Anda bahkan tidak membuat objek sama sekali; Atribut yang dimodifikasi oleh statis disebut sifat statis, dan salah satu fitur paling penting dari jenis atribut ini adalah bahwa mereka adalah atribut dari suatu kelas, bukan objek spesifik dari kelas apa pun. Dengan kata lain, untuk objek spesifik kelas ini, properti statis adalah unit penyimpanan umum. Ketika objek kelas mana pun mengaksesnya, itu mendapatkan nilai numerik yang sama. Ketika objek apa pun dari kelas apa pun memodifikasinya, ia juga melakukan operasi pada unit memori yang sama.
(2) Situasi lain adalah bahwa kita membutuhkan metode khusus yang tidak terkait dengan objek kelas ini. Artinya, bahkan jika objek tidak dibuat, metode yang dapat dipanggil langsung oleh kelas diperlukan.
Tujuan penting statis adalah untuk membantu kita memanggil metode itu tanpa harus membuat objek.
Konstanta statis
Variabel statis jarang terjadi. Namun, konstanta statis adalah umum. Misalnya, konstanta statis didefinisikan dalam kelas matematika:
Matematika kelas publik
{… Pubin final statis pi pi = 3.1.4159265358979323846;…} Metode statis menyatakan bahwa metode statis memiliki setidaknya tiga makna:
(1) Saat menggunakan metode ini, nama kelas harus digunakan sebagai awalan, bukan nama objek tertentu;
(2) Metode non-statis adalah metode milik suatu objek. Ketika objek ini dibuat, metode objek memiliki segmen kode khusus dalam memori; Sementara metode statis milik seluruh kelas, dan segmen kodenya dalam memori akan dialokasikan dan dimuat sesuai dengan definisi kelas dan tidak akan eksklusif untuk objek apa pun;
(3) Karena metode statis milik seluruh kelas, ia tidak dapat memanipulasi dan memproses variabel anggota milik objek tertentu, tetapi hanya dapat memproses variabel anggota yang termasuk seluruh kelas.
5 metode utama
Metode utama tidak menerapkan operasi untuk objek apa pun. Bahkan, ketika program mulai dieksekusi, belum ada objek. Metode statis dijalankan dan objek yang diperlukan oleh program dibangun.
Ini meminta bahwa setiap kelas dapat memiliki metode utama. Ini adalah trik yang sangat nyaman untuk kelas tes unit.
Abstrak adalah pengubah abstrak yang dapat digunakan untuk memodifikasi kelas atau metode.
Kelas abstrak
Ketika kelas dinyatakan sebagai abstrak, kelas ini disebut kelas abstrak. Kelas abstrak yang disebut adalah kelas tanpa objek instance konkret.
Untuk mengatasi masalah ini, Java menyediakan mekanisme yang disebut "Metode Abstrak". Itu milik metode yang tidak lengkap, dengan hanya satu deklarasi, dan tidak memiliki badan metode. Berikut adalah sintaks yang digunakan saat mendeklarasikan metode abstrak:
abstrak void x ();
Metode abstrak
Sebagai pengubah metode kelas, abstrak menyatakan metode abstrak yang hanya memiliki header metode tetapi tidak ada metode metode spesifik dan implementasi operasi.
Dapat dilihat bahwa metode abstrak hanya memiliki deklarasi header metode, dan titik koma digunakan untuk menggantikan definisi badan metode: seperti untuk implementasi spesifik dari badan metode, diselesaikan oleh subkelas yang berbeda dari kelas saat ini dalam definisi kelas masing -masing.
Perlu dicatat bahwa semua metode abstrak harus ada di kelas abstrak
tengah.
Selain metode abstrak, kelas abstrak juga dapat memiliki data dan metode konkret.
Metode abstrak adalah konsep yang sangat penting dalam bahasa pemrograman Java. Anda akan menggunakannya dalam banyak hal di antarmuka.
Catatan: Di sini kita perlu membandingkan dan menghafal dengan antarmuka. Metode dalam antarmuka adalah semua metode abstrak. Tentu saja, ada juga atribut dalam antarmuka, dan sifat spesifiknya akan dijelaskan secara rinci nanti.
Kelas Akhir, Atribut Akhir, Metode Akhir dan Finalizer (tidak ada pengubah akhir dalam C ++)
Final adalah pengubah akhir, yang memodifikasi kelas, properti, dan metode. Selain itu, kata kunci terminal sangat mirip dengan final, dan akan diperkenalkan bersama
Kelas terakhir
Jika suatu kelas dinyatakan final, itu berarti tidak dapat memperoleh subkelas baru dan tidak dapat diwarisi sebagai kelas induk. Oleh karena itu, kelas tidak dapat dinyatakan baik abstrak dan final.
Kelas yang didefinisikan sebagai final biasanya beberapa kelas dengan fungsi khusus yang digunakan untuk menyelesaikan fungsi standar. Mendefinisikan kelas sebagai final dapat memperbaiki konten, atribut, dan fungsi dan membentuk hubungan pemetaan yang stabil dengan nama kelasnya, sehingga memastikan bahwa fungsi yang diimplementasikan ketika mengacu pada kelas ini akurat.
Atribut akhir
Banyak bahasa pemrograman memiliki cara mereka sendiri untuk memberi tahu kompiler bahwa data tertentu adalah "konstan". Konstanta terutama digunakan dalam dua aspek berikut:
(1) Periode Kompilasi Konstan, itu tidak akan pernah berubah;
(2) Kami tidak ingin nilai yang diinisialisasi selama runtime berubah.
Bidang instan dapat didefinisikan sebagai final (tidak dapat diubah). Bidang ini harus diinisialisasi ketika objek dibangun. Artinya, harus dipastikan bahwa nilainya telah ditetapkan sebelum akhir setiap konstruktor. Nilai bidang tidak dapat diubah di masa depan
Metode terakhir
Alasan untuk menggunakan metode akhir mungkin karena pertimbangan karena dua alasan.
Yang pertama adalah "mengunci" metode untuk mencegah kelas warisan mengubah makna aslinya. Saat merancang suatu program, praktik ini dapat diambil jika Anda ingin perilaku metode tetap tidak berubah selama warisan dan tidak dapat ditimpa atau ditulis ulang.
Alasan kedua untuk mengadopsi metode akhir adalah efisiensi eksekusi program
Terminator
Fungsi terminator adalah metode yang dijalankan saat mengambil objek. Mirip dengan metode yang konstruktor dieksekusi saat membuat objek.
contoh
voidFinalize yang dilindungi () {System.out.println (""); }Pengubah lainnya
tidak stabil
Jika atribut dimodifikasi oleh volatile, itu berarti bahwa atribut ini dapat dikontrol dan dimodifikasi oleh beberapa utas secara bersamaan.
disinkronkan
Terutama digunakan untuk sinkronisasi utas
warga asli
Ini berarti bahwa metode ini tidak ditulis dalam bahasa Java (ditulis dalam C, C ++ dan bahasa lain)
Beberapa informasi yang ditemukan secara online: - Kategori internal
Sederhananya, kelas internal adalah kelas di kelas, misalnya:
Class A {private int i; private void m () {} class b {mm (int j) {i = j; m ();}}}Di sini, B adalah kelas internal A, yang ditandai dengan akses mudah ke metode dan properti pribadi di kelas eksternal. Misalnya, di sini B dapat secara langsung mengakses properti pribadi I dan metode pribadi m () di A.
Fitur terpenting dari pemrograman berorientasi objek adalah enkapsulasi (juga disebut abstraksi), warisan dan polimorfisme. Sebagai bahasa pemrograman yang berorientasi objek, Java memiliki keunggulannya sendiri dalam hal ini:
"Warisan adalah bentuk penggunaan kembali perangkat lunak, yang efektif dalam mengurangi kompleksitas perangkat lunak. Warisan juga merupakan fitur dari bahasa pemrograman yang berorientasi objek. Bahasa yang mengadopsi objek tetapi tidak memiliki warisan adalah bahasa berbasis objek, tetapi bukan bahasa yang berorientasi objek. Ini adalah perbedaan antara keduanya."
Hubungan warisan antar kelas adalah simulasi langsung hubungan genetik di dunia nyata. Ini mewakili hubungan intrinsik antara kelas dan berbagi atribut dan operasi, yaitu, subclass dapat mengikuti fitur tertentu dari kelas induk (kelas warisan). Tentu saja, subkelas juga dapat memiliki properti dan operasi independen mereka sendiri
Warisan adalah bentuk penggunaan kembali perangkat lunak. Kelas baru dihasilkan oleh kelas yang ada, dan atribut dan perilaku baru ditambahkan dengan mempertahankan sifat dan perilaku mereka, dan memodifikasi kinerja sesuai dengan persyaratan kelas baru. Jika kelas anak hanya mewarisi dari satu kelas orang tua, itu disebut warisan tunggal; Jika kelas anak mewarisi dari lebih dari satu kelas orang tua, itu disebut multi-warisan. Perhatikan bahwa Java tidak mendukung banyak warisan, tetapi mendukung konsep "antarmuka". Antarmuka memungkinkan Java untuk mendapatkan banyak keuntungan dari warisan berganda dan meninggalkan kerugian yang sesuai. Catatan: C ++ mendukung warisan berganda
Definisi hubungan warisan:
[Pengubah] Nama Subkelas Kelas Memperpanjang Nama Kelas Induk, Nama Kelas Induk 2 2
Nama kelas induk mengikuti meluas
Kata kunci digunakan untuk menunjukkan subkelas mana dari kelas saat ini sudah ada, dan ada hubungan warisan.
Tentukan dua subclass karyawan kelas karyawan:
Kategori Karyawan Umum: CommoniMereee
Kategori Supervisor: ManajerMir Kerja
Ada dua aspek utama warisan subkelas dari kelas induk:
(1) Warisan atribut. Misalnya, perusahaan adalah kelas induk, dan perusahaan memiliki nama, alamat, manajer, karyawan, dll., Yang semuanya merupakan aspek struktural.
(2) Metode warisan. Kelas orang tua mendefinisikan beberapa operasi, seperti perusahaan yang perlu memiliki proyek, laba, penunjukan manajer, merekrut karyawan, dll., Dan anak perusahaan juga akan mewarisi tindakan ini;
ClassCommonEmplyeextends karyawan // Subclass 1: {intm_managerno; // Tentukan atribut kelas m_managerno, mewakili nomor bos karyawan} classManagerEmployeeExtends karyawan // subclass 2: {intm_secretaryno;/ Atribut warisan dan persembunyian
Meskipun kelas karyawan adalah kelas orang tua, itu tidak berarti bahwa ia memiliki lebih banyak fungsi hanya karena itu adalah kelas orang tua. Sebaliknya, sub-analog memiliki lebih banyak fungsi daripada kelas induknya. Karena subkelas adalah perpanjangan dari kelas induk, atribut dan metode yang tidak dimiliki kelas induk ditambahkan (1) subkelas tidak dapat mengakses anggota pribadi kelas induk, tetapi subclass dapat mengakses publik dari kelas induknya.
(2) Akses yang dilindungi adalah tingkat perantara pelindung antara akses publik dan pribadi.
(3) Karena anggota kelas induk yang diwariskan tidak tercantum dalam deklarasi subkelas, anggota ini ada di subkelas.
Di sini, kita perlu membedakan antara warisan, timpa dan kelebihan beban, beberapa konsep yang membingungkan:
Hanya pada tingkat konseptual metode ketiga konsep ini dapat dengan mudah bingung:
Metode Warisan
Untuk objek subkelas, metode dari kelas induk dapat digunakan. Bahkan jika metode ini tidak didefinisikan dengan jelas dalam subkelas, mereka secara otomatis diwariskan dari kelas induk.
Cakupan metode
Metode Override mengacu pada: metode yang mendefinisikan metode dengan nama yang sama untuk menimpa kelas induk, yang merupakan implementasi teknologi polimorfik. Ketika metode kelas induk ditimpa di kelas anak, biasanya versi kelas anak yang memanggil versi kelas induk dan melakukan beberapa pekerjaan tambahan.
Ada banyak hal yang perlu diperhatikan. Di sini, saya terutama menyebutkan ini dan super. Ada ini di C ++ (dan konsepnya mirip dengan yang ada di Java), tetapi tidak ada super.
Ini mewakili objek saat ini itu sendiri, dan ini merupakan referensi ke objek saat ini. Itu dapat dipahami sebagai nama lain dari objek. Ini memungkinkan Anda untuk memanggil metode dan sifat objek saat ini.
Misalnya: this.getName () dan getName () sama di kelas.
Super mewakili objek kelas induk langsung dari objek saat ini, dan merupakan metode referensi yang berlebihan dari objek kelas induk dari objek saat ini.
Definisi Overload: Metode ini dapat didefinisikan dengan nama metode yang sama tetapi tabel parameter yang berbeda (angka, jenis, atau urutan parameter dalam tabel parameter memiliki nilai yang berbeda), yang disebut metode kelebihan metode.
• Overloading: Overloading terjadi ketika beberapa metode memiliki nama yang sama dan berisi parameter yang berbeda. Kompiler harus memilih metode mana yang akan dihubungi. Ini memilih metode yang benar dengan membandingkan tipe parameter di header metode yang berbeda dengan jenis nilai yang digunakan dalam panggilan metode tertentu.
Polimorfisme memungkinkan pemrosesan variabel yang ada dan kelas terkait dalam gaya terpadu, membuatnya mudah untuk menambahkan fitur baru dalam sistem. Di sini, memposting informasi yang Anda temukan secara online dapat lebih jelas mengklarifikasi polimorfisme dan masalah warisan yang membutuhkan perhatian khusus dalam warisan:
Polimorfisme Java
Pemrograman berorientasi objek memiliki tiga karakteristik, yaitu enkapsulasi, warisan dan polimorfisme.
Enkapsulasi menyembunyikan mekanisme implementasi internal kelas, sehingga struktur internal kelas dapat diubah tanpa mempengaruhi pengguna, sambil melindungi data.
Warisan adalah menggunakan kembali kode kelas induk sambil mempersiapkan implementasi polimorfisme. Jadi apa itu polimorfisme?
Metode penulisan ulang, kelebihan beban, dan koneksi dinamis merupakan polimorfisme. Salah satu alasan mengapa Java memperkenalkan konsep polimorfisme adalah bahwa ia berbeda dari C ++ dalam hal warisan kelas. Yang terakhir memungkinkan banyak warisan, yang memang membawanya fungsi yang sangat kuat, tetapi hubungan warisan yang kompleks juga membawa masalah yang lebih besar bagi pengembang C ++. Untuk menghindari risiko, Java hanya memungkinkan warisan tunggal, dan ada hubungan IS-A antara kelas yang diturunkan dan kelas dasar (mis. "Kucing" adalah "hewan"). Meskipun melakukan ini memastikan kesederhanaan dan kejelasan hubungan warisan, itu pasti akan memiliki keterbatasan fungsional yang besar. Oleh karena itu, Java memperkenalkan konsep polimorfisme untuk menebus kekurangan ini. Selain itu, kelas dan antarmuka abstrak juga merupakan cara penting untuk menyelesaikan keterbatasan peraturan warisan tunggal. Pada saat yang sama, polimorfisme juga merupakan inti dari pemrograman yang berorientasi objek.
Untuk memahami polimorfisme, Anda harus terlebih dahulu tahu apa itu "transformasi ke atas".
Saya mendefinisikan kucing subkelas, yang mewarisi kelas hewan, dan yang terakhir adalah bahwa yang pertama adalah kelas induk. Saya bisa lulus
Kucing c = kucing baru ();
Instantiasi objek kucing tidak sulit untuk dipahami. Tetapi ketika saya mendefinisikannya seperti ini:
Hewan a = kucing baru ();
Apa artinya ini?
Sederhana saja, itu berarti bahwa saya mendefinisikan referensi tipe hewan ke objek tipe kucing yang baru dibuat. Karena CAT diwarisi dari hewan kelas induknya, referensi ke jenis hewan dapat menunjuk ke objek jenis kucing. Jadi apa gunanya melakukan ini? Karena subclass merupakan peningkatan dan ekstensi ke kelas induk, subkelas umumnya lebih kuat daripada kelas orang tua dalam fungsi, dan atributnya lebih unik daripada kelas orang tua.
Mendefinisikan referensi ke tipe kelas induk menunjuk ke objek yang disubkelas tidak hanya dapat menggunakan fungsi yang kuat dari subkelas, tetapi juga mengekstraksi kesamaan kelas induk.
Oleh karena itu, referensi ke jenis kelas induk dapat memanggil semua properti dan metode yang ditentukan dalam kelas induk, dan tidak berdaya untuk metode yang ditentukan dalam kelas anak tetapi tidak dalam kelas induk;
Pada saat yang sama, metode di kelas induk hanya dapat dipanggil dengan referensi ke jenis kelas induk jika didefinisikan dalam kelas induk tetapi tidak ditimpa di kelas anak;
Untuk metode yang ditentukan dalam kelas induk, jika metode ini ditulis ulang di kelas anak, referensi ke jenis kelas induk akan memanggil metode ini di kelas anak, yang merupakan koneksi dinamis.
Lihatlah program berikut:
kelas ayah {public void func1 () {func2 (); } // Ini adalah metode func2 () di kelas induk, karena metode ini ditimpa dalam subkelas di bawah ini // Jadi ketika dipanggil dalam referensi jenis kelas induk, metode ini tidak akan lagi valid // mengganti metode func2 () yang diganti dalam subclass public func2 () {System.out.println ("aaa"); } } class Child extends Father{ //func1(int i) is an overload of the func1() method // Since this method is not defined in the parent class, it cannot be called by the reference of the parent class type //So in the main method below child.func1(68) is wrong public void func1(int i){ System.out.println("BBB"); } // func2 () Menulis ulang metode func2 () di kelas induk ayah // jika metode func2 () dipanggil dalam referensi ke jenis kelas induk, itu harus menjadi metode yang ditulis ulang dalam subclass public void func2 () {System.out.println ("CCC"); }} kelas publik PolymorphismTest {public static void main (string [] args) {ayah anak = anak baru (); Child.func1 (); // Bagaimana hasil cetak? }}Program di atas adalah contoh polimorfisme yang sangat khas. Anak kelas anak mewarisi ayah kelas induk, berlebihan metode kelas induk Func1 (), dan menimpa metode kelas induk Func2 (). Func1 yang kelebihan beban (int i) dan func1 () tidak lagi merupakan metode yang sama. Karena tidak ada func1 (int i) di kelas induk, anak referensi dari jenis kelas induk tidak dapat memanggil metode func1 (int i). Jika subclass mengesampingkan metode func2 (), maka anak referensi dari jenis kelas induk akan memanggil func2 yang ditulis ulang () di subkelas saat memanggil metode.
Jadi hasil apa yang akan dicetak program?
Jelas, itu harus "CCC".
Untuk polimorfisme, itu dapat diringkas sebagai:
(1) Gunakan referensi tipe kelas induk untuk menunjuk ke objek subkelas (objek aktual);
(2) referensi ini hanya dapat memanggil metode dan variabel yang ditentukan dalam kelas induk;
(3) Jika metode dalam kelas induk ditulis ulang di subkelas, maka ketika memanggil metode ini, metode dalam subkelas akan dipanggil; (Koneksi dinamis, panggilan dinamis)
(4) Variabel tidak dapat ditulis ulang (ditimpa). Konsep "penulisan ulang" hanya untuk metode. Jika variabel dalam kelas induk "menulis ulang" di subkelas, kesalahan akan dilaporkan selama kompilasi.
Polimorfisme adalah melalui:
(1) Antarmuka dan mengimplementasikan antarmuka dan menimpa beberapa kelas berbeda yang mencakup metode yang sama di antarmuka (2) kelas induk dan kelas induk dan kelas induk dan menimpa beberapa subclass berbeda yang mencakup metode yang sama di kelas induk.
1. Konsep Dasar
Polimorfisme: Kirim pesan ke suatu objek dan biarkan objek memutuskan perilaku mana yang harus ditanggapi.
Panggilan metode dinamis diimplementasikan dengan menetapkan referensi objek subkelas ke variabel referensi objek superclass.
Mekanisme AVA ini mengikuti prinsip: Ketika objek superclass mengacu pada variabel untuk merujuk pada objek subkelas, jenis objek yang dirujuk daripada jenis variabel yang direferensikan menentukan metode anggota yang dipanggil, tetapi metode yang dipanggil harus didefinisikan dalam superclass, yaitu metode yang dicakup oleh subkelas.
(1) Jika A adalah referensi ke kelas A, maka A dapat menunjuk ke instance kelas A, atau ke subclass kelas A.
(2) Jika a adalah referensi ke antarmuka A, maka harus menunjuk ke instance kelas yang mengimplementasikan antarmuka A.
Mekanisme implementasi polimorfisme java
Mekanisme implementasi JVM Sun saat ini, referensi instance kelas adalah penunjuk ke pegangan, yang merupakan sepasang pointer:
Pointer menunjuk ke tabel, dan pada kenyataannya, tabel ini juga memiliki dua pointer (satu pointer menunjuk ke tabel metode yang berisi objek, dan pointer lainnya ke objek kelas, menunjukkan jenis yang dimiliki objek);
Pointer lain menunjuk ke sepotong ruang memori yang dialokasikan dari tumpukan Java.
Meringkaskan
(1) Panggilan metode dinamis diimplementasikan dengan menetapkan referensi objek subkelas ke variabel referensi objek superclass.
Turunan c2 = new duevedc (); Baseclass A1 = C2; // kelas dasar baseclass, DerivedC adalah a1.play () diwarisi dari baseclass; //play() is defined in BaseClass and DerivedC, that is, the subclass overrides the method
menganalisa:
* 为什么子类的类型的对象实例可以覆给超类引用？
自动实现向上转型。通过该语句，编译器自动将子类实例向上移动，成为通用类型BaseClass；
* A. Will play() execute a method defined by the subclass or a parent class?
子类的。在运行时期，将根据a这个对象引用实际的类型来获取对应的方法。所以才有多态性。一个基类的对象引用，被赋予不同的子类对象引用，执行该方法时，将表现出不同的行为。
在a1=c2的时候，仍然是存在两个句柄，a1和c2，但是a1和c2拥有同一块数据内存块和不同的函数表。
（2）不能把父类对象引用赋给子类对象引用变量
BaseClass a2=new BaseClass(); DerivedC c1=a2;//出错
在java里面，向上转型是自动进行的,但是向下转型却不是，需要我们自己定义强制进行。
c1=(DerivedC)a2; 进行强制转化,也就是向下转型.
（3）记住一个很简单又很复杂的规则，一个类型引用只能引用引用类型自身含有的方法和变量。
你可能说这个规则不对的，因为父类引用指向子类对象的时候，最后执行的是子类的方法的。
其实这并不矛盾，那是因为采用了后期绑定，动态运行的时候又根据型别去调用了子类的方法。而假若子类的这个方法在父类中并没有定义，则会出错。
例如，DerivedC类在继承BaseClass中定义的函数外，还增加了几个函数（例如myFun()）
menganalisa:
当你使用父类引用指向子类的时候，其实jvm已经使用了编译器产生的类型信息调整转换了。
这里你可以这样理解，相当于把不是父类中含有的函数从虚拟函数表中设置为不可见的。注意有可能虚拟函数表中有些函数地址由于在子类中已经被改写了，所以对象虚拟函数表中虚拟函数项目地址已经被设置为子类中完成的方法体的地址了。
（4）Java与C++多态性的比较
jvm关于多态性支持解决方法是和c++中几乎一样的，
只是c++中编译器很多是把类型信息和虚拟函数信息都放在一个虚拟函数表中，但是利用某种技术来区别。
Java把类型信息和函数信息分开放。Java中在继承以后，子类会重新设置自己的虚拟函数表，这个虚拟函数表中的项目有由两部分组成。从父类继承的虚拟函数和子类自己的虚拟函数。
虚拟函数调用是经过虚拟函数表间接调用的，所以才得以实现多态的。
Java的所有函数，除了被声明为final的，都是用后期绑定。
1个行为,不同的对象,他们具体体现出来的方式不一样,
比如: 方法重载overloading 以及方法重写(覆盖)override
class Human{ void run(){输出人在跑} } class Man extends Human{ void run(){输出男人在跑} } 这个时候,同是跑,不同的对象,不一样(这个是方法覆盖的例子) class Test{ void out(String str){输出str} void out(int i){输出i} }这个例子是方法重载,方法名相同,参数表不同
ok,明白了这些还不够,还用人在跑举例
Human ahuman=new Man();
这样我等于实例化了一个Man的对象,并声明了一个Human的引用,让它去指向Man这个对象意思是说,把Man这个对象当Human看了.
比如去动物园,你看见了一个动物,不知道它是什么, "这是什么动物? " "这是大熊猫! "
这2句话,就是最好的证明,因为不知道它是大熊猫,但知道它的父类是动物,所以,
这个大熊猫对象,你把它当成其父类动物看,这样子合情合理.
这种方式下要注意new Man();的确实例化了Man对象,所以ahuman.run()这个方法输出的是"男人在跑"
如果在子类Man下你写了一些它独有的方法比如eat(),而Human没有这个方法,
在调用eat方法时,一定要注意强制类型转换((Man)ahuman).eat(),这样才可以...
对接口来说,情况是类似的...
Contoh:
package domatic; //定义超类superA class superA { int i = 100; void fun(int j) { j = i; System.out.println("This is superA"); } } // 定义superA的子类subB class subB extends superA { int m = 1; void fun(int aa) { System.out.println("This is subB"); } } // 定义superA的子类subC class subC extends superA { int n = 1; void fun(int cc) { System.out.println("This is subC"); } } class Test { public static void main(String[] args) { superA a = new superA(); subB b = new subB(); subC c = new subC(); a = b; a.fun(100); a = c; a.fun(200); } } /*
* 上述代码中subB和subC是超类superA的子类,我们在类Test中声明了3个引用变量a, b,
* c,通过将子类对象引用赋值给超类对象引用变量来实现动态方法调用。也许有人会问：
* "为什么(1)和(2)不输出：This is superA"。
* java的这种机制遵循一个原则：当超类对象引用变量引用子类对象时,
* 被引用对象的类型而不是引用变量的类型决定了调用谁的成员方法,
* 但是这个被调用的方法必须是在超类中定义过的,
* 也就是说被子类覆盖的方法。
* 所以,不要被上例中(1)和(2)所迷惑,虽然写成a.fun(),但是由于(1)中的a被b赋值,
* 指向了子类subB的一个实例,因而(1)所调用的fun()实际上是子类subB的成员方法fun(),
* 它覆盖了超类superA的成员方法fun()；同样(2)调用的是子类subC的成员方法fun()。
* 另外,如果子类继承的超类是一个抽象类,虽然抽象类不能通过new操作符实例化,
* 但是可以创建抽象类的对象引用指向子类对象,以实现运行时多态性。具体的实现方法同上例。
* 不过,抽象类的子类必须覆盖实现超类中的所有的抽象方法,
* 否则子类必须被abstract修饰符修饰,当然也就不能被实例化了
*/
以上大多数是以子类覆盖父类的方法实现多态.下面是另一种实现多态的方法-----------重写父类方法
JAVA里没有多继承，一个类之能有一个父类。而继承的表现就是多态。一个父类可以有多个子类，而在子类里可以重写父类的方法（例如方法print()），这样每个子类里重写的代码不一样，自然表现形式就不一样。这样用父类的变量去引用不同的子类，在调用这个相同的方法print()的时候得到的结果和表现形式就不一样了，这就是多态，相同的消息（也就是调用相同的方法）会有不同的结果。举例说明：
//父类public class Father{ //父类有一个打孩子方法public void hitChild(){ } } //子类1 public class Son1 extends Father{ //重写父类打孩子方法public void hitChild(){ System.out.println("为什么打我？我做错什么了！"); } } //子类2 public class Son2 extends Father{ //重写父类打孩子方法public void hitChild(){ System.out.println("我知道错了，别打了！"); } } //子类3 public class Son3 extends Father{ //重写父类打孩子方法public void hitChild(){ System.out.println("我跑，你打不着！"); } } //测试类public class Test{ public static void main(String args[]){ Father father; father = new Son1(); father.hitChild(); father = new Son2(); father.hitChild(); father = new Son3(); father.hitChild(); } }都调用了相同的方法，出现了不同的结果！这就是多态的表现！
import java.io.*;class Super{ Super(){ System.out.println("This is super class!"); } void method(){ System.out.println("Super's method"); }}class Sub extends Super{ Sub(){ super(); System.out.println("/n/t:and here is the child"); } void method(){ System.out.println("child's method"); }}public class Super_Sub{ public static void main(String[] args){ Super sup=new Sub(); sup.method(); Sub child=(Sub)new Super();//这里，实际分配的内存是Super的，但是却用Child来指代它，这就是“向下转型”(父类冒充子类，因为子类在UML中画时是在下的嘛),必经强制类型转换child.method(); }}对于数据来说，继承是否为正确的设计可以用一个简单的规则来判断。“is-a”规则表明子类的每一个对象都是一个超类的对象。例如，每一个经理是一个员工。然而，只有经理类是员工类的子类才是有意义的。很明显，反过来就不行了――并不是每个员工都是经理。
还有一个明确叙述“is-a”规则的方法是替代原则。该原则规定无论何时，如果程序需要一个超类对象，都可以用一个子类对象来代替
动态绑定
理解调用一个对象方法的机制是非常重要的。下面具体介绍：Xf；
（1）编译器检查对象的声明类型和方法名。
(2) Next, the compiler checks the parameter type in the method call. If one of all methods called f has a parameter type whose parameter type best matches the parameter type provided by the call, the method will be selected to call. This process is called overload selection. (statis)
（3）当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用同x所指向的对象的实际类型相匹配的方法版本。
...
如果类中没有写构造函数，那么系统会自动为该类提供一个默认构造函数，该构造函数将所有的实例字段初始化为默认值：
...
包用途:
Java允许把多个类收集在一起成为一组，称作包（package）。包便于组织任务，以及使自己的任务和其他人提供的代码库相分离。
标准Java库被分类成许多的包，其中包括java.1ang、java.util和java.net等等。标准Java包是分层次的。就像在硬盘上嵌套有各级子目录一样，可以通过层次嵌套组织包。所有的Java包都在Java和Javax包层次内
创建包
已经看到，已有的库，比如JavaAPI中的类和接口，可以导入到Java程序中。
Java API中的每一个类和接口属于一个特定的包。它包含一组相关联的类和接口，实际是对类和接口进行组织的目录结构。
例如，假定文件名是MyClass.java。它意味着在那个文件有一个、而且只能有一个public类。而且那个类的名字必须是MyClass（包括大小写形式）：
packagemypackage;publicclass MyClass{……}创建可复用的类的步骤简要说明如下：
（1）定义一个public类。如果类不是public，它只能被同一包中的其他类使用。
（2）选择一个包名，并把package语句加到可复用的类的源代码文件中。
（3）编译这个类。这样，它就被放到适当的包目录结构中，以供编译器和解译器使用。
（4）把这个可复用的类导入到需要用它的程序中。现在就可以使用它了。
注意在Java语言中可以出现在类定义的括号外面的仅有两个语句，它们是package和import。
包引用---每个类名前加上完整的包名
例如，给出一个指向此包中的类的快捷方式。一旦使用import（导入）了以后，就不再需要给出完整的包名。
可以引入一个特定的类，也可以引入整个包。import语句要放在源文件的头部（但在所有package语句的下面）。例如，可以通过下面的语句引入在java.util包中的所有的类：
importjava.util.*;
然后，就可以使用
Datetoday=new Date();
而不需要在前面加上包名。也可以引入包中某个特定的类：
importjava.util.Date;
要把类放人一个包中，必须把此包的名字放在源文件头部，并且放在对包中的类进行定义的代码之前。例如，在文件Employee.java的开始部分如下：
packagecom.horstmann.corejava;publicclass Employee{……}把包中的文件放入与此完整的包名相匹配的子目录中。例如，在包com.horstmann.corejava中的所有的类文件都必须放在子目录com/horstmann/core.java（Windows下的com/horstmann/corejava）下。这是最简单的一种方法
类被存储在文件系统的子目录中。类的路径必须与所在包名相匹配。
在前面的例子中，包目录com/horstmann/corejava是程序目录的一个子目录。然而这样安排很不灵活。一般，有多个程序需要访问包文件。为了使包可以在多个程序间共享，需要做以下事情：
1）把类放在一个或多个特定的目录中，比如/home/user/classdir。此目录是包树的基本目录。如果加入了类com.horstmann.corejava.Employee，那么此类文件必须位于子目录/home/user/classdir/com/horstmann/corejava下。
2）设置类路径。类路径是其子目录包含类文件的所有基本目录的集合。classpath
已经接触过public和private访问指示符。
被标记为Public的部件可以被任何类使用，而私有部件只能被定义它们的类使用。如果没有指定public或private，那么部件（即类、方法或变量）可以被同一个包中的所有方法访问。
Java API包
为了简化面向对象的编程过程，Java系统事先设计并实现了一些体现了常用功能的标准类，如用于输入／输出的类，用于数学运算的类，用于图形用户界面设计的类，用于网络处理的类等。这些系统标准类根据实现的功能不同，可以划分成不同的集合，每个集合是一个包，合称为类库。可以引用这些包，也可以创建自己的包。
Java的类库是系统提供的已实现的标准类的集合，是Java编程的API，它可以帮助开发者方便、快捷地开发Java程序
接口主要作用是可以帮助实现类似于类的多重继承的功能。在Java中，出于简化程序结构的考虑，不再支持类间的多重继承而只支持单重继承，即一个类至多只能有一个直接父类。然而在解决实际问题的过程中，仅仅依靠单重继承在很多情况下都不能将问题的复杂性表述完整，需要其他的机制作为辅助。
接口声明
Java中声明接口的语法如下：
[public] interface 接口名[extends 父接口名列表]{ //接口体;//常量域声明[public] [static] [final] 域类型域名=常量值; //抽象方法声明[public] [abstract] 返回值方法名(参数列表) [throw异常列表];}从上面的语法规定可以看出，定义接口与定义类非常相似，实际上完全可以把接口理解成为一种特殊的类，接口是由常量和抽象方法组成的特殊类
（1）接口中的属性都是用final修饰的常量，
（2）接口中的方法都是用abstract修饰的抽象方法，在接口中只能给出这些抽象方法的方法名、返回值和参数列表，而不能定义方法体，即仅仅规定了一组信息交换、传输和处理的“接口”
接口的实现
一个类要实现某个或某几个接口时，有如下的步骤和注意事项：
（1）在类的声明部分，用implements关键字声明该类将要实现哪些接口；
如下：
class类名implements接口{ }（2）如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须实现指定接口的所有抽象方法，即为所有抽象方法定义方法体，而且方法头部分应该与接口中的定义完全一致，即有完全相同的返回值和参数列表；
（3）如果实现某接口的类是abstract的抽象类，则它可以不实现该接口所有的方法。
（4）一个类在实现某接口的抽象方法时，必须使用完全相同的方法头。
（5）接口的抽象方法，其访问限制符都已指定是public，所以类在实现方法时，必须显式地使用public修饰符。
ringkasan:
多重继承是指一个子类继承多个父类。Java不支持多重继承，但Java提供了接口。
子类不能访问父类的private成员，但子类可以访问其父类的public，protected和包访问成员；要访问父类的包访问成员，子类一定要在父类的包内。
子类构造函数总是先调用（显式的或隐式地）其父类的构造函数，以创建和初始化子类的父类成员。
子类的对象可以当作其父类的对象对待，反之则不行（即向上转型）
protected访问是public和private访问之间一个保护性的中间层次。父类方法、子类方法和在同一个包内类的方法都能访问父类的protected成员，但其他方法均不能访问
一个子类对象引用可以隐式地转换成一个父类对象引用。使用显式的类型转换，可以把父类引用转换成子类引用。如果目标不是子类对象，将产生ClassCastException例外处理。