java
Manufaktur industri
Dalam tutorial ini, kita akan belajar tentang pewarisan Java dan jenisnya dengan bantuan contoh.
Pewarisan adalah salah satu fitur utama OOP yang memungkinkan kita membuat kelas baru dari kelas yang sudah ada.
Kelas baru yang dibuat dikenal sebagai subkelas (anak atau kelas turunan) dan kelas yang ada dari mana kelas anak diturunkan dikenal sebagai superclass (kelas induk atau dasar).
extends kata kunci digunakan untuk melakukan pewarisan di Jawa. Misalnya,
class Animal {
// methods and fields
}
// use of extends keyword
// to perform inheritance
class Dog extends Animal {
// methods and fields of Animal
// methods and fields of Dog
} Dalam contoh di atas, Anjing kelas dibuat dengan mewarisi metode dan bidang dari Hewan kelas.
Di sini, Anjing adalah subkelas dan Hewan adalah kelas super.
class Animal {
// field and method of the parent class
String name;
public void eat() {
System.out.println("I can eat");
}
}
// inherit from Animal
class Dog extends Animal {
// new method in subclass
public void display() {
System.out.println("My name is " + name);
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// access field of superclass
labrador.name = "Rohu";
labrador.display();
// call method of superclass
// using object of subclass
labrador.eat();
}
} Keluaran
My name is Rohu I can eat
Dalam contoh di atas, kami telah menurunkan subkelas Anjing dari kelas super Hewan . Perhatikan pernyataannya,
labrador.name = "Rohu";
labrador.eat();
Di sini, labrador adalah objek Anjing . Namun, nama dan eat() adalah anggota Hewan kelas.
Sejak Anjing mewarisi bidang dan metode dari Hewan , kami dapat mengakses bidang dan metode menggunakan objek Anjing .
Di Jawa, pewarisan adalah is-a hubungan. Artinya, kita menggunakan pewarisan hanya jika ada hubungan is-a antara dua kelas. Misalnya,
Di sini, Mobil dapat mewarisi dari Kendaraan , Oranye dapat mewarisi dari Buah , dan seterusnya.
Dalam Contoh 1 , kita melihat objek subclass dapat mengakses metode superclass.
Namun, jika metode yang sama ada di superclass dan subclass, apa yang akan terjadi?
Dalam hal ini, metode di subclass menimpa metode di superclass. Konsep ini dikenal sebagai metode overriding di Java.
class Animal {
// method in the superclass
public void eat() {
System.out.println("I can eat");
}
}
// Dog inherits Animal
class Dog extends Animal {
// overriding the eat() method
@Override
public void eat() {
System.out.println("I eat dog food");
}
// new method in subclass
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// call the eat() method
labrador.eat();
labrador.bark();
}
} Keluaran
I eat dog food I can bark
Pada contoh di atas, eat() metode hadir di kedua superclass Hewan dan subkelas Anjing .
Di sini, kami telah membuat objek labrador dari Anjing .
Sekarang ketika kita memanggil eat() menggunakan objek labrador , metode di dalam Anjing disebut. Ini karena metode di dalam kelas turunan menggantikan metode di dalam kelas dasar.
Ini disebut metode override. Untuk mempelajari lebih lanjut, kunjungi Java Method Overriding.
Catatan :Kami telah menggunakan @Override anotasi untuk memberi tahu kompiler bahwa kami mengganti metode. Namun, anotasi tidak wajib. Untuk mempelajari lebih lanjut, kunjungi Anotasi Java.
Sebelumnya kita melihat bahwa metode yang sama di subkelas menimpa metode di superkelas.
Dalam situasi seperti itu, super kata kunci digunakan untuk memanggil metode kelas induk dari metode kelas anak.
class Animal {
// method in the superclass
public void eat() {
System.out.println("I can eat");
}
}
// Dog inherits Animal
class Dog extends Animal {
// overriding the eat() method
@Override
public void eat() {
// call method of superclass
super.eat();
System.out.println("I eat dog food");
}
// new method in subclass
public void bark() {
System.out.println("I can bark");
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// call the eat() method
labrador.eat();
labrador.bark();
}
} Keluaran
I can eat I eat dog food I can bark
Pada contoh di atas, eat() metode hadir di kedua kelas dasar Hewan dan kelas turunan Anjing . Perhatikan pernyataannya,
super.eat();
Di sini, super kata kunci digunakan untuk memanggil eat() metode yang ada di superclass.
Kita juga dapat menggunakan super kata kunci untuk memanggil konstruktor superclass dari konstruktor subclass. Untuk mempelajari lebih lanjut, kunjungi kata kunci super Java.
Di Java, jika kelas menyertakan protected bidang dan metode, maka bidang dan metode ini dapat diakses dari subkelas kelas.
class Animal {
protected String name;
protected void display() {
System.out.println("I am an animal.");
}
}
class Dog extends Animal {
public void getInfo() {
System.out.println("My name is " + name);
}
}
class Main {
public static void main(String[] args) {
// create an object of the subclass
Dog labrador = new Dog();
// access protected field and method
// using the object of subclass
labrador.name = "Rocky";
labrador.display();
labrador.getInfo();
}
} Keluaran
I am an animal. My name is Rocky
Pada contoh di atas, kita telah membuat sebuah kelas bernama Animal. Kelas menyertakan bidang yang dilindungi:name dan metode:display() .
Kami telah mewarisi Anjing kelas mewarisi Hewan . Perhatikan pernyataannya,
labrador.name = "Rocky";
labrador.display(); Di sini, kita dapat mengakses bidang yang dilindungi dan metode superclass menggunakan labrador objek subkelas.
Ada lima jenis warisan.
Dalam pewarisan tunggal, satu subclass meluas dari satu superclass. Misalnya,
Dalam pewarisan bertingkat, subclass meluas dari superclass dan kemudian subclass yang sama bertindak sebagai superclass untuk kelas lain. Misalnya,
Dalam pewarisan hierarkis, beberapa subclass diperluas dari satu superclass. Misalnya,
Dalam multiple inheritance, satu subclass memanjang dari beberapa superclass. Misalnya,
Catatan :Java tidak mendukung pewarisan berganda. Namun, kita dapat mencapai pewarisan berganda menggunakan antarmuka. Untuk mempelajari lebih lanjut, kunjungi Java mengimplementasikan multiple inheritance.
Warisan hibrida adalah kombinasi dari dua atau lebih jenis pewarisan. Misalnya,
Di sini, kami telah menggabungkan pewarisan hierarki dan pewarisan berganda untuk membentuk pewarisan hibrida.
java
Kelas Java BufferedInputStream Dalam tutorial ini, kita akan belajar tentang Java BufferedInputStream dan metodenya dengan bantuan contoh. BufferedInputStream kelas java.io package digunakan dengan aliran input lain untuk membaca data (dalam byte) dengan lebih efisien. Ini memperluas InputStream k
Kelas Java PrintStream Dalam tutorial ini, kita akan belajar tentang kelas Java PrintStream dan metode print() dan printf() dengan bantuan contoh. PrintStream kelas java.io package dapat digunakan untuk menulis data keluaran dalam bentuk (teks) yang dapat dibaca secara umum alih-alih byte. Ini mem
Kelas Pembaca Java Dalam tutorial ini, kita akan belajar tentang Java Reader, subclass-nya dan metodenya dengan bantuan sebuah contoh. Reader kelas java.io package adalah superclass abstrak yang mewakili aliran karakter. Sejak Reader adalah kelas abstrak, itu tidak berguna dengan sendirinya. Namun
Warisan dapat didefinisikan sebagai proses di mana satu kelas memperoleh properti (metode dan bidang) dari yang lain. Dengan menggunakan pewarisan, informasi dibuat dapat dikelola dalam urutan hierarkis. Kelas yang mewarisi sifat-sifat orang lain dikenal sebagai subkelas (kelas turunan, kelas anak)