Kế thừa trong Java là 1 trong những tính năng quan trọng nhất của hệ thống lập trình hướng đối tượng (OOP). Chúng ta đã thấy tổng quan về kế thừa trong hướng dẫn trước của Các khái niệm OOP trong Java. Trong hướng dẫn này, chúng ta sẽ hiểu chi tiết về kế thừa trong Java và kiểu của nó với nhiều ví dụ khác nhau.
Kế thừa trong Java là 1 tính năng giúp dùng lại các phương thức và biến của 1 lớp này trong 1 lớp khác. Nói cách khác, nó cho phép 1 lớp mới kế thừa các thuộc tính và chức năng của 1 lớp hiện có mà không cần viết lại mã. Nó thực hiện Cha mẹ và con mối quan hệ. Điều này có nghĩa là lớp con có thể dùng lại trực tiếp các biến và hàm của lớp cha.
I. Tại Sao Dùng Tính Kế Thừa Trong Java?
Tính kế thừa trong Java là môt kỹ thuật mà trong đấy 1 đối tượng thu được hầu hết thuộc tính và hành vi của đối tượng cha. Ý tưởng đằng sau tính kế thừa trong Java là các các bạn có thể tạo các lớp mới mà được xây dựng dựa trên các lớp đang tồn tại.
Khi các các bạn kế thừa từ 1 lớp đang tồn tại, các các bạn có thể tái dùng các phương thức và các trường của lớp cha, và các các bạn cũng có thể bổ sung thêm các phương thức và các trường khác. Tính kế thừa biểu diễn mối quan hệ IS-A, còn được gọi là mối quan hệ cha-con.
Có 1 số lý do vì sao nên dùng kế thừa trong lập trình Java:
– Khả năng thể hiện các mối quan hệ kế thừa đảm bảo sự gần gũi với các mô hình trong thế giới thực.
– 1 lý do khác là khả năng tái dùng. Khi dùng tính kế thừa ta có thể lấy 1 lớp mới từ 1 lớp hiện có và thêm tính năng mới vào nó mà không cần sửa đổi lớp cha và viết lại lớp cha để kế thừa nó.
– 1 lý do khác là tính chất bắc cầu. Nếu lớp 1 kế thừa các thuộc tính từ 1 lớp B, sau đấy hầu hết các lớp con của A sẽ tự động kế thừa từ B. Tính chất này được gọi là tính chất bắc cầu của kế thừa.
II. Cú Pháp Của Tính Kế Thừa Trong Java
Mọi người đã biết rằng để kế thừa 1 lớp, chúng ta dùng từ khóa expand. Cú pháp của việc dùng kế thừa trong Java chính là:
class ten_lop_con extends ten_lop_cha {
//cac phuong thuc va cac truong
}
Từ khóa extends chỉ rằng bạn đang tạo 1 lớp mới mà kế thừa từ 1 lớp đang tồn tại. Trong Java, 1 lớp mà được kế thừa được gọi là 1 lớp cha. Lớp mới được gọi là lớp con.
Trong ví dụ sau, Programmer là lớp con và Employee là lớp cha. Mối quan hệ giữa hai lớp là Programmer IS-A Employee. Nghĩa là Programmer là 1 kiểu của Employee.
class Employee {
float salary = 40000;
}
class Programmer extends Employee {
int bonus = 10000;
public static void main(String args[]) {
Programmer p = new Programmer();
System.out.println("Luong Lap trinh vien la:" + p.salary);
System.out.println("Bonus cua Lap trinh vien la:" + p.bonus);
}
}
Ở trên, đối tượng Programmer có thể truy cập trường của riêng lớp nó cũng như của lớp Employee, đấy là ví dụ cho tính tái dùng.
III. Các Loại Kế Thừa Trong Java
Có 5 kiểu kế thừa trong Java đấy là đơn kế thừa, Đa kế thừa, Kế thừa đa cấp, Kế thừa phân cấp, Kế thừa lai
Khi 1 class được kế thừa từ nhiều class đươc gọi là đa kế thừa. Trong Java, đa kế thừa chỉ được support thông qua interface, như đã được nói đến trong bài interface trong Java
1. Đơn kế thừa (Single Inheritance):
Đơn kế thừa: nghĩa là 1 lớp chỉ được kế thừa từ đúng 1 lớp khác. Hay nói cách khác, lớp con chỉ có duy nhất 1 lớp cha.
Cú pháp khai báo đơn kế thừa:
class lopcon : phamvidulieu lopcha
{
// nội dung lớp con
};
dưới đây là 1 ví dụ:
#include <iostream>
using namespace std;
// Lớp cha
class Mayvitinh
{
public:
Mayvitinh()
{
cout << "This is a computer" << endl;
}
};
// Lớp con kế thừa từ lớp cha
class mayAcer : public Mayvitinh
{
};
// main function
int main()
{
mayAcer may1;
return 0;
Chương trình sẽ cho kết quả:
2. Đa kế thừa (Multiple Inheritance):
Đa kế thừa là 1 tính năng của ngôn ngữ C++. Trong đấy 1 lớp có thể kế thừa từ nhiều hơn 1 lớp khác. Nghĩa là 1 lớp con được kế thừa từ nhiều hơn 1 lớp cơ sở.
Cú pháp khai báo đa kế thừa:
class lopcon : phamvitruycap lopcha1, phamvitruycap lopcha2, ....
{
// nội dung của lớp con
};
Ở đây, các lớp cơ sở sẽ được phân tách bằng dấu phẩy , và phạm vi truy cập cho mọi lớp cơ sở phải được chỉ định.
Chúng ta cùng xem ví dụ sau:
#include <iostream>
using namespace std;
// Lớp cơ sở thứ nhất
class Mayvitinh
{
public:
Mayvitinh()
{
cout << "This is a computer's brand" << endl;
}
};
// Lớp cơ sở thứ hai
class Maylaptop
{
public:
Maylaptop()
{
cout << "This is a laptop's brand" << endl;
}
};
// Lớp con kế thừa từ 2 lớp cha
class mayAcer : public Mayvitinh, public Maylaptop
{
};
// main function
int main()
{
mayAcer may1;
return 0;
}
Sau khi chạy ta sẽ có kết quả sau:
3. Kế thừa đa cấp (Multilevel Inheritance):
Kế thừa đa cấp: Trong kiểu thừa kế này, 1 lớp dẫn xuất được tạo từ 1 lớp dẫn xuất khác.
Ví dụ về kế thừa đa cấp:
#include <iostream>
using namespace std;
// Lớp cha
class Mayvitinh
{
public:
Mayvitinh()
{
cout << "This is a computer's brand" << endl;
}
};
// Lớp con kế thừa từ lớp cha
class Maylaptop : public Mayvitinh
{
public:
Maylaptop()
{
cout << "This is a laptop's brand" << endl;
}
};
// Lớp con kế thừa từ lớp cha thứ 2
class mayAcer : public Maylaptop
{
public:
mayAcer(){
cout << "This brand is Acer" << endl;
}
};
// main function
int main()
{
mayAcer may1;
return 0;
}
Sau khi chạy ta có kết quả:
4. Kế thừa phân cấp (Hierarchical Inheritance):
Kế thừa phân cấp: Trong kiểu thừa kế này, sẽ có nhiều hơn 1 lớp con được kế thừa từ 1 lớp cha duy nhất.
Chúng ta có ví dụ:
#include <iostream>
using namespace std;
// Lớp cha
class Mayvitinh
{
public:
Mayvitinh()
{
cout << "This is a computer's brand" << endl;
}
};
// Lớp con thứ nhất
class mayAsus : public Mayvitinh
{
};
// Lớp con thứ hai
class mayAcer : public Mayvitinh
{
};
// main function
int main()
{
mayAcer may1;
mayAsus may2;
return 0;
}
Sau khi chạy ta có kết quả:
5. Kế thừa lai (Kế thừa ảo) – Hybrid (Virtual) Inheritance:
Kế thừa lai (Kế thừa ảo): được thực hiện bằng cách kết hợp nhiều hơn 1 loại thừa kế.
Chúng ta lấy ví dụ về sự kết hợp của phân cấp và đa kế thừa dưới đây:
#include <iostream>
using namespace std;
// Lớp cha
class Mayvitinh
{
public:
Mayvitinh()
{
cout << "This is a computer's brand" << endl;
}
};
// Lớp cha
class Maylaptop
{
public:
Maylaptop()
{
cout << "This is a laptop's brand" << endl;
}
};
// Lớp con thứ nhất
class mayAcer : public Mayvitinh
{
};
// Lớp con thứ hai
class mayAsus : public Mayvitinh, public Maylaptop
{
};
// main function
int main()
{
mayAsus may1;
mayAcer may2;
return 0;
}
Sau khi chạy ta có kết quả:
IV. Từ Khóa Instanceof Trong Java
Trong bài viết này, các bạn sẽ tìm hiểu về toán tử Instanceof Java 1 cách chi tiết với sự trợ giúp của các ví dụ.
Trong Java, từ khóa Instanceof là 1 toán tử nhị phân. Nó được dùng để kiểm tra xem 1 đối tượng có phải là 1 Instance của 1 class cụ thể hay không.
Toán tử cũng kiểm tra xem 1 đối tượng có phải là 1 Instance của 1 class thực hiện 1 giao diện(interface) hay không (sẽ được thảo luận sau trong bài hướng dẫn này).
Cú pháp của toán tử Instanceof là:
result = objectName Instanceof className;
Toán hạng bên trái của toán tử Instanceof là tên đối tượng và toán hạng bên phải là tên class. Kết quả sẽ true nếu 1 đối tượng là 1 Instance của 1 class và sẽ là false nếu nó không phải.
Ví dụ 1: Toán tử Instanceof
/**
* Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
*
* @author cafedevn
* Contact: cafedevn@gmail.com
* Fanpage: https://www.facebook.com/cafedevn
* Instagram: https://instagram.com/cafedevn
* Twitter: https://twitter.com/CafedeVn
* Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
*/
class Main {
public static void main (String[] args) {
String name = "Programiz";
Integer age = 22;
System.out.println("Is name an Instance of String: "+ (name Instanceof String));
System.out.println("Is age an Instance of Integer: "+ (age Instanceof Integer));
}
}
Khi chúng ta chạy chương trình, kết quả sẽ là:
Is name an Instance of String: true Is age an Instance of Integer: true
Trong ví dụ trên, chúng ta đã tạo đối tượng name của kiểu String và 1 đối tượng khác là age của kiểu Integer. Sau đấy, chúng ta đã dùng toán tử Instanceof để kiểm tra xem liệu rằng đối tượng name có thuộc kiểu String và đối tượng age có thuộc kiểu Integer hay không.
dùng toán tử Instanceof trong tính kế thừa
Vơi tính thừa kế, toán tử Instanceof được dùng để kiểm tra xem liệu rằng 1 đối tượng của subclass có phải cũng là 1 toán tử Instanceof của siêu class hay là không.
Ví dụ 2: Instanceof trong kế thừa
/**
* Cafedev.vn - Kênh thông tin IT hàng đầu Việt Nam
*
* @author cafedevn
* Contact: cafedevn@gmail.com
* Fanpage: https://www.facebook.com/cafedevn
* Instagram: https://instagram.com/cafedevn
* Twitter: https://twitter.com/CafedeVn
* Linkedin: https://www.linkedin.com/in/cafe-dev-407054199/
*/
class Animal {
}
// Dog class is a subclass of Animal
class Dog extends Animal {
}
class Main {
public static void main(String[] args){
Dog d1 = new Dog();
// checks if d1 is an object of Dog
System.out.println("Is d1 an Instance of Dog: "+ (d1 Instanceof Dog));
// checks if d1 is an object of Animal
System.out.println("Is d1 an Instance of Animal: "+ (d1 Instanceof Animal));
}
}
Khi chúng ta chạy chương trình, kết quả sẽ là:
Is d1 is an Instance of Dog: true Is d1 an Instance of Animal: true
Trong ví dụ trên, d1 là 1 Instance của cả class Dog và Animal. Do đấy, cả d1 Instanceof Dog và d1 Instanceof Animal trả về kết quả là true .
V. Quan hệ HAS-A Trong Java
Nếu 1 class có tham chiếu đến 1 thực thể khác, được gọi là quan hệ HAS – A.
Ví dụ Chúng ta có class Student, 1 Student cần có các thông tin như id, name, email, etc. Và thực thể Address chứa các thông tin city, country, zipcode etc.
// File Student.java
public class Student {
String id;
String name;
Address address;
}
// File Address.java
public class Address {
String city;
String country;
String zipcode;
}
Class Student tham chiếu đến Address là 1 thực thể, chúng ta có thể phát biểu như sau: Student có quan hệ HAS – A Address.
Mục đích dùng HAS – A
Ở ví dụ trên, các bạn hoàn toàn có thể gộp các thuộc tính địa chỉ vào class Student như sau.
// File Student.java
public class Student {
String id;
String name;
String city;
String country;
String zipcode;
}
Với cách làm trên của chúng ta là hoàn toàn ổn. Sau đấy ứng dụng mở rộng chúng ta có thêm class Employee cũng cần dùng đến địa chỉ. Nếu như làm theo cách trên thì chúng ta phải duplicate các thuộc tính address cho Employee. Làm như vậy thì code sẽ trở nên dài dòng, giảm tính reused code của project.
Vậy nên chúng ta cần dùng HAS – A để tăng tính tái dùng code. Định nghĩa Address ra 1 class riêng, và Student, Employee đều tham chiếu đến Address.
Khi nào nên dùng HAS -A
Như đã bàn luận ở trên, dùng HAS – A làm tăng tính tái dùng code. Khi các bạn thấy giữa các class có các thông tin chung giống hệt nhau thì ta nên tách nhỏ nó ra thành 1 class khác bao gồm những thuộc tính chung.
Các bạn đừng nhầm lẫn HAS – A với IS – A(thừa kế) nha. Thừa kế là 1 khái niệm mà các class con dùng lại các thuộc tính và method của class cha có sẵn. HAS – A là đặt những điểm chung ra riêng 1 class và import vào các class khác để dùng.
Ví dụ
Address.java
// File Address.java
public class Address {
String city;
String country;
String zipcode;
public Address(String city, String country, String zipcode) {
this.city = city;
this.country = country;
this.zipcode = zipcode;
}
}
Student.java
// File Student.java
public class Student {
int id;
String name;
Address address;
Student(int id, String name, Address address) {
this.id = id;
this.name = name;
this.address = address;
}
void display() {
System.out.println("ID: " + id);
System.out.println("Name: " + name);
System.out.println("Address: " + address.city + " " + address.country + " " + address.zipcode);
}
}
// File Main.java
public class Main {
public static void main(String[] args) {
Address address = new Address("HCM", "VN", 11000);
Student student = new Student(1, "Hai", address);
student.display();
}
}
Output:
ID: 1
Name: Hai
Address: HCM VN 11000
VI. Bài Tập Kế Thừa Trong Java Có Lời Giải
Tạo 1 lớp Person lưu trữ các thông tin dưới đây ( Tên, giới tính, địa chỉ,ngay sinh)
Tạo 1 lớp Student kế thừa từ lớp person lưu trữ các thông tin như dưới đây:
Mã sinh viên,điểm trung bình, email
Viết 1 phương thức nhập thông tin của student
Viết 1 phương thức hiện thị thông tin của student
Viết phương trình xem xét có sinh viên nào được học bổng không? điểm trung bình hơn 8.0 sẽ được hổng bổng
Khai báo class parent Person
class Person{
protected String name;
protected String sex;
protected String adrress;
protected String ngaysinh;
public void intputPerson(){
Scanner scanner = new Scanner(System.in);
System.out.println("Nhap Ten :");
this.name = scanner.nextLine();
System.out.println("Nhap gioi tinh");
this.sex = scanner.nextLine();
System.out.println("Nhap dia chi");
this.adrress = scanner.nextLine();
System.out.println("Nhap ngay sinh");
this.ngaysinh = scanner.nextLine();
}
public void showPerson(){
System.out.println("Ho Ten : " +this.name + " Gioi Tinh : " +this.sex +" Dia chi : " +this.adrress +" Ngay sinh : " +this.ngaysinh);
}
}
Trong đấy:
Có 4 biến bao gồm ( ten,gioitinh,diachi,ngaysing) và có 2 phương thức:
intputPerson : Là phương thức nhập thông tin
showPerson : Xuất hiện thông tin
Tiếp thep khai báo 1 lớp student được kế thừa từ lớp Person
class Student extends Person{
protected String masv;
protected float diemtrungbinh;
protected String email;
public void intPutStudent(){
Scanner input = new Scanner(System.in);
System.out.println("Nhap ma sinh vien");
this.masv = input.nextLine();
System.out.println("Nhap diem trung binh");
this.diemtrungbinh = input.nextFloat();
System.out.println("Nhap email");
this.email = input.nextLine();
}
public void showStudent(){
System.out.println("Ma sinh vien : " +this.masv +" Diem trung binh " + this.diemtrungbinh);
}
public void kiemtrahocbong(){
if(this.diemtrungbinh >=8){
System.out.println("Duoc hoc bong");
}else{
System.out.println("Khong duoc hoc bong");
}
}
}
Lớp Person có 3 biến cần lưu trữ,và 3 phương thức java
intPutStudent : Nhập thông tin của sinh viên đấy.
showStudent : Xuất thông tin của sinh viên
kiemtrahocbong : Phương thức kiểm tra học bổng
Hàm khởi tạo để thực hiện chương trình như sau:
ublic class BT1 {
public static void main(String []args){
Student person = new Student();
person.intputPerson();
person.intPutStudent();
person.showPerson();
person.showStudent();
person.kiemtrahocbong();
}
}
Kết quả:
VII. Đa Kế Thừa Trong Java
Nếu 1 lớp triển khai đa kế thừa, hoặc 1 Interface kế thừa từ nhiều Interface thì đó là đa kế thừa.
Trong Java, 1 lớp chỉ được thừa kế (extends) từ 1 lớp, có thể cài đặt (implements) nhiều interface. Tuy nhiên, 1 interface có thể thừa kế (extends) nhiều interface.
1 interface không thể cài đặt (implements) interface khác, do interface không phần cài đặt, chỉ chứa các khai báo.
Ví dụ 1 lớp cài đặt (implements) nhiều interface:
public interface Shape {
void draw();
}
public interface Color {
String getColor();
}
public class Rectangle implements Shape, Color {
@Override
public void draw() {
System.out.println("Draw " + this.getColor() + " rectangle");
}
@Override
public String getColor() {
return "red";
}
}
Ví dụ interface kế thừa (extend) nhiều interface:
public interface Shape {
void draw();
}
public interface Color {
String getColor();
}
public interface ShapeColor extends Shape, Color {
}
public class Circle implements ShapeColor {
@Override
public void draw() {
System.out.println("Draw " + this.getColor() + " circle");
}
@Override
public String getColor() {
return "red";
}
}
Câu hỏi: Đa kế thừa không được hỗ trợ thông qua lớp trong Java nhưng là có thể bởi Interface, vì sao?
Như đã giới thiệu, kế thừa không được hỗ trợ thông qua lớp. Nhưng nó được hỗ trợ bởi Interface bởi vì không có tính lưỡng nghĩa khi trình triển khai được cung cấp bởi lớp Implementation.
Ví dụ đa thừa kế với Interface
public interface Printable {
void print();
}
public interface Showable {
void print();
}
public class InterfaceDemo implements Printable, Showable {
public void print() {
System.out.println("Welcome to gpcoder.com");
}
public static void main(String args[]) {
InterfaceDemo obj = new InterfaceDemo();
obj.print();
}
}
Trong ví dụ trên, interface Printable và Showable có cùng các phương thức print() nhưng trình triển khai của nó được cung cấp bởi lớp InterfaceDemo, vì thế không có tính lưỡng nghĩa ở đây.
Ví dụ đa thừa kế với class
public class Printable {
void print() {
System.out.println("Printable");
}
}
public class Showable {
void print() {
System.out.println("Showable");
}
}
// Không thể thực hiện đa thừa kế với class
public class InterfaceDemo extends Printable, Showable {
public static void main(String args[]) {
InterfaceDemo obj = new InterfaceDemo();
obj.print(); // Không thể xác định được gọi phương thức print() của class nào
}
}
Trong ví dụ trên, lớp Printable và Showable có cùng các phương thức print() và InterfaceDemo kế thừa 2 class đó không override lại phương thức print() nên trình biên dịch không biết thực thi phương thức print() của lớp Printable hay là của lớp Showable. Để bảo đảm an toàn và giảm tính phức tạp của hệ thống nên Java không hỗ trợ đa thừa kế đối với class.
The post Kế Thừa Trong Java first appeared on Techacademy.
Nhận xét
Đăng nhận xét