-
Thông tin
-
Hỏi đáp
Lý thuyết môn Cơ sở lập trình nội dung về "Kế thừa (Inheritance)"
Lý thuyết môn Cơ sở lập trình nội dung về "Kế thừa (Inheritance)" của Đại học Nguyễn Tất Thành với những kiến thức và thông tin bổ ích giúp sinh viên tham khảo, ôn luyện và phục vụ nhu cầu học tập của mình cụ thể là có định hướng ôn tập, nắm vững kiến thức môn học và làm bài tốt trong những bài kiểm tra, bài tiểu luận, bài tập kết thúc học phần, từ đó học tập tốt và có kết quả cao cũng như có thể vận dụng tốt những kiến thức mình đã học vào thực tiễn cuộc sống. Mời bạn đọc đón xem!
Môn: Cơ sở Lập trình - Java 4 tài liệu
Trường: Đại học Nguyễn Tất Thành 1 K tài liệu
Thông tin:
Tác giả:
Preview text:
lOMoARcPSD| 36667950
https://www.geeksforgeeks.org/inheritance-in-java/
KẾ THỪA (INHERITANCE)
1/. Khái niệm Inheritance:
Kế thừa là một trụ cột quan trọng của OOP (Lập trình hướng đối tượng). Đây là cơ chế trong java
mà một lớp được phép kế thừa các tính năng (thuộc tính và phương thức) của lớp khác.
Kế thừa trong Java là sự liên quan giữa hai class với nhau, trong đó có class cha (superclass) và
class con (subclass). Khi kế thừa class con được hưởng tất cả các phương thức và thuộc tính của
class cha. Tuy nhiên, nó chỉ được truy cập các thành viên public và protected của class cha. Nó
không được phép truy cập đến thành viên private của class cha.
Tư tưởng của kế thừa trong Java là có thể tạo ra một class mới được xây dựng trên các lớp đang tồn
tại. Khi kế thừa từ một lớp đang tồn tại ta có sử dụng lại (Reusability) các phương thức và thuộc tính
của lớp cha, đồng thời có thể khai báo thêm các phương thức và thuộc tính khác của lớp con.
2/. Cú pháp của kế thừa trong Java:
Sử dụng từ khóa extends để khai báo kế thừa:
class subclass extends superclass {
//methods and fields / properties }
Ví dụ: file InheritanceSample1.java
class Employee //super class {
private String id = "12345" ;
public String name = "Bill Gate" ;
protected int age = 64;
public float salary = 1000; }
class Programmer extends Employee //subclass { float bonus = 500; } lOMoARcPSD| 36667950
public class InheritanceSample1 //Driver Class {
public static void main(String args[]) {
Employee e = new Employee();
//System.out.println("Tên Employee: " + e.id); //kg nhìn th y ( n)ấ ẩ
System.out.println("Tên Employee: " + e.name);
System.out.println("Tu i Employee: "ổ + e.age);
System.out.println("L ng Employee: "ươ + e.salary);
//System.out.println("Th ng Employee: "ưởơ
+ e.bonus); //kg truy xu t đ
cấ ượ Programmer p = new Programmer();
//System.out.println("Tên Programmer: " + p.id); //kg nhìn th y ( n)ấ ẩ
System.out.println("Tên Programmer: " + p.name);
System.out.println("Tu i Programmer: "ổ + p.age);
System.out.println("L ng Programmer: "ươ + p.salary);
System.out.println("Th ng Programmer is: "ưởơ + p.bonus); } }
Kết quả: Sinh viên nghe giải thích
Trong ví dụ trên class Programmer là con của class Employee, nên nó được phép truy cập đến
thuộc tính /trường name, age, salary của class cha, nhưng không truy cập đến thuộc tính id do là private.
Từ class cha không thể truy xuất thuộc tính của class con.
Ví dụ: file TestBicycle.java
//super class hoặc Base class class Bicycle {
//Bicycle class có 2 thuộc tính
public int gear; //hộp số
public int speed; //tốc độ
//Bicycle class có 1 constructor
public Bicycle(int gear, int speed) { lOMoARcPSD| 36667950 this.gear = gear; this.speed = speed; }
//Bicycle class có 3 method
public void applyBrake(int decrement) {
speed -= decrement; //đạp thắng làm giảm tốc }
public void speedUp(int increment) {
speed += increment; //tăng tốc }
//phương thức toString() dùng xuất thông tin
public String toString() {
return("Gears: "+gear+"\n" + "speed: "+speed); } }
//subclass hoặc derived class class
MountainBike extends Bicycle {
//MountainBike subclass có thêm thuộc tính
public int seatHeight;
//MountainBike subclass có 1 constructor
public MountainBike(int gear,int speed, int startHeight) {
//gọi constructor của lớp cha| base-class(Bicycle) super(gear, speed);
seatHeight = startHeight; }
//MountainBike subclass có thêm 1 method
public void setHeight(int newValue) {
seatHeight = newValue; }
//overriding phương thức toString()của Bicycle @Override
public String toString() {
return (super.toString()+"\nseat height: "+seatHeight); } } lOMoARcPSD| 36667950 //driver class
public class TestBicycle {
public static void main(String args[]) {
MountainBike mb = new MountainBike(3, 100, 25);
System.out.println(mb.toString()); } } Kết quả: Gears: 3 speed: 100 seat height: 25
Hình ảnh minh họa của chương trình: (sinh viên tìm hiểu) Từ khóa super chỉ lớp cha.
Constructor (phương thức khởi tạo) của lớp con được gọi khi chúng ta tạo đối tượng của lớp con, nó
theo mặc định sẽ gọi constructor mặc định của lớp cha. Do đó, trong kế thừa, các đối tượng được
xây dựng từ trên xuống. Constructor của lớp cha có thể được gọi bằng cách sử dụng từ khóa super,
nhưng nó phải là câu lệnh đầu tiên trong construtor của lớp con.
Không được phép sử dụng nhiều từ khóa super để truy cập vào một lớp tổ tiên khác với lớp cha trực tiếp. lOMoARcPSD| 36667950
3/. Các kiểu kế thừa trong Java:
Có 3 kiểu kế thừa trong java đó là: đơn kế thừa, kế thừa nhiều cấp, kế thừa thứ bậc.
Khi một 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
3.1/. Đơn kế thừa (single inheritance):
Trong thừa kế đơn, các lớp con kế thừa các tính năng của một lớp cha. Ví dụ: file
(có dùng từ khóa super là constructor của class cha) Có mở Animal.java
rộng để sinh viên hiểu trước về override package XXX;
class Animal //Class cha { String name ;
public Animal(String name ) //constructor { this . name = name ; } void eat() {
System. out .println( "Ăn tht" ) ; }
void outputto() //overriding {
System. out .println( "Name: " + this . name ; ) eat(); } }
class Dog extends Animal //class Dog k tha t Animal ếừừ { String breed ;
public Dog(String name , String breed ) //constructor {
super ( name ) ; //gi constructor ca class cha ọ ủ this . breed = breed ; } void bark() { lOMoARcPSD| 36667950
System. out .println( "Sa ngi l" ủ ư ờạ ) ; }
void outputto() //overriding {
System. out .println( "Name : " + this . name ; )
System. out .println( "Breed: " + this . breed ) ; eat(); bark(); } }
file TestInheritance1 .java package XXX;
public class TestInheritance1 {
public static void main(String[] args ) {
Animal x = new Animal( "Cp" ọ ) ; x .outputto();
//-------------------------------------------------
Dog d = new Dog( "Chó" , "Chăn cu" ừ ) ; d .outputto(); } } Kết quả:
3.2/. Kế thừa nhiều cấp (multilevel Inheritance):
Trong Kế thừa nhiều cấp, một lớp con (lớp dẫn xuất) sẽ được kế thừa một lớp cha (lớp cơ sở) và
cũng như lớp con cũng đóng vai trò là lớp cha cho lớp khác. Trong hình ảnh bên dưới, lớp A đóng
vai trò là lớp cha cho lớp con B, lớp này lần lượt đóng vai trò là lớp cha cho lớp con C. Trong Java,
một lớp không thể truy cập trực tiếp vào các thành viên của ông bà. lOMoARcPSD| 36667950 lOMoARcPSD| 36667950 Ví dụ: class Animal {
void eat() {
System.out.println("Ăn thịt"); } }
class Dog extends Animal {
void bark() {
System.out.println("Sủa người lạ"); } }
class BabyDog extends Dog {
void sl eep() {
System.out.println("Ngủ"); } }
public class TestInheritance2 {
public static void main(String args[]) {
BabyDog d = new BabyDog(); d.sleep(); d.bark(); d.eat(); } } Kết quả: Ngủ Sủa người lạ Ăn thịt
3.3/. Kế thừa phân cấp (Hierachical Inheritance):
Trong Kế thừa phân cấp, một lớp đóng vai trò là siêu lớp (lớp cha) cho nhiều hơn một lớp con. Trong
hình ảnh bên dưới, lớp A đóng vai trò là lớp cơ sở cho lớp dẫn xuất B, C và D. lOMoARcPSD| 36667950
Ví dụ: file TestInheritance3.java
class Animal { void eat() {
System.out.println("Ăn thịt"); } }
class Dog extends Animal { void bark() {
System.out.println("Sủa người lạ"); } }
class Cat extends Animal { void meow() {
System.out.println("Kêu meo meo"); } }
public class TestInheritance3 { lOMoARcPSD| 36667950
public static void main(String args[]) { Cat c = new Cat(); c.meow(); c.eat();
// c.bark(); // compile error_ sinh tự viên giải thích } } Kết quả: Kêu meo meo Ăn thịt
Ví dụ: Sinh viên tìm lỗi sai!. class A { void msg() {
System.out.println("Hello"); } } class B { void msg() {
System.out.println("Welcome"); } }
public class C extends A,B {
public static void main(String args[]) { C obj = new C(); obj.msg(); } } 4/. Overriding:
4.1/. Khái niệm về Override
Override là hiện tượng 1 phương thức thuộc lớp cha được định nghĩa lại ở lớp con. •
Phương thức Override và được Override phải có chung kiểu trả về, tên phương thức và danh sách tham số. •
Override chỉ xảy ra giữa các lớp có quan hệ kế thừa (cha và con). •
1 phương thức ở lớp cha được Override ở lớp con thì phương thức Override ở lớp con không được
phép thu hẹp tầm vực của phương thức đó ở lớp cha. lOMoARcPSD| 36667950 •
Phương thức ở lớp cha được Override ở lớp con thì phương thức Override ở lớp con không được phép
phát sinh những ngoại lệ kiểm tra (checked exception) khác loại hoặc không có quan hệ kế thừa với
các ngoại lệ được ném ra từ phương thức đó ở lớp cha. •
Sử dụng từ khóa super để gọi phương thức được Override ở lớp cha tại phương thức Override ở lớp con.
Phương thức Override là một trong những cách mà java đạt được tính đa hình (Polymorphism) lúc thời gian
chạy (Run time). Phiên bản của một phương thức được thực thi sẽ được xác định bởi đối tượng (của class
nào) được sử dụng để gọi nó.
https://www.stdio.vn/java/ghi-de-phuong-thuc-overriding-method-trong-java-g1zwe8 Ví dụ: class Parent { void show() {
System. out .println( "Parent's show()" ) ; } } //class con / k tha ếừ
class Child extends Parent {
//phng thc này s override phng thc show() ca class cha @Override void show() {
System. out .println( "Child's show()" ) ; } } lOMoARcPSD| 36667950
public class TestOverride1 {
public static void main(String[] args ) {
Parent obj1 = new Parent(); obj1 .show(); Parent obj2 = new Child(); //Child obj2 = new Child(); obj2 .show(); } } Kết quả:
4.2/. Một số qui tắc Override: •
Phương thức Override phải có cùng tham số, cùng kiểu trả về như trong class cha. •
Override các phương thức có Access modifier là: protected, private sẽ sinh lỗi (compiletime error) •
Phương thức final, static là không thể Override. •
Không thể Override constructor (vì class cha và con không thể trùng tên) •
Phương thức Override phải có cùng kiểu trả về (hoặc kiểu con): Từ phiên bản Java 5.0 trở đi,
có thể có kiểu trả về khác cho phương thức Override trong lớp con, nhưng kiểu trả về của con
phải là kiểu con của kiểu trả về của cha.
4.3/. Phân biệt Overloading và Overriding: lOMoARcPSD| 36667950 OVERLOADING METHOD OVERRIDING METHOD
Kiểu trả về của các phương thức overload có thể
Kiểu trả về, tên, danh sách tham số của phương thức
giống nhau hoặc khác nhau. Số lượng tham số hoặc override và phương thức được override phải giống kiểu
dữ liệu của tham số ở các hàm overload phải nhau. khác nhau.
Có thể mở rộng hoặc thu hẹp phạm vi của phương Không thể thu hẹp phạm vi của phương thức được thức được overload. override.
Không cho phép tạo ra những ngoại lệ khác loại
Cho phép tạo ra những ngoại lệ hoàn toàn mới so hoặc không phải đối tượng thuộc lớp con của lớp có với
những ngoại lệ từ phương thức được overload. thể hiện là ngoại lệ từ phương thức được override.
Phương thức overload được gọi do trình biên dịch Ví dụ: import java.util.*; class HinhTron {
public final float PI = 3.14f;
public float banKinh ; //Constructor
public HinhTron( float banKinh ) {
quyết định dựa trên kiểu dữ liệu của biến tham
Phương thức override được gọi do máy ảo Java
chiếu tại quá trình biên dịch.
quyết định dựa trên kiểu dữ liệu của đối tượng được
tham chiếu tới tại quá trình runtime. lOMoARcPSD| 36667950
this . banKinh = banKinh ; }
public float tinhChuVi() {
return 2 * PI * banKinh ; }
public float tinhDienTich() {
return PI * banKinh * banKinh ; }
public void xuatThongTin() {
System. out .println( "Đây là Hình tròn" ) ;
System. out .println( "Hình tròn có Chu vi: " + tinhChuVi() + " và Din tích: " + tinhDienTich()); } }
class HinhTru extends HinhTron {
public float chieuCao ; //Constructor
public HinhTru( float banKinh , float chieuCao ) { super ( banKinh ; )
this . chieuCao = chieuCao ; }
public float tinhTheTich() {
return tinhDienTich() * chieuCao ; } @Override
public void xuatThongTin() {
System. out .println( "Đây là Hình tr" ) ;
System. out .println( "Hình tr có Th tích: " + tinhTheTich()); } }
public class TestOverride2 {
public static void main(String[] args ) {
Scanner sc = new Scanner(System. in ) ;
System. out .print( "Nhp Bán kính: " ) ;
float bk = sc .nextFloat();
System. out .print( "Nhp Chiu cao: " );
float cc = sc .nextFloat(); lOMoARcPSD| 36667950
HinhTron hinhTron = new HinhTron( bk ) ;
HinhTru hinhTru = new HinhTru( bk , cc ); hinhTron .xuatThongTin(); hinhTru .xuatThongTin();
System. out .println( "Bye." ) ; sc .close(); } } Kết quả: lOMoARcPSD| 36667950 Bài tập mẫu:
Khai báo các Class kế thừa như hình. File Chim.java:
public class Chim { public String Giong ; public String Xuatxu ; public Chim() { }
public Chim(String giong , String xuatxu ) { Giong = giong ; Xuatxu = xuatxu ; }
public void xemTT() {
System. out .println( "Ging Ch ố
im: " + this . Giong ) ;
System. out .println( "Xut x t ấứừ : " + this . Xuatxu ) ; } }
class BimBip extends Chim {
public float Trongluong ;
private int Soluong ;
public BimBip(String giong , String xuatxu , float trongluong , int soluong ) {
super ( giong , xuatxu ) ;
this . Trongluong = trongluong ; lOMoARcPSD| 36667950
this . Soluong = soluong ; }
public void setSoLuong( int soluong ) {
this . Soluong = soluong ; }
public int getSoLuong() {
return this . Soluong ; } @Override
public void xemTT() { super .xemTT();
System. out .println( "Trng ln g: " + this . Trongluong ; )
System. out .println( "S lng c ốượ òn li: " ạ + this . Soluong ) ; } } File Drive1.java: import java.util.*;
public class Drive1 {
public static void main(String[] args ) {
Chim a = new Chim( "Diu hâu ề " , "Vit Nam " ) ; a .xemTT();
BimBip x = new BimBip( "Bìm Bp m xan ịỏ
h" , "Thailand" , 0.25f, 100); x .xemTT(); } } Kết quả:
ABSTRACT CLASSES TRONG JAVA
1/. Tính trừu tượng trong Java:
Tính trừu tượng (abstract) là một tiến trình ẩn các cài đặt chi tiết và chỉ hiển thị tính năng tới người dùng.
Nói cách khác, nó chỉ hiển thị các thứ quan trọng tới người dùng và ẩn các chi tiết nội tại, ví dụ: để
gửi tin nhắn, người dùng chỉ cần soạn text và gửi tin. Bạn không biết tiến trình xử lý nội tại về phân phối tin nhắn. lOMoARcPSD| 36667950
Tính trừu tượng giúp ta chú ý đến trọng tâm hơn vào đối tượng thay vì quan tâm đến cách nó thực hiện.
2/. Lớp Abstract trong Java:
Một lớp được khai báo là abstract thì đó là lớp trừu tượng. Nó cần được kế thừa và phương thức của
nó cần được triển khai ở các lớp kế thừa (viết code cho phương thức). Nó không thể được khởi tạo.
Sử dụng từ khóa abstract để khai báo một lớp abstract. Từ khóa này được khai báo trước từ khóa class trong khai báo lớp.
3/. Phương thức abstract trong Java:
Một phương thức được khai báo là abstract và không có chương trình triển khai (viết code) thì đó là
phương thức trừu tượng.
Nếu ta muốn một lớp chứa một phương thức cụ thể nhưng lại triển khai phương thức đó ở các lớp
con, thì ta có thể khai báo phương thức đó trong lớp cha ở dạng abstract.
Từ khóa abstract được sử dụng để khai báo một phương thức dạng abstract. Một phương thức abstract
không có thân phương thức. Ví dụ: abstract void draw();
Phương thức abstract sẽ không có định nghĩa nội dung, được kết thúc bằng dấu chấm phảy, không
có cặp dấu ngoặc móc { } theo sau:
4/. Các điểm cần nhớ về lớp abstarct và phương thức abstract:
1. Từ khóa abstract được dùng để tạo một lớp abstract, phương thức abstract.
2. Lớp abstract không thể được khởi tạo.
3. Phương thức abstract không có thân.
4. Nếu 1 lớp có phương thức abstract thì lớp đó phải là lớp abstract, nếu không nó sẽ không được biên dịch.
5. Lớp abstract có thể không chứa phương thức abstarct.
6. Lớp con (subclass) của lớp abstract phải thực hiện triển khai (viết code) cho tất cả các phương thức abstract.
7. Lớp abstract được dùng để cung cấp các phương thức chung đến các lớp con của nó. Ví dụ 1:
abstract class myAbstract { //có th có thuc tính ể ộ String name ; int age ; //có th có constructor ể myAbstract() {
System. out .println( "Khi to myAbstract." ởạ ) ; } lOMoARcPSD| 36667950
//có th có ph ng th c staticể ươ ứ
public static void Method1() {
System.out.println("Ph ng th c không abstract và static"ươ ứ ); }
//có th có ph ng th c không abstractể ươ
ứ public void Method2() {
System.out.println("Ph ng th c không abstract và không static"ươ ứ ); }
//có th có ph ng th c abstractể ươ ứ
abstract String Method3();
public static void main(String[] args) {
//myAbstract x = new myAbstract(); //không th kh i t o l p ể ở ạ ớ
abstract myAbstract.Method1(); //có th g i ph ng th c staticể ọ ươ ứ
//myAbstract.Method2(); //không th g i ph ng th c không staticể ọ ươ ứ } } Kết quả:
Ph ng th c không abstract và staticươ ứ
Ví dụ 2: khai báo lớp abstract //ví d v l
ụềớ p abstract trong Java abstract class Shape { int color; //phng thc ab stract abstract void draw(); } lOMoARcPSD| 36667950
Ví dụ 2 tiếp theo: khai báo lớp con kế thừa
abstract class Bike { //lp ớ abstract
abstract void show(); //phng thc ab stract }
class Honda extends Bike { //lp k ớếừ tha
void show() { System. out .println( "Đây là xe máy" ) ; } }
public class Main {
public static void main(String[] args ) { //Bike x = new Bike(); //x.show(); //2 dòng lnh
ệ trên là sai, vì sao? (Sv gii t ả hích) Bike x = new Honda(); x .show(); } } lOMoARcPSD| 36667950
Ví dụ 3: một lớp abstract có 3 lớp con //Lp
ớ abstract không có constructor và có 3 lp c ớ on
abstract class Bike {
abstract void run(); //phng thc ab stract, nó s đc vit c ác lp ớ con. }
class Honda extends Bike {
void run() {System. out .println( "Honda chim ế 80% th phn ịầ " ) ; } }
class Yamaha extends Bike {
void run() {System. out .println( "Yamaha chim ế 10% th phn ịầ " ) ; } }
class Sym extends Bike {
void run() {System. out .println( "Sym chim ế 8% th phn ịầ " ) ; } }
public class Main {
public static void main(String[] args ) { Bike x = new Honda(); x .run(); Bike y = new Yamaha(); y .run(); Bike z = new Sym(); z .run(); } } Kết quả: Honda chim ế 80% th phn ịầ Yamaha chi m 10% th ph nế ị
ầ Sym chi m 8% th ph nế ị ầ lOMoARcPSD| 36667950
Ví dụ 4: một lớp abstract có thể chứa các constructor và một constructor của lớp trừu tượng được
gọi (gọi ngầm) khi một thể hiện của lớp kế thừa được khởi tạo. Ví dụ, sau đây là một chương trình Java hợp lệ.
//L p abstract có constructor ớ
abstract class Base {
Base() {System.out.println("1.G i Base Constructor"ọ );}
abstract void fun(); //ph ng th c abstractươ ứ }
class Derived extends Base //L p k th aớ ế ừ {
Derived() {System.out.println("2.G i Derived Constructor"ọ
);} void fun() {System.out.println("3.G i method Derived fun()"ọ );} }
public class Main
{ public static void main(String[] args) {
Derived d = new Derived();//s g i constructor l p Base()ẽ ọ ớ
//s g i constructor l p Derived() | l p con k th aẽ ọ ớ ớ ểế ừ d.fun(); } } Kết quả: 1. G i Base Constructorọ 2. G i Derived Constructorọ 3. G i method Derived funọ ()
Ví dụ 5: thực hiện thiết kế class theo hình sau: lOMoARcPSD| 36667950
Tạo file Nhansu.java: package KTLTJ;
public abstract class Nhansu {
private String name ; //2 thuc tính private ộ
private int ns_ID ;
public void Thongtinchung() //phng thc xut thông tin chung {
System. out .println( "Name: " + name ) ;
System. out .println( "ns_ID: " + ns_ID ) ; }
public void setName(String ten ) //phng thc setName { this . name = ten ; }
public void setId( int id ) //phng thc setId { this . ns_ID = id ; }
public abstract void Thongtinan( int s ,String p ) ; //phng thc abstract } lOMoARcPSD| 36667950 Tạo file HR.java : package KTLTJ; import java.io.*;
public class HR extends Nhansu {
private int salary ;
private String performance ;
//vit phng thc abstract ti subclass ế ươ ứ ạ
public void Thongtinan( int s ,String p ) { this . salary = s ;
this . performance = p ;
System. out .println( "salary: " + salary ) ;
System. out .println( "performance: " + performance ) ; }
public static void main(String[] args ) throws IOException { HR hr = new HR();
InputStreamReader is = new InputStreamReader(System. in ) ;
BufferedReader br = new BufferedReader( is ) ; String ten ; int id ;
System. out .println( "Nhp H tên: " ); ten = br .readLine();
System. out .println( "Nhp ns_Id: " ) ;
id = Integer. parseInt ( br .readLine()); hr .setName( ten ; ) hr .setId( id ) ; hr .Thongtinchung();
hr .Thongtinan(5000, "good" ) ;
//có th vit các phng thc get, set... ểế ươ ứ } } Kết quả: Nguồn:
https://viettuts.vn/java/abstract-class-trong-java
https://www.geeksforgeeks.org/abstraction-in-java-2/ lOMoARcPSD| 36667950
https://www.programiz.com/java-programming/abstract-classes-methods Quan Hệ Has - a 1/. Quan hệ Has - a:
lập trình và thiết kế hướng đối tượng, has-a là mối quan hệ thành phần trong đó một đối tượng "thuộc
về" một đối tượng khác và hành xử theo các quy tắc sở hữu. Nói một cách đơn giản, có một mối
quan hệ trong một đối tượng được gọi là trường thành viên của một đối tượng. Ví dụ:
public class Address { String City ; String Country ; String Phonenumber ; }
public class Student { String Id ; String Name ; Address Saddress ; … }
Thuộc tính / trường Saddress tham chiếu đến đối tượng Address, đây là quan hệ Has – a.
Ví dụ: Làm sao tham chiếu khởi tạo, truy cập đến các thuộc tính của đối tượng có quan hệ Has – a ? File Address.java:
public class Address { String City ; String Country ; String Phonenumber ;
public Address(String city , String country , String phonenumber ) { City = city ; Country = country ; Phonenumber = phonenumber ; } } File Student.java: lOMoARcPSD| 36667950
public class Student { String Id ; String Name ; Address Saddress ;
Student(String id , String name , Address address ) { this . Id = id ; this . Name = name ;
this . Saddress = address ; }
public void showInfo() {
System. out .println( "ID: " + Id ) ;
System. out .println( "Name: " + Name ; )
System. out .println( "Address: " + Saddress . City + " " +
Saddress . Country + " " + Saddress . Phonenumber ) ; } }
File DriveStudent.java:
public class DriveStudent
{ public static void main(String[] args) {
Address address = new Address("Tp.HCM", "Vi t Nam"ệ, "0917964474");
Student student = new Student("1811512922", "Lê Tr ng H i"ọ ả , address); student.showInfo();
Address x = new Address("Qu ng Châu"ả, "China", "0124964474");
Student a = new Student("1811583474", "Âu D ng Phong"ươ , x); a.showInfo(); } } Kết quả: lOMoARcPSD| 36667950
2 /. Has – a sử dụng khi nào? :
Sử dụng Has – a làm tăng tính tái sử dụng code. Khi ta 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 một 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 là thừa kế. Thừa kế (Is – a) là một khái niệm mà các
class con sử dụng lại các thuộc tính và method của class cha có sẵn. Has – a là lấy những điểm
chung ra riêng một class và import vào các class khác để sử dụng.
3/. Quan hệ Is – a: Mối quan hệ Is-A trong Java
Trong Java, mối quan hệ Is - a phụ thuộc vào tính kế thừa. Kế thừa xa hơn có hai loại, kế thừa lớp
và đa kế thừa (interface). Nó được sử dụng để tái sử dụng mã trong Java. Ví dụ: Khoai tây là rau; Xe buýt là phương tiện,
Bóng đèn là thiết bị điện tử, v.v.
Một trong những thuộc tính của thừa kế là tính kế thừa có tính chất một chiều. Giống như chúng ta
có thể nói rằng một ngôi nhà là một công trình. Nhưng không phải tất cả các công trình đều là nhà
ở. Chúng ta có thể dễ dàng xác định mối quan hệ Is-A trong Java. Khi có một từ khóa extends hoặc
implements trong khai báo lớp trong Java, thì lớp cụ thể được cho là tuân theo mối quan hệ Is-A.
Ví dụ về Has – a:
https://www.c-sharpcorner.com/UploadFile/3614a6/is-a-and-has-a-relationship-in-java/ File HardDisk.java: class HardDisk { String Loai ; public HardDisk() { } lOMoARcPSD| 36667950
public void Dung() {
System. out .println( "Đĩa cng t huc l oi : " + Loai ) ; } } File Computer.java:
public class Computer {
// segate is referece of HardDisk class in Computer class.
// So, Computer Has-A HardDisk
HardDisk segate = new HardDisk();
public void Show () {
System. out .println( "Máy tính có đĩa cng Seag ate" ) ; segate .Dung(); }
public static void main(String[] args ) {
//HardDisc diacung = HardDisc();
Computer x = new Computer();
x . segate . Loai = "Laptop Type" ; x .Show();
x . segate . Loai = "Server Type" ; x .Show(); } } Kết quả: