CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

บทที่ 8 Object-Oriented Programming

ในการเขียนโปรแกรมดวยภาษา Java จากบทเรียนที่ผานมา จะเปนการวางพื้นฐานเกี่ยวกับโครงสราง

และคําสั่งตางๆ ที่ใชในภาษา Java สําหรับบทนี้จะเปนการแนะนําการเขียนโปรแกรมดวยภาษา Java ใน
ลักษณะเชิงวัตถุ โดยจะนําเสนอเทคนิคตางๆ เชน การสืบทอด (inheritance) การซอนขอมูล (encapsulation)
โครงสรางขอมูลแบบ abstract data type (ADT) การสรางและทําลาย object ในโปรแกรม เปนตน

8.1 การสืบทอด (Inheritance)

หลักการของการสืบทอดเปนการนํา class ทีเ่ คยสรางไวแลว นํากลับมาใชใหม โดยใชหลักการของ

การมีคณ
ุ สมบัติบางอยางรวมกันของแตละ object

class ทีเ่ ปนตนแบบ จะเรียกวา super-class หรือ based-class หรือ parent-class สวน class ที่
แตกออกมาจาก class ตนแบบ เรียกวา sub-class หรือ derived-class หรือ child-class ในการสืบทอด sub-
class จะมีคุณสมบัติรวมเหมือนกับ super-class

ตัวอยางเชน นักศึกษาแตละคนของ CS313 มีโครงสรางประวัติสวนตัวเหมือนกัน คือ มีชื่อ-สกุล ที่อยู

ในขณะเดียวกันนักศึกษาแตละคนของ CS499 ก็ตอ งมีการจัดเก็บประวัติสวนตัวเชนกัน ดังนั้นหากทําการออก
แบบโปรแกรมเชิงวัตถุ super-class คือการเก็บทะเบียนประวัติสวนตัว สวน sub-class ในตัวอยางนี้จะมี 2
sub-class คือนักศึกษาที่เรียนวิชา CS313 และ sub-class ของนักศึกษาที่เรียนวิชา CS499

อยางไรก็ตาม sub-class แตละ sub-class อาจมีคุณสมบัติเฉพาะตัว ที่ super-class และ sub-

class อื่น ไมมี เชน sub-class วิชา CS313 มีโครงสรางการเก็บคะแนนที่ตางกับ sub-class วิชา CS499

การสืบทอดของ class ตางๆ จะมีลักษณะเปนลําดับชั้น ( hierarchy ) กลาวคือ การสืบทอดไมได

จํากัดเพียงระหวาง super-class และ sub-class เทานั้น ตัว sub-class เอง สามารถเปน super-class ของอีก
class หนึง่ ได ในการเขียนแผนภาพความสัมพันธระหวาง super-class และ sub-class นิยมเขียนเปนแผนผัง
แบบ tree ดังตัวอยางแผนผังการสืบทอดของ class ในระบบบัญชีธนาคาร ซึ่งบัญชีแตละประเภทจะมีการ
ทํางานพืน้ ฐานที่เหมือนกัน คือ การคํานวณหายอดคงเหลือ ( balance) การฝาก (deposit) และการถอน
(withdraw) ดังนั้นในสวนของ super class จะมีการทํางานทั้งสามสวนนี้ประกาศอยู อยางไรก็ตามในบัญชีแต
ละประเภท จะมีคุณสมบัติที่แตกตางกันออกไป ดังระบุในแผนผัง นอกจากนี้ใน class บัญชีออมทรัพย ยังทํา
หนาที่เปน super class ของ class บัญชีออมทรัพยพิเศษดวย

2/2545 1
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

บัญชีธนาคาร
getBalance()
deposit()
widthdraw()

กระแสรายวัน บัญชีออมทรัพย บัญชีฝากประจํา

deductFees
addInterest() addInterest()
taxDeduction()

บัญชีออมทรัพยพิเศษ
minWithdrawPerMonth()

ดังนัน้ สรุปไดวา หลักสําคัญประการหนึ่งในการออกแบบเชิงวัตถุคือ ตองพยายามหาคุณสมบัติทั่วไป

ของ class ซึง่ จะเปน class พื้นฐาน หรือ super-class ของ sub-class อื่นนั่นเอง

8.2 Inheriting Instance Variable and Methods

จากที่กลาวมาแลววา super-class เปนพื้นฐานของทุก class สวน class ทีส่ รางจาก super-class

เหลานี้ เรียกวาเปน sub-class โดยหลักการทั่วไป sub-class จะมีการเพิ่มเติม method หรือ variable จาก
super-class ซึง่ สามารถสรุปคุณลักษณะของ sub-class ไดดังนี้
1. Overriding คือ การเขียน method ทีม่ ีชื่อเหมือน super-class ทุกอยาง เมื่อมีการเรียก method
เหลานี้ทํางาน จะขึ้นอยูกับ object ทีส่ ราง วาสรางจาก sub-class หรือ super-class หากเปน
การสรางจาก sub-class method ทีถ่ กู เรียกใชจะเปนของ sub-class ซึง่ เปนลักษณะของ
overriding นัน่ เอง แตหาก object นัน้ ถูกสรางจาก super-class method ทีถ่ กู เรียกจะเปนของ
super-class อยางไรก็ตาม method ที่มี modifier เปน private, static, final ตัว sub-class จะ
ไมสามารถ override ได
2. Inherit หากไมมีการ overriding แลว method ตางๆ จาก super-class จะไดรับการสืบทอด
มายัง sub-class
3. การสราง method ใหม sub-class สามารถสราง method ใหมได รวมทั้งการเพิ่มเติมคุณ
ลักษณะประจําของ sub-class นั้นๆ ดวย

โดยหลักการของการประมวลผลและออกแบบโปรแกรมเชิงวัตถุ class แตละ class สามารถกําหนด

ขอบเขตของความสามารถในการเรียกประมวลผล ดังนั้นถึงแมวาการสืบทอดจะมีคุณสมบัติที่กลาววา สามารถ
ใหการสืบทอดของคุณสมบัติตางๆ ไปยัง sub-class ได แตไมไดหมายความวาสมาชิก หรือคุณสมบัติ ทุกราย

2/2545 2
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

การสามารถสืบทอดไปยัง sub-class ไดทงั้ หมด ทั้งนี้ขึ้นอยูกับการกําหนดการเขาถึงของ modifier ทีก่ ํากับ

สมาชิกของ super-class ดวย

การกําหนดการเขาถึงดวย access modifier มีผลทําให sub-class ไมสามารถมองเห็น หรือประมวล

ผลไดอยางจํากัด กับ method หรือ variable ของ super-class access modifier ทีน่ ยิ มใชมีดังนี้
1. public ไมวาจะระบุที่ method หรือ variable แสดงวา class ใดๆ สามารถเรียกประมวลผลได
2. private method หรือ variable จะถูกเรียกประมวลผลไดเมื่ออยูภายใน class นั้นๆ เทานั้น แม
แต sub-class ก็ไมสามารถเรียกใชงานได
3. protected method หรือ variable จะถูกเรียกประมวลผลก็ตอเมื่อเปนสมาชิกของ class หรือ
เปน sub-class ทีแ่ มวาจะอยูคนละ package ก็สามารถเรียกประมวลผลได

ตัวอยางที่ 8.1 การสืบทอดและการเขาถึงตัวแปร และ method ตางๆ

class X {
public int varXPublic = 0;
protected int varXProtected = 0;
private int varXPrivate = 0;

public void methodX() {

System.out.println(“In super X”);
varXPublic = 10;
varXProtected = 10;
varXPrivate = 10;
}

protected void protectedMethodX() {

System.out.println(“In proctected method in class X”);
}
} // class X

class Y extends X {
public int varYPublic = 0;
protected int varYProtected = 0;
private int varYPrivate = 0;

void methodY() {
varYPublic = 5;
varYProtected = 5;
varYPrivate = 5;
System.out.println(“In subclass Y”);
System.out.println(“Access Protected super X ” + varXProtected);
// System.out.println(“Access Protected super X ” + varXPrivate);
}

protected void protectedMethodX() {

super.protectedMethodX();
System.out.println(“In protected method in class Y”);
}
} // class Y

2/2545 3
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

ตัวอยางที่ 8.1 (ตอ)

class TestAccessMember {
public static void main (String args[] ) {
X objX = new X();
Y objY = new Y();
System.out.println(“Test private case”);
// System.out.println(“Access super X ” + objX.varXPrivate);
// System.out.println(“Access subclass Y ”+objY.varYPrivate);
// objY.methodY();
System.out.println(“Test public case”);
System.out.println(“Access super X ”+objY.varXPublic);
System.out.println(“Access subclass Y ”+objY.varYPublic);

System.out.println(“Test protected case”);

System.out.println(“Access super X ”+objY.varXProtected);
System.out.println(“Access subclass Y “+objY.varYProtected);

System.out.println(“Test protected method”);

objX.protectedMethodX();
objY.protectedMethodX();
}
} // end

ในตัวอยางที่ 8.1 จะมีการประกาศ class จํานวนทั้งสิ้น 3 class คือ X, Y และ TestAccessMember

โดยที่ class Y จะถูกประกาศใหเปน sub-class ของ class X โดยใชคําสั่ง extends ซึง่ มีรปู แบบการใชงานดัง
ตอไปนี้
class sub-class name extends super-class name

คําถามชวนคิด
ในตัวอยางที่ 8.1 ใหนักศึกษาลองเอา comment ออก ในบรรทัดที่ถูก comment ไว แลวดูผลลัพธของโปรแกรมวา
เปนอยางไร และทําไมจึงเปนเชนนั้น

ในการประกาศ method ชื่อ ProtectedMethodX ของ class Y พบวา method นีม้ ชี ื่อเหมือนกับ
method ใน class X เพือ่ มิใหเกิดความสับสนในการเรียกใช method หรือ variable ทีม่ ชี ื่อซํ้ากันทั้งใน super-
class และ sub-class สามารถทําไดโดยใช this และ super เมื่อ this เปนการอางอิงถึง object ของ class ที่
กําลังประมวลผลอยู สวน super เปนการอางอิงถึง method หรือ variable ของ super-class

2/2545 4
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

ตัวอยางที่ 8.2
class Point2D {
int x, y;
Point2D (int x, int y) { // Point2D1
this.x = x;
this.y = y;
}

Point2D (int x) { // Point2D2

this(x, 0);
}

Point2D () { // Point2D3
this(0,0);
}
}

class Point3D extends Point2D {

int z;
Point3D(int x, int y, int z) { // Point3D1
// this.x = super.x = x;
// this.y = super y = y;
super(x, y);
this.z = z;
}

Point3D (int z) { // Point3D2

super(0,0);
this.z = z;
}

Point3D() { // Point3D3
this(0,0,0);
}
}

class DemoThisSuper {
public static void main (String args[] ) {
Point3D d1 = new Point3D();
System.out.println(“x = “ + d1.x + “ y = “ + d1.y + “ z = “ + d1.z);
Point3D d2 = new Point3D(20,30,4);
System.out.println(“x = “ + d2.x + “ y = “ + d2.y + “ z = “ + d2.z);
}
}

จากตัวอยางโปรแกรมที่ 8.2 พิจารณาการสราง object ตอไปนี้ วาทําการเรียก constructor ตัวใดบาง

:- Point2D1, Point2D2, Point2D3, Point3D1, Point3D2 หรือ Point3D3
1. Point2D var1 = new Point3D();
เรียก Point3D3 ! Point3D1 ! Point2D1
2. Point2D var2 = new Point2D(5,4);
เรียก Point2D1

2/2545 5
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

3. Point3D var3 = new Point3D();

เรียกเชนเดียวกับขอ 1
4. Point3D var4 = new Point3D(3,4,5);
เรียก Point3D1 ! Point2D1
5. Point3D var5 = new Point3D(5);
เรียก Point3D2 ! Point2D1
6. Point3D var6 = new Point3D(5,6);
ไมมี constructor ทีส่ อดคลอง

8.3 Polymorphism

คุณสมบัติ polymorphism ในภาษา Java สามารถชวยใหการเขียนโปรแกรมกระชับ และงายขึ้น

กลาวคือ ใหพิจารณาการเขียนโปรแกรมสําหรับการคํานวณพื้นที่ของรูปเรขาคณิตแบบตางๆ เชน สี่เหลี่ยม
สามเหลีย่ ม และ วงกลม ซึ่งมีสูตรคํานวณที่แตกตางกันไป หากใชวิธีการเขียนโปรแกรมเชิงโครงสราง การคิด
คํานวณอาจตองใชโครงสราง If-then-else หรือ switch/case มาชวยในการพิจารณาเลือกคํานวณพื้นที่ที่
ตองการ แตสําหรับการเขียนโปรแกรมเชิงวัตถุแลว เราสามารถนําเอาคุณสมบัติ polymorphism มาชวยในการ
แกปญหาไดดังนี้
1. รูปสีเ่ หลีย่ ม สามเหลี่ยม และวงกลม ตางมีคุณสมบัติรวมกัน คือ การเปนรูปเรขาคณิต (shape)
ดังนัน้ อาจกลาวอีกนัยหนึ่งไดวา รูปตางๆ เหลานี้ จะเปน sub-class จาก class รูปเรขาคณิต
2. class รูปเรขาคณิต จะมีสมาชิกของ class เปนตัวแปร 3 ตัว คือ คา x, y และชื่อรูปทรง และมี 1
constructor ซึง่ จะกําหนดคาใหกับตัวแปรทั้ง 3 นอกจากนี้ยังมี 2 method คือ getName() และ
calArea()
3. แตละรูปทรงจะมี class เปนของตนเอง และแตละ class นัน้ จะมี 1 constructor และ 1 method

โครงสรางความสัมพันธของ class ตางๆ เหลานี้ สามารถแสดงไดดังแผนผังตอไปนี้

Shape
double x, y
String fname

Shape
getName
double calArea()

Circle Triangle Rectangle1

double x, y double x, y double x, y
String fname String fname String fname

Circle Triangle Rectangle1

double calArea() double calArea() double calArea()

2/2545 6
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

แตละ class สามารถที่จะกําหนด method calArea() สําหรับการคํานวณที่เหมาะสมกับรูปราง หรือ

class นั้นๆ โดยใชชื่อ method เหมือนกันได หรือกลาวอีกนัยหนึ่งคือ calArea() อยูใ นลักษณะของ
polymorphism นัน่ เอง ซึง่ จากแผนภาพขางตนนี้ สามารถเขียนโปรแกรมได ดังแสดงในตัวอยางที่ 8.3

ตัวอยางที่ 8.3 แสดงคุณสมบัติ polymorphism

class Shape {
double x, y;
String fName;
Shape (double x, double y, String name) {
this.x = x;
this.y = y;
fName = name;
}
String getName() {
return fName;
}
double calArea() {
return 0.0;
}
}

class Circle extends Shape {

Circle (double x, double y, String name) {
super(x, y, name);
}
double calArea() {
return(0.5*Math.PI*Math.pow(x,2.0));
}
}

class Triangle extends Shape {

Triangle(double x, double y, String name) {
super(x, y, name);
}
double calArea() {
return(0.5*x*y);
}
}

class Rectangle1 extends Shape {

Rectangle1(double x, double y, String name) {
super(x, y, name);
}
double calArea() {
return(x*y);
}
}

public class TestPolymorphism {

public static void main(String args[]) {
Shape[] tmpShape = new Shape[3];
tmpShape[0] = new Circle(5,0.0,”Circle1”);
tmpShape[1] = new Triangle(5,8.0,”Triangle”);
tmpShape[2] = new Rectangle1(5,3.0,”Rectangle”);
for (int j=0; j<3; j++) {
System.out.print(“The area of “+tmpShape[j].getName());
System.out.println(” is ”+tmpShape[j].calArea());
}
}
}

2/2545 7
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

8.4 Abstract class and Abstract Method

ในภาษา Java method ทีป่ ระมวลผลจะตองปรากฏในชวงของการ compile เพื่อที่ compiler จะ

สามารถตรวจสอบ method เหลานั้นได อยางไรก็ตามในการพัฒนาระบบงาน แตละ sub-class อาจตองมี
กรรมวิธกี ารในการเขียนชุดคําสั่งที่แตกตางกัน เพื่อใหเกิดความคลองตัวในการพัฒนา จึงเกิดเทคนิคในการ
สราง class แบบ abstract class โดยทีค่ วามหมายของคําวา abstract คือ เปน class เชิงนาม ไมมีตัวตนอยู
จริง หรืออีกนัยหนึ่งคือ ไมมีชุดคําสั่งในการทํางานนั่นเอง ดังนั้น abstract class จะไมสามารถสราง object ได
การสราง object ตองกระทําที่ super-class เทานั้น abstract class ตองประกอบดวย method ที่เปน
abstract อยางนอย 1 method
การกําหนด abstract class ทําไดโดยการพิมพ abstract ในสวนของ modifier จากตัวอยางที่ 8.3
เราอาจกําหนดให class Shape เปน abstract class ได โดยพิมพคําวา abstract ไวหนาบรรทัดที่ประกาศ
class ดังนี้
abstract class Shape() {
……….
}
หากตองการกําหนดให calArea() เปน abstract method ทําไดโดยการพิมพคําวา abstract ในสวน
ของ access modifier และในสวนของคําสั่ง หรือ body ของ method ก็ทาการลบทิ ํ ้ง เนื่องจาก abstract
method จะไมมกี ารกําหนดคําสั่งในการทํางานแตอยางใด
abstract double calArea();

8.5 การปองกันการแกไขหรือเปลี่ยนแปลงการทํางานของ class ดวย final

หลักการหนึง่ ของการโปรแกรมเชิงวัตถุ คือ ความสามารถในการซอนขอมูล (encapsulation) เพื่อไมให

ผูอ นื่ แกไข หรือเปลี่ยนแปลง การกําหนดเชนนี้ในภาษา Java สามารถทําไดโดยการกําหนดคาของ modifier ให
มีคาเปน final โดยที่ผลลัพธของ final มีรายละเอียดดังนี้

- เมื่อใช final กับ variable เปนการกําหนดวา variable ตัวนีไ้ มสามารถเปลี่ยนแปลงคาได (คาคงที่)

- หากใช final กับ method เปนการปองกันการ override และเปนการลดเวลาในการ load method
- การกําหนด final กับ class ทําให class นัน้ ไมสามารถเปน super-class ได ขอควรระวังคือ class
ดังกลาวตองไมมี abstract method เนือ่ งจาก abstract method ตองเปน method ใน abstract class ซึ่งไม
สามารถสราง object ได

2/2545 8
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

8.6 Interfaces

ในภาษา Java ใช interface เปนตัวเชื่อมประสานระหวาง class ทีไ่ มมีความสัมพันธกัน แตตองการที่

จะติดตอหรือสงขอมูลใหกับอีก object ของอีก class หนึ่ง

การสราง interface จะคลายกับการสราง class แตการประกาศจะแตกตางจากการสราง class และ

มีขอ จํากัดมากกวา ดังนี้
1. interface ไมสามารถมีตัวแปร instance แตสามารถมีตัวแปรคาคงที่ได การประกาศตัวแปรคา
คงที่ ไมจําเปนตองประกาศเปน public static final เพราะ compiler จะเติมใหโดยอัตโนมัติ
2. method ตางๆ ใน interface จะตองเปน abstract method เทานั้น กลาวคือ มีแตชื่อตัวแปรที่สง
ผานคา ซึ่งจะแตกตางจาก abstract class ที่ method ใน abstract class ไมจําเปนตองเปน
abstract method ทุก class
3. method ตางๆ ตองมี access modifier เปน public อยางเดียวเทานั้น หากไมระบุเปน public
จะใชไดเฉพาะภายใน package เทานั้น

รูปแบบ
public interface InterfaceName extends SuperInterfaces {… Interface body … }

จากรูปแบบการสราง interface สามารถสรุปลักษณะของ interface ไดดังนี้

1. interface สามารถขยายเพิ่มจาก interface อื่นได เชน SuperInterfaces และสามารถเพิ่มได
หลายๆ interface ในคราวเดียวกัน ซึ่งจะแตกตางจาก class ทีส่ ืบทอดไดเพียง class เดียวเทา
นั้น การสืบทอดของ interface จะใชหลักการเดียวกันกับการสืบทอดของ class แตสิ่งที่สืบทอด
ไดคือ ตัวแปรคาคงที่ และ abstract method เทานั้น
2. คําสั่งในสวนของ interface กรณีเปน abstract method จะมีรูปแบบดังนี้
access_modifier return_type methodName( parameterList );

3. ไมจาเป
ํ นตองใสเครื่องหมาย { } access_modifier ของ method โดยปกติจะเปน public
abstract โดยอัตโนมัติ

ในการใชงาน interface ในภาษา Java นั้น class ตางๆ สามารถสืบทอดจาก super-class ไดเพียง
class เดียว แตการใช interface สามารถที่จะใชไดไมจํากัด

รูปแบบ class SubClassName implements InterfaceName1, InterfaceName2, … { … }

2/2545 9
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

การประยุกตใชงาน interface สามารถประยุกตได 2 แบบ คือ

1. ประยุกตโดยใชคําสั่ง implements ตามรูปแบบขางตน การเขียนโปรแกรมดวยคําสั่งขางตนทําให
ตองประยุกต method ตางๆ ของ interface ใน class นัน้ ทัง้ หมด ถึงแมจะไมใชงานก็ตาม
2. การประยุกตใช interface แบบ inner class ในการประยุกตแบบนี้ method ของ interface ไม
สามารถเรียกประมวลผลได ยกเวน class นัน้ จะเขียน method ประมวลผล method ของ
interface ให
ไมวา จะประยุกตแบบใดก็ตาม การเรียกใชงานตองมีการสราง object กอน

ตัวอยางที่ 8.4 การประกาศ และใชงาน interface

public abstract interface MainInterface {
public abstract void interface1();
public abstract void interface2();
}

การประยุกตแบบ implements การประยุกตแบบ inner class

class X implements MainInterface { class X {
public void interface1() { public void testXinterface() {
System.out.println(“use interface 1”); System.out.println(“In class X”);
} new InnerX().interface1();
public void interface2() { }
System.out.println(“use interface 2”); class InnerX implements MainInterface {
} public void interface1() {
} System.out.println(“implement
interface1 as inner class”);
public class TestInterface { }
public static void main(String args[] ) { public void interface2() {
System.out.println(“Interface using”); System.out.println(“implement
X obj = new X(); interface2 as inner class”);
obj.interface2(); }
MainInterface obj1 = new X(); }
obj.interface1(); }
}
} public class TestInterface2 {
public static void main(String args[] ) {
System.out.println(“Interface using2”);
X obj = new X();
obj.testXinterface();
}
}

2/2545 10
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

8.7 Packages

Packages เปนชุดของ class และ interface ทีม่ คี วามสัมพันธใกลเคียงกัน หรือมีจุดประสงคแบบ

เดียวกัน packages สามารถลดปญหาในการตั้งชื่อซํ้ากัน และควบคุมการมองเห็นของ class, interface,
method และ variable จาก class ภายนอก package ได

ในทางปฏิบัติ package ก็คือ directory นัน่ เอง เชน package java.awt.image เปนการอางอิง
directory c:\java\awt\image อยางไรก็ตามตัวแปรภาษา Java รุน ใหม ไมจําเปนตองแยกการเก็บ package
เปน directory ใหเห็นอยางชัดเจนเชนนี้ แตจะรวมไวในแฟมขอมูลประเภท jar แตการจัดหรือรวบรวม class
ในแฟม jar ยังคงใชหลักของการจัดการ directory ซึง่ สามารถตรวจสอบในขณะ compile โดยใส option -
verbose ในคําสั่ง javac

การสราง package เพื่อรวบรวม class หรือ interface ทีม่ คี วามใกลเคียงกันใหเปนหมวดหมูมีลําดับ

ดังนี้
1. ทีต่ นแฟมขอมูลของ class ใหพิมพคําวา package mypack.myclass
โดยที่ mypack.myclass คือ directory ที่เก็บไฟล .class จากการ compile
2. การ compile หากไมตองการระบุ directory ในการเก็บ package ก็ใชคําสั่งในการ compile
ปกติ ซึ่ง Java จะนํา class ที่ไดไปเก็บใน directory ทีต่ ิดตั้ง Java ( เชน jdk1.2.1\lib\ )
หากตองการระบุ directory ทีต่ องการ ให compile โดยใช option ดังตัวอยางตอไปนี้
javac –d c:\directory1\sub1 javaprogram.java
โดยที่ directory1\sub1 ไมรวม directory ทีไ่ ดระบุไวในคําสั่ง package

การเรียก package มาใชงานสามารถสั่งได 2 แบบ คือ

1. class ทีต่ อ งการอางอิงถึง class ใน package ตองเพิ่มคําสั่ง import ทีต่ นของแฟมขอมูล ทําให
ไมตองระบุชื่อ package ทุกครัง้ ทีต่ องการเรียกใชงาน

import package_name.class_name;
หรือ import package_name.*; // อางถึงทุก class ใน package_name นั้นๆ

2. ไมตองสั่งดวยคําสั่ง import แตใหระบุชื่อเต็มของ package ทุกครัง้ ที่ตองการใชงาน เชน

java.util.Date tmpDate = new java.util.Date();

อยางไรก็ตาม มีขอควรระวังคือ ตอน compile โปรแกรม อาจหา class ไมพบ ซึ่งหากพบปญหานี้ให

ระบุ class path ดวย ซึ่งสามารถกําหนดในแฟมขอมูล autoexec.bat ดังนี้
SET CLASSPATH=.;C:\java\lib; C:\mypack\myclass

หรือ กําหนดตอน compile ดังนี้

javac –classpath c:\mypack\myclass JavaClass.java

2/2545 11
CS313: Object-Oriented Programming บทที่ 8: Object-Oriented Programming

ตัวอยางที่ 8.5 การใช package

package MyPack;
public class X {
public int varXPublic = 0;
protected int varXProtected = 0;
private int varXPrivate = 0;

public void methodX() {

System.out.println(“In super X”);
varXPublic = 10;
varXProtected = 20;
varXPrivate = 30;

protected void protectedMethodX() {

System.out.println(“In protected method in class X”);
}
}

package MyPack;
public class Y extends X {
public int varYPublic = 0;
protected int varYProtected = 0;
private int varYPrivate = 0;

public void methodY() {

varYPublic = 15;
varYProtected = 25;
varYPrivate = 35;
System.out.println(“In subclass Y”);
System.out.println(“Access Protected super X “ + varXProtected);
}

protected void protectedMethodX() {

super.protectedMethodX();
System.out.println(“In protected method in class Y”);
}
}

import MyPack.*;
class TestAccessMember1 {
public static void main (String args[] ) {
X objX = new X();
Y objY = new Y();
System.out.println(“Test public case”);
System.out.println(“Access super X “+objY.varXPublic);
System.out.println(“Access subclass Y “+objY.varYPublic);
}
}

2/2545 12