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!

lOMoARcPSD|36667950
https://www.geeksforgeeks.org/inheritance-in-java/
KẾ THỪA (INHERITANCE)
1/. Khái niệm Inheritance:
Kế thừa một trụ cột quan trọng của OOP (Lập trình hướng đối ợng). Đây 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 sự liên quan giữa hai class với nhau, trong đó class cha (superclass)
class con (subclass). Khi kế thừa class con được ởng tất cả các phương thức thuộc nh của
class cha. Tuy nhiên, chỉ được truy cập các thành viên public protected của class cha.
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 sử dụng lại (Reusability) các phương thức 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
}
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); }
}
Trong dụ trên class Programmer con của class Employee, 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
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 hoc Base class class
Bicycle
{
//Bicycle class có 2 thuc tính
public int gear; //hp s
public int speed; //tc đ
//Bicycle class có 1 constructor
public Bicycle(int gear, int speed)
{
Kết quả:
Sinh viên nghe giải thích
lOMoARcPSD|36667950
this.gear = gear;
this.speed = speed; }
//Bicycle class có 3 method
public void applyBrake(int decrement)
{
speed -= decrement; //đp thng làm gim tc
}
public void speedUp(int increment)
{
speed += increment; //tăng tc
}
//phương thc toString() dùng xut thông tin
public String toString()
{
return("Gears: "+gear+"\n" + "speed: "+speed);
}
}
//subclass hoc derived class class
MountainBike extends Bicycle
{
//MountainBike subclass có thêm thuc tính
public int seatHeight;
//MountainBike subclass có 1 constructor
public MountainBike(int gear,int speed, int startHeight)
{
//gi constructor ca lp 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 thc toString()ca 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 đ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.
dụ:
(có dùng từ khóa super là constructor của class cha)
mở rộng để sinh viên hiểu trước về override
file
Animal.java
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
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 sở)
cũng như lớp con cũng đóng vai trò 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à.
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();
}
}
lOMoARcPSD|36667950
lOMoARcPSD|36667950
Sa ngưi l
Ăn tht
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.
class
Animal
{
void
eat()
{
System.out.println("Ăn tht");
}
}
class
Dog
extends
Animal
{
void
bark()
{
System.out.println("Sa 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
lOMoARcPSD|36667950
Ví dụ: file TestInheritance3.java
class
Animal
{
void eat() {
System.out.println("Ăn tht");
}
}
class
Dog
extends
Animal
{
void bark() {
System.out.println("Sa 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 gii thích
}
}
Kết quả:
Kêu meo meo
Ăn thịt
Ví dụ: Sinh viên tìm lỗi sai!.
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 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.
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();
}
}
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 hkế 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
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:
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();
}
}
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
quyết định dựa trên kiểu dữ liệu của biến tham
chiếu tại quá trình biên dịch.
Ví dụ:
Phương thức override được gọi do máy ảo Java
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.
import
java.util.*;
class
HinhTron
{
public
final
float
PI
= 3.14f;
public
float
banKinh
;
//Constructor
public
HinhTron(
float
banKinh
)
{
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
Kết quả:
HinhTron
hinhTron
=
new
HinhTron(
bk
)
;
HinhTru
hinhTru
=
new
HinhTru(
bk
,
cc
;
)
hinhTron
.xuatThongTin();
hinhTru
.xuatThongTin();
System.
out
.println(
"Bye."
)
;
sc
.close();
}
}
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 Chim: "
+
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
File Drive1.java:
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 ẩn các chi tiết nội tại, 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.
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 lng: "
+
this
.
Trongluong
;
)
System.
out
.println(
"S lng còn li: "
ốượ
+
this
.
Soluong
)
;
}
}
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 xanh"
ịỏ
,
"Thailand"
, 0.25f, 100);
x
.xemTT();
}
}
Kết quả:
lOMoARcPSD|36667950
Tính trừu tượng giúp ta chú ý đến trọng m hơn vào đối tượng thay quan tâm đến cách thực
hiện.
2/. Lp 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ì đó
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 skhông đị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 phương thức abstract thì lớp đó phải lớp abstract, nếu không 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 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 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 lp abstract trong Java
ụềớ
abstract
class Shape
{
int color;
//phng thc abstract
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 abstract
}
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 thích)
Bike
x
=
new
Honda();
x
.show();
}
}
lOMoARcPSD|36667950
Yamaha chi m 10% th ph nế
Sym chi m 8% th ph nế
Ví dụ 3:
một lớp abstract có 3 lớp con
//Lp abstract không có constructor và có 3 lp con
abstract
class
Bike
{
abstract
void
run();
//phng thc abstract, 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
ịầ
ế
lOMoARcPSD|36667950
dụ 4: một lớp abstract thể chứa các constructor 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 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
https://viettuts.vn/java/abstract-class-trong-java
https://www.geeksforgeeks.org/abstraction-in-java-2/
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:
lOMoARcPSD|36667950
https://www.programiz.com/java-programming/abstract-classes-methods
Quan Hệ Has - a
1/. Quan hệ Has - a:
lập trình thiết kế hướng đối tượng, has-a mối quan hệ thành phần trong đó một đối tượng "thuộc
về" một đối tượng khác hành xử theo các quy tắc sở hữu. Nói một cách đơn giản, 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ụ:
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 quan hệ Has a
?
File Address.java:
File Student.java:
public
class
Address
{
String
City
;
String
Country
;
String
Phonenumber
;
}
public
class
Student
{
String
Id
;
String
Name
;
Address
Saddress
;
}
public
class
Address
{
String
City
;
String
Country
;
String
Phonenumber
;
public
Address(String
city
, String
country
, String
phonenumber
)
{
City
=
city
;
Country
=
country
;
Phonenumber
=
phonenumber
;
}
}
lOMoARcPSD|36667950
public class Student
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ả:
{
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
)
;
}
}
lOMoARcPSD|36667950
S dng Has a làm tăng tính tái s dng code. Khi ta thy gia các class các thông tin chung
ging ht nhau thì ta nên tách nh ra thành mt class khác bao gm nhng thuc tính chung.
Các bạn đừng nhm ln Has A vi Is a tha kế. Tha kế (Is a) mt khái nim mà các
class con s dng li các thuc tính và method ca class cha có sn. Has a là ly những điểm
chung ra riêng một class và import vào các class khác để s dng.
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ế 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:
2
/. Has a sử dụng khi nào?
:
class
HardDisk
{
String
Loai
;
public
HardDisk()
{
}
lOMoARcPSD|36667950
File Computer.java:
public
void
Dung()
{
System.
out
.println(
"Đĩa cng thuc loi : "
+
Loai
)
;
}
}
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 Seagate"
)
;
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ả:
| 1/28

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ả: