คลาสและออบเจ็คมีความสัมพันธ์ต่อ กล่าวได้ว่าคลาส เป็นโครงสร้างต้นแบบของออบเจ็ค โดยบทนี้จะอธิบายรายละเอียดเกี่ยวกับคลาสและออบเจ็คให้ทราบ รวมถึงจะอธิบายเกี่ยวกับแอตทริบิวต์และเมธอดของออบเจ็คด้วย นอกจากนี้จะอธิบายถึง Modifier ประเภทต่างๆ เนื่องจากการทำงานกับคลาส แอตทริบิวต์และ เมธอดจะเกี่ยวข้องกับ Modifier เสมอ

คลาส (Class) คือ ต้นแบบของวัตถุ การจะสร้างวัตถุขึ้นมาอย่างหนึ่ง จะต้องสร้างคลาสขึ้นมาเป็นโครงสร้างต้นแบบสำหรับวัตถุก่อนเสมอ

วัตถุหรือออบเจ็ค (Object) คือ สิ่งที่ประกอบด้วยคุณสมบัติ 2 ประการ คือ คุณลักษณะ และพฤติกรรม
- คุณลักษณะ (Attribute หรือ Data) คือ สิ่งที่บ่งบอกลักษณะทั่วไปของวัตถุ
- พฤติกรรม (Behavior หรือ Method) คือ สิ่งที่วัตถุสามารถกระทำออกมาได้

ตัวอย่างของออบเจ็ค เช่น

ออบเจ็ค “พนักงานบริษัท”
	แอตทริบิวต์	รหัสพนักงาน, เงินเดือน, เวลาเข้า-ออกงาน
	เมธอด	รูดบัตรพนักงาน, รับเงินเดือน

ออบเจ็ค “โทรทัศน์”
	แอตทริบิวต์	ยี่ห้อ, ขนาด, ระบบเสียง, ฟังก์ชั่นการทำงาน
	เมธอด	เปิด, ปิด, เพิ่ม-ลด, ปรับความคมชัดของภาพ

ออบเจ็ค “รถจักรยานยนต์”
	แอตทริบิวต์	ยี่ห้อ, ขนาด, ระบบเสียง, ฟังก์ชั่นการทำงาน
	เมธอด	ติดเครื่อง, ออกตัว, เลี้ยว, เปลี่ยนเกียร์, หยุดรถ

ออบเจ็ค “โทรศัพ์มือถือ”
	แอตทริบิวต์	ยี่ห้อ, รุ่น, จอภาพ, รูปแบบของเสียงเรียกเข้า
	เมธอด	เปิด, ปิด, เลือกรูปแบบของเสียงเรียกเข้า, ตั้งเวลาปลุก

Modifier ในภาษาจาวาแบ่งออกเป็น ประเภทใหญ่ๆ คือ access modifier และ non-access modifier

- access modifier ได้แก่ private, public, protected และ package (อาจเรียก package ว่า none, default หรือ friendly ก็ได้)
- non-access modifier ได้แก่ final, abstract, static, native, transient, volatile, synchronized, strictfp

สำหรับบทนี้จะอธิบายเฉพาะ access modifier เท่านั้น ส่วน non-access modifier จะอธิบายแทรกไว้ในแต่ละบท เมื่อพบส่วนของเนื้อหาที่เกี่ยวข้องสัมพันธ์กับ modifier เหล่านั้น

access modifier ใช้กำหนดไว้หน้าคลาส แอตทริบิวต์ หรือเมธอดใดๆ เพื่อกำหนดระดับการเข้าใช้งาน โดยสำหรับ modifier public และ package สามารถใช้กำหนดให้กับคลาส แอตทริบิวต์ หรือเมธอดก็ได้ ส่วน modifier protected และ private ใช้กำหนดให้กับคลาสไม่ได้ แต่สามารถใช้กำหนดให้กับแอตทริบิวต์หรือเมธอดได้ ดังตารางที่ 1

ตารางที่ 1 สรุปการนำ access modifier แต่ละแบบไปใช้งาน

จาวาแบ่งระดับของ access modifier ออกเป็น 4 ระดับ คือ
- public (สาธารณะ) หากกำหนด modifier public ให้กับคลาส แอตทริบิวต์ หรือเมธอดใดแล้ว คลาสอื่นๆจะสามารถเข้าใช้งานคลาส แอตทริบิวต์หรือเมธอดนั้นได้อย่างอิสระ ไม่มีขีดจำกัด
- protected (ถูกปกป้อง) ไม่ได้เปิดให้คลาสใดๆสามารถเข้าใช้งานได้อย่างอิสระ แต่ก็ไม่ถึงกลับปิดไม่ให้ใครเข้าใช้งานเลย ดังนี้
- กรณีที่กำหนด modifier เป็น protected ให้กับ member (แอตทริบิวต์และเมธอด) ของคลาสแล้ว คลาสอื่นๆในแพ็กเกจเดียวกันจะสามารถเรียกใช้งาน member เหล่านั้นได้ สมมติเช่นคลาส A กับคลาส B อยู่ในแพ็กเกจเดียวกันและคลาส A กำหนด modifier เป็น protected ให้กับ member ของคลาสแล้ว คลาส B จะสามารถเรียกใช้งาน member ของคลาส A ที่ถูกกำหนด modifier เป็น protected ได้
- กรณีที่กำหนด modifier เป็น protected ให้กับ member ของคลาสแล้ว คลาสอื่นๆที่อยู่ต่างแพ็กเกจกันกับคลาสนี้จะไม่สามารถเรียกใช้งาน member เหล่านั้นได้ สมมติเช่นคลาส A กับคลาส B อยู่ต่างแพ็กเกจกัน และคลาส A กำหนด modifier เป็น protected ให้กับ member ของคลาสแล้ว คลาส B จะไม่สามารถเรียกใช้งาน member ของคลาส A ที่ถูกกำหนด modifier เป็น protected ได้
- กรณีที่กำหนด modifier เป็น protected ให้กับ member ของคลาสแล้ว คลาสอื่นๆที่มีความสัมพันธ์เป็นคลาสแม่คลาสลูกกันกับคลาสนี้ ถึงแม้จะอยู่คนละแพ็กเกจกัน ก็จะสามารถเรียกใช้งาน member เหล่านั้นได้ สมมติเช่นคลาส A กับคลาส B อยู่ต่างแพ็กเกจกันแต่คลาส A และคลาส B มีความสัมพันธ์เป็นคลาสแม่คลาสลูกกัน และคลาส A กำหนด modifier เป็น protected ให้กับ member ของคลาสแล้ว คลาส B จะสามารถเรียกใช้งาน member ของคลาส A ที่ถูกกำหนด modifier เป็น protected ได้
- package กรณีที่ไม่ได้กำหนด modifier ใดๆไว้หน้าคลาส แอตทริบิวต์หรือเมธอด จะทำให้คลาสแอตทริบิวต์ หรือเมธอดนั้น มีระดับการเข้าถึงเป็น package ซึ่งหมายความว่า คลาสที่อยู่ในแพ็กเกจอื่นจะไม่สามารถเข้าใช้งานคลาส แอตทริบิวต์ หรือเมธอดเหล่านี้ได้
- private (ส่วนบุคคล) หมายถึง แอตทริบิวต์และเมธอดของคลาสจะถูกหุ้มห่อ (Encapsulate) เอาไว้ ปิดกั้นไม่ให้คลาสอื่นเข้ามาใช้งานแอตทริบิวต์หรือเมธอดที่ถูกกำหนด modifier เป็น private ได้

กล่าวคือ จะมีแต่เฉพาะคลาสของมันเองเท่านั้นที่มีสิทธิ์ใช้งานได้ หลักการนี้เรียกว่า Information hiding

ตารางที่ 2 สรุปการทำงานของ access-modifier แต่ละแบบ

ตัวอย่างที่ 1.1   กำหนดคลาส A ดังนี้ จงตอบคำถามว่าโปรแกรมนี้คอมไพล์ผ่านหรือไม่ เพราะเหตุใด

protected class A { public int a1 = 1; protected int a2 = 2; int a3 = 3; private int a4 = 4; }

ตัวอย่างที่ 1.2 กำหนดคลาส A ดังนี้ จงตอบคำถามว่าโปรแกรมนี้คอมไพล์ผ่านหรือไม่ เพราะเหตุใด

private class A { public int a1 = 1; protected int a2 = 2; int a3 = 3; private int a4 = 4; }

โปรแกรมคอมไพล์ไม่ผ่าน เนื่องจากเราไม่สามารถนำ modifier private มากำหนดให้หับคลาสได้

ตัวอย่างที่ 1.3 กำหนดคลาส A ดังนี้ จงตอบคำถามว่าโปรแกรมนี้คอมไพล์ผ่านหรือไม่ เพราะเหตุใด

โปรแกรมคอมไพล์ผ่าน เพราะสามารถนำ modifier package มากำหนดให้กับคลาสได้ รวมถึงสามารถนำ modifier public, protected, package, private มากำหนดให้กับแอตทริบิวต์ a1, a2, a3, a4 และสามารถนำ modifier public, protected, package, private มากำหนดให้กับเมธอด method1, method2, method3, method4 ได้ตามลำดับ

ตัวอย่างที่ 1.4 กำหนดคลาส A ดังนี้ จงตอบคำถามว่าโปรแกรมนี้คอมไพล์ผ่านหรือไม่ เพราะเหตุใด

public class A { }

ตัวอย่างที่ 1.5 กำหนดคลาส A ดังนี้

Package test.classA; public class A { public int a1 = 1; protected int a2 = 2; int a3 = 3; private int a4 = 4; }

และสมมติว่ากำหนดคลาส B ให้อยู่ในแพ็กเกจ test.classB ดังนี้

Package test.classB; public class B { }

จงตอบคำถามดังต่อไปนี้

- คลาส B สามารถเรียกใช้งานแอตทริบิวต์ a1 ของคลาส A ได้หรือไม่ เพราะเหตุใดได้ เพราะ แอตทริบิวต์ a1 มี modifier เป็น public คลาส B จึงสามารถเรียกใช้งานแอตทริบิวต์ a1 ได้อย่างไม่มีขีดจำกัด
- คลาส B สามารถเรียกใช้งานแอตทริบิวต์ a2 ของคลาส A ได้หรือไม่ เพราะเหตุใดไม่ได้ เนื่องจากคลาส B อยู่ในแพ็กเกจ test.classB ส่วนคลาส A อยู่ในแพ็กเกจ test.classA ซึ่งเป็นคนละแพ็กเกจกัน ดังนั้น คลาส B จึงไม่สามารถเรียกใช้งานแอตทริบิวต์ a2 ซึ่งมี modifier เป็น protected ได้
- การจะทำให้คลาส B สมารถเรียกใช้งานแอตทริบิวต์ a2 ของคลาส A ได้ต้องทำเช่นใด สามารถทำได้ 2 วิธี คือ วิธีแรก กำหนดคลาส B ให้อยู่ในแพ็กเกจเดียวกันกับคลาส A ดังนี้

Package test.classB; Import test.classA.A; public class B extends A { //code program }

เนื่องจากคลาส A และคลาส B อยู่ต่างแพ็กเกจกัน ดังนั้นการที่คลาส B จะเรียกใช้งานแอตทริบิวต์ a2 ของคลาส A ได้ จำเป็นต้องระบุคำสั่งอิมพอร์ต คือ import test.classA.A; ไว้ในโปรแกรมด้วย

- คลาส B สามารถเรียกใช้งานแอตทริบิวต์ a3 ของคลาส A ได้หรือไม่ เพราะเหตุใดไม่ได้เนื่องจากคลาส B อยู่ในแพ็กเกจ test.classB ส่วนคลาส A อยู่ในแพ็กเกจ test.classA ซึ่งเป็นคนละแพ็กเกจกัน ดังนั้นคลาส B จึงไม่สามารถเรียกใช้งานแอตทริบิวต์ a3 ซึ่งมี modifier เป็น package ได้

- การจะทำให้คลาส B สามารถเรียกใช้งานแอตทริบิวต์ a3 ของคลาส A ได้ต้องทำเช่นใด เนื่องจากแอตทริบิวต์ a3 มี modifier เป็น package จึงทำให้คลาสที่อยู่ต่างแพ็กเกจกันกับคลาส A ไม่สามารถเข้าใช้งานตัวแปร a3 ได้ ดังนั้น การที่คลาส B จะเรียกใช้งานแอตทริบิวต์ a3 ของคลาส A ได้นั้น จึงจำเป็นต้องกำหนดคลาส B ให้อยู่ในแพ็กเกจเดียวดันกับคลาส A ดังนี้

Package test.classA; public class B { //code program }

- คลาส B สามารถเรียกใช้งานแอตทริบิวต์ a4 ของคลาส A ได้หรือไม่ เพราะเหตุใดไม่ได้ เนื่องจากแอตทริบิวต์ a4 มี modifier เป็น private ซึ่งหมายถึง ความเป็นส่วนตัว เป็นการปิดกั้นไม่ให้คลาสอื่นเข้ามาใช้งานได้ ดังนั้น จึงมีแต่เฉพาะคลาส A เท่านั้นที่มีสิทธิ์ใช้งานแอตทริบิวต์ a4 ได้

- การจะทำให้คลาส B สามารถเรียกใช้งานแอตทริบิวต์ a4 ของคลาส A ได้ต้องทำเช่นใดไม่มีวิธีใดที่จะทำให้คลาส B สามารถเรียกใช้งานแอตทริบิวต์ a4 ของคลาส A ได้โดยตรง เพราะแอตทริบิวต์ a4 ถูกหุ้มห่อไว้ภายในคลาส A ซึ่งวิธีที่คลาสอื่นจะเรียกใช้งานแอตทริบิวต์ที่ถูกหุ้มห่อไว้ภายในคลาสหนึ่งๆเป็นอย่างไรนั้น เราจะได้ศึกษากันต่อไป แต่ขอให้จำไว้เสมอว่าคลาสอื่นจะไม่สามารถเรียกใช้งานแอตทริบิวต์ที่ถูกหุ้มห่อไว้ภายในคลาสหนึ่งได้โดยตรง

ก่อนที่จะกล่าวถึงออบเจ็คในหัวข้อถัดไป เราจะมาศึกษากันถึงเรื่องของการประกาศคลาสขึ้นใช้งานก่อน เพื่อสร้างโครงสร้างต้นแบบของออบเจ็คขึ้นมา

การประกาศคลาส
รูปแบบการประกาศคลาส คือ

กฎและข้อแนะนำสำหรับการตั้งชื่อคลาส
- การตั้งชื่อคลาสเป็นไปตามกฎการตั้งชื่อของภาษาจาวา แต่นิยมขึ้นต้นด้วยตัวอักษรตัวใหญ่
- หากชื่อคลาสประกอบด้วยคำมากกว่า 1 คำ โดยทั่วไปกำหนดให้ตัวอักษรแรกของแต่ละคำเป็นตัวใหญ่
- ชื่อคลาสควรเป็นคำนาม

ตัวอย่างการตั้งชื่อคลาสที่ถูกต้อง (และเป็นไปตามความนิยม) เช่น Employee, Televisiom, Motocycle, MobilePhone_, MobilePhone$ เป็นต้น

ตัวอย่างการประกาศคลาส

Public class Employee { }

เป็นการประกาศชื่อคลาส Employee ขึ้น โดยกำหนด modifier เป็น public นั่นหมายถึง คลาสอื่นทุกคลาสสามารถมองเห็นและเรียกใช้งานคลาส Employee นี้ได้

ตัวอย่างนี้เป็นเพียงการประกาศคลาสขึ้นเท่านั้น ยังไม่มีส่วนของการประกาศแอตทริบิวต์ (attribute deciaration) และส่วนของการประกาศเมธอด (method declaration)

การประกาศคลาสดังกล่าวข้างต้น สามารถแทนด้วย UML Class Diagram ได้ดังนี้

NOTE : UML (Unified Modeling Language) คือ ภาษาที่ใช้แผนภาพเป็นสื่อในการวิเคราะห์และออกแบบระบบงาน

การประกาศแอตทริบิวต์
รูปแบบการประกาศแอตทริบิวต์ คือ

[modifier] ชนิดข้อมูล ชื่อแอตทริบิวต์ คือ

กฎและข้อแนะนำสำหรับการตั้งชื่อแอตทริบิวต์

- การตั้งชื่อแอตทริบิวต์เป็นไปตามกฎการตั้งชื่อของภาษาจาวา แต่นิยมขึ้นต้นด้วยตัวอักษรตัวเล็ก
- หากชื่อแอตทริบิวต์ประกอบด้วยคำมากกว่า 1 คำ โดยทั่วไปนิยมกำหนดให้ตัวอักษรตัวแรกของแต่ละคำ (ยกเว้นคำแรก) เป็นตัวใหญ่
- ชื่อแอตทริบิวต์ควรนเป็นคำนาม

ตัวอย่างการตั้งชื่อแอตทริบิวต์ที่ถูกต้อง (และเป็นไปตามความนิยม) เช่น employeeId, empName, position, department, salary, salary$ เป็นต้น

ตัวอย่างการประกาศแอตทริบิวต์
การประกาศแอตทริบิวต์ต้องประกาศไว้ในคลาส ซึ่งจากหัวข้อที่แล้วเราได้สร้างคลาส Employee ไว้แล้ว ดังนั้นเราลองมาประกาศแอตทริบิวต์สำหรับคลาส Employee

public class Employee { public int empId; private double salary; public String timeIn; public String timeOut; }

คือทำการประกาศแอตทริบิวต์รหัสพนักงาน (empId), เงินเดือน (salary), เวลาเข้างาน (timeIn) และเวลาออกงาน (timeOut) ให้กับคลาส Employee ซึ่งสามารถแทนด้วย UML Class Diagram ได้ดังนี้

รูปที่ 2 แสดง UML Class Diagram ของคลาส Employee ที่ประกอบด้วยแอตทริบิวต์

NOTE : UML ได้กำหนดหลักการเขียน Diagram ในส่วนของแอตทริบิวต์ไว้ดังนี้ - ถ้าแอตทริบิวต์มี modifier เป็น public ให้ระบุเครื่องหมาย + ไว้หน้าแอตทริบิวต์นั้น - ถ้าแอตทริบิวต์มี modifier เป็น private ให้ระบุเครื่องหมาย – ไว้หน้าแอตทริบิวต์นั้น - ถ้าแอตทริบิวต์มี modifier เป็น protected ให้ระบุเครื่องหมาย # ไว้ข้างหน้าแตทริบิวต์นั้น

การประกาศเมธอด
รูปแบบการประกาศเมธอด คือ

กฎและข้อเสนอแนะสำหรับการตั้งชื่อเมธอด
การตั้งชื่อเมธอดมีกฎเกณฑ์และข้อแนะนำเหมือนกับการตั้งชื่อแอตทริบิวต์ทุกประการ ยกเว้นว่าชื่อของเมธอดที่ตั้งขึ้นควรกำหนดให้เป็นคำกริยา แทนที่จะเป็นคำนาม

ตัวอย่างการตั้งชื่อเมธอดที่ถูกต้อง (และเป็นไปตามความนิยม) เช่น switchOffMobile, getTime, setRingtone เป็นต้น

ตัวอย่างการประกาศเมธอด
การประกาศเมธอดต้องประกาศไว้ภายใต้คลาสเช่นเดียวกับการประกาศแอตทริบิวต์ ดังนั้น จากคลาส Employee ในหัวข้อที่แล้ว เราจะลองมาเพิ่มการประกาศเมธอดให้กับคลาสนี้กันดู

คือ ทำการประกาศเมธอดขึ้น 3 เมธอด ดังนี้
* public void setTimeIn (String time) รับค่าพารามิเตอร์ time ซึ่งมีชนิดข้อมูลเป็น String เข้ามา แล้วนำค่าของ time ไปกำหนดให้กับตัวแปร timeIn ภายในคลาส เพื่อเซ็ตค่าเวลาเข้างาน โดยเมธอดนี้จะไม่คืนค่าใดๆออกไปจากเมธอด (สังเกตว่าระบุชนิดข้อมูลที่ต้องการส่งกลับออกไปเป็น void)
* public void setTimeOut (String time) เมธอดนี้มีหลักการทำงานเหมือนกับเมธอด setTimeIn เพียงแต่เมธอดนี้เป็นการเซ็ตค่าเวลาออกงาน ไม่ใช่เวลาเข้างาน
* private double getSalary (int empId) เมธอดนี้จะรับค่ารหัสพนักงาน คือ empId เข้ามา แล้วทำการตรวจสอบว่าพนักงานที่มีรหัสพนักงานนั้นๆมีเงินเดือนเป็นเท่าใด

จากนั้นจะคืนค่าเงินเดือน (salary) เป็นเลขจำนวนจริง double กลับออกไปจากเมธอด จากการประกาศเมธอดทั้ง 3 เมธอดข้างต้นสามารถเขียน UML Class Diagram ของคลาส Employee ได้ดังนี้

รูปที่ 3 แสดง UML Class Diagram ของตลาส Employce ที่ประกอบด้วยแอตทริบิวต์และเมธอด

NOTE : UML ได้กำหนดหลักการเขียน Diagram ในส่วนของเมธอดไว้ดังนี้ * ถ้าเมธอดมี modifier เป็น public ให้ระบุเครื่องหมาย + ไว้ที่หน้าเมธอดนั้น * ถ้าเมธอดมี modifier เป็น private ให้ระบุเครื่องหมาย – ไว้ที่หน้าเมธอดนั้น * ถ้าเมธอดมี modifier เป็น protected ให้ระบุเครื่องหมาย # ไว้ที่หน้าเมธอดนั้น

จากหัวข้อที่แล้วเราได้คลาสของพนักงานที่ประกอบด้วยแอตทริบิวต์และเมธอดที่พร้อมใช้งานได้แล้ว แต่ ณ ตอนนี้ยังใช้งานไม่ได้เพราะคลาสเป็นเพียงโครงสร้างว่างเปล่าเท่านั้น การที่จะทำให้คลาสใช้งานได้จริงต้องทำอย่างไร

การประกาศตัวแปรออบเจ็ค (Object Declaration)

ตัวแปรออบเจ็ค (Object Variable) หมายถึงตัวแปรที่ใช้อ้างอิงออบเจ็คที่จะสร้างขึ้นการประกาศตัวแปรออบเจ็คมีรูปแบบดังนี้

ชื่อคลาส ชื่อตัวแปรออบเจ็ค;

ตัวอย่างการประกาศตัวแปรออบเจ็ค
* การประกาศตัวแปรออบเจ็คเพียงตัวตัวแปรเดียว เช่น

Emplyee employee

การประกาศตัวแปรออบเจ็คเพียงตัวแปรเดียว เช่น

Emplyee somsri, somsak, somchai

การสร้างออบเจ็ค (Object Creation)

ออบเจ็คที่สร้างขึ้นจากคลาส บางครั้งเรียกว่า “ instance ของคลาส” ซึ่งเราสามารถสร้างออบเจ็คบนจากคลาสหนึ่งๆได้มากกว่า 1 ออบเจ็ค การสร้างออบเจ็คของคลาส (เรียกได้อีกอย่างว่าการ Instanuare คลาส) สามารถทำได้โดยใช้คีย์เวิร์ด new รูปแบบการสร้างออบเจ็ค คือ

new ชื่อคลาส (อาร์กิวเมนต์);

ตัวอย่างการสร้างออบเจ็ค
เราสามารถสร้างออบเจ็คของคลาส Employee ได้ดังนี้

new Employee ( );

จากหัวข้อที่แล้วเราได้ประกาศตัวแปรออบเจ็คขึ้นแล้ว สามารถนำเอาตัวแปรออบเจ็คที่ประกาศขึ้นอ้างอิงมายังออบเจ็คของคลาส Employee ที่สร้างขึ้นได้ดังนี้

employee = new Employee( );

ในการสร้างออบเจ็คของคลาส Employee หลายๆออบเจ็ค เราสามารถใช้ตัวแปรออบเจ็คเดิมอ้างอิงมายังออบเจ็คที่สร้างขึ้นได้ เช่น

1. คำสั่ง somsri = new Employee( ); ทำการสร้างออบเจ็คของคลาส Employee ขึ้น และใช้ตัวแปรออบเจ็ค somsri ที่ประกาศขึ้นอ้างอิงมายังออบเจ็คนี้

2. ทำคำสั่ง somsri = new Employee ( ); อีกครั้งคำสั่งนี้จะสร้างออบเจ็คของคลาส Employee ขึ้นใหม่อีกออบ เจ็คหนึ่ง และใช้ตัวแปรออบเจ็ค somsri ตัวเดิมอ้างอิงมายังออบเจ็คใหม่นี้ ซึ่งมีผลให้ออบเจ็คเดิม (ที่สร้างจาก คลาส Employee) ไม่ถูกใช้งานอีกต่อไป และกลายเป็น "ขยะ" (garbage) ค้างอยู่ในหน่วยความจำ ดังนั้น garbage collection หรือ "ตัวกำจัดขยะ" จึงทำการเคลียร์พื้นที่นี้ให้เป็นพื้นที่ว่าง (คืนหน่วยความจำส่วนนี้ ให้กับระบบ) เพื่อจะได้นำพื้นที่นี้กลับมาใช้งานใหม่ได้

ตัวอย่างที่ 2 แสดงการสร้างออบเจ็ค โดยไม่มีการประกาศตัวแปรออบเจ็คขึ้นมาอ้างอิง ออบเจ็คที่ได้ สร้างขึ้นนั้น

*ไฟล์ TestCreateObject.java

วิธีคอมไพล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม

บรรทัดที่ 6 เป็นการสร้างออบเจ็คของคลาส TestCreateObject ขึ้นด้วยคีย์เวิร์ด new โดยหลังจากสร้าง ออบเจ็คขึ้นแล้วเรียกเมธอด getValue ให้ทำงานด้วย (สังเกตว่าไม่มีการประกาศตัวแปร ออบเจ็คแต่สร้างออบเจ็คขึ้นพร้อมกับเรียกใช้งานเมธอด getValue ของออบเจ็คที่ได้สร้าง ขึ้นมา)

จะเห็นว่าโปรแกรมได้คอมเมนต์บรรทัดที่ 7-8 เอาไว้ ซึ่งบรรทัดที่ 7 เป็นการประกาศตัวแปรออบเจ็ค t ขึ้นเพื่อใช้อ้างอิงออบเจ็คของคลาส TestCreateObject ที่สร้างขึ้น ส่วนบรรทัดที่ 8 เป็นการเรียกเมธอด getValue ในออบเจ็คนั้นให้ทำงาน ตรงนี้ให้ทดลองนำคอมเมนต์บรรทัดที่ 7 และ 8 ออก และใส่คอมเมนต์ในบรรทัดที่ 6 แทน จะเห็นว่ายังคงได้ผลลัพธ์เหมือนเดิมทุกประการ (เหมือนการทำงานของบรรทัดที่ 6) ตรงนี้คงแล้วแต่ผู้เขียนโปรแกรมว่าจะเลือกใช้งานวิธีใด (วิธีแรกเขียนโค้ดน้อยกว่า กระชับกว่า แต่ก็เข้าใจยากกว่าส่วนวิธีหลังเขียนโค้ดมากกว่า แต่เข้าใจง่ายกว่า เพราะโค้ดสื่อความหมายได้ดีกว่า นอกจากนั้นยังสามารถทำงานอื่นๆกับออบเจ็คได้อีก เพียงแค่ระบุถึงตัวแปรออบเจ็ค t ที่ใช้อ้างอิงไปยังออบเจ็คนั้น)

เปรียบเทียบการกำหนดค่าให้กับตัวแปร และการกำหนดค่าให้กับตัวแปรออบเจ็ค

การกำหนดค่าให้กับตัวแปร

int a, int b; a = 1; b = a;

ตัวอย่างนี้กำหนดค่าเลขจำนวนเต็ม 1 ให้กับตัวแปร a จากนั้นกำหนดค่าของตัวแปร a ให้กับตัวแปร b ดังนั้นตัวแปร 6 จึงมีค่าเป็น 1 ด้วยสรุปแล้วการกำหนดค่าให้กับตัวแปรคือการกำหนดค่าข้อมูลที่แท้จริงให้กับตัวแปรตรงๆนั่นเอง

การกำหนดค่าให้กับตัวแปรออบเจ็ค

Employee Somsri, Somsak; somsri = new Employee ( ); somsak = somsri;

บรรทัด somsri = new Employee( ); เป็นการสร้างออบเจ็คของคลาส Employee ขึ้น และใช้ตัวแปรออบเจ็ค somsri ที่ประกาศขึ้นอ้างอิงมายังออบเจ็คนี้

ส่วน somsak = somsri; เป็นการระบุให้ตัวแปรออบเจ็ค somsak ชี้อ้างอิงไปยังออบเจ็คเดียวกันกับที่ตัวแปรออบเจ็ค somsri ชี้อยู่ คือชี้ไปยังออบเจ็คของคลาส Employee ที่สร้างขึ้นจากบรรทัดก่อนหน้านั่นเอง

จะเห็นว่าการกำหนดค่าให้กับตัวแปรออบเจ็คต่างจากการกำหนดค่าให้กับตัวแปร คือ การกำหนดค่าให้กับตัวแปรออบเจ็คอย่างเช่น somsak = Somsri; นั้นไม่ได้เป็นการกำหนดค่าข้อมูลที่แท้จริงให้กับตัวแปรออบเจ็คแต่เป็นการกำหนดค่าอ้างอิง (reference) ให้กับตัวแปรออบเจ็ค เพื่อระบุว่าต้องการให้ตัวแปรออบเจ็คชี้ไปที่ออบเจ็คใด

การทำงานกับแอตทริบิวต์
แอตทริบิวต์เป็นสมาชิก (member) ของคลาส การทำงานกับแอตทริบิวต์ผ่านตัวแปรออบเจ็คที่อ้างอิงออบเจ็คของคลาสนั้นๆอยู่เป็นดังนี้

รูปแบบการทำงานกับแอตทริบิวต์ คือ

ชื่อตัวแปรออบเจ็ค.ชื่อแอตทริบิวต์

รูปแบบการกำหนดค่าให้กับแอตทริบิวต์ คือ

ชื่อตัวแปรออบเจ็ค.ชื่อแอตทริบิวต์ = ค่าที่ต้องการกำหนดให้;

ตัวอย่างเช่น

employee.empId = 2264; employee.salary = 20000; employee.timeIn = “08.30”; employee.time0ut= “17.30”;

ตัวอย่างที่ 3 โปรแกรมแสดงการกำหนดค่าให้กับแอตทริบิวต์ต่างๆของออบเจ็คหนึ่งๆ

*ไฟล์ Employee.java

วิธีคอมไพล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม

บรรทัดที่ 2-5 ประกาศแอตทริบิวต์ขึ้น 4 ตัว ได้แก่ empId, salary, timeIn, time0ut
บรรทัดที่ 8 สร้างออบเจ็คของคลาส Employee ขึ้น และพร้อมกันนั้นก็ประกาศตัวแปรออบเจ็ค ชื่อ employee เพื่อใช้อ้างอิงออบเจ็คของคลาส Employee ที่สร้างขึ้นด้วย ดังรูป

บรรทัดที่ 9-12 กำหนดค่าให้กับแอตทริบิวต์แต่ละตัวในออบเจ็คที่สร้างขึ้น โดยใช้ค่าที่เหมาะสมกับชนิด ข้อมูลของแอตทริบิวต์นั้นๆ
บรรทัดที่ 14-18 ทดลองพิมพ์ค่าของแต่ละแอตทริบิวต์ออกทางจอภาพ เพื่อตรวจสอบดูค่าของแอตทริบิวต์ ที่ได้ทำการกำหนดไปในบรรทัดที่ 9-12

การทำงานกับเมธอด
เมธอดก็เป็นสมาชิกของคลาสเช่นเดียวกับแอตทริบิวต์ การทำงานกับเมธอดผ่านตัวแปรออบเจ็คที่อ้างอิงออบเจ็คของคลาสนั้นๆอยู่ เป็นดังนี้

รูปแบบการทำงานกับเมธอด คือ

ชื่อตัวแปรออบเจ็คชื่อเมธอด (อาร์กิวเมนต์)

ตัวอย่างการทํางานกับเมธอด

employee. setTimeIn ("08. 20"); employee. setTimeOut ("18. 00"); employee. getSalary (2264);

การส่งพารามิเตอร์ไปยังเมธอดจะเป็นการส่งแบบ by value (ส่งโดยค่า) เสมอ โดย
* ถ้าพารามิเตอร์ที่ส่งให้เมธอด คือ ตัวแปรที่มีชนิดข้อมูลเป็นชนิดข้อมูลพื้นฐาน (primitive data type) แล้ว เมธอดจะไม่สามารถเปลี่ยนแปลงค่าของพารามิเตอร์นั้นได้
* ถ้าพารามิเตอร์ที่ส่งให้เมธอด คือ ตัวแปรออบเจ็คซึ่งเก็บค่าอ้างอิง (reference) ไปยังออบเจ็คหนึ่งๆ ไว้เมธอดจะไม่สามารถเปลี่ยนแปลงให้ตัวแปรออบเจ็คชี้อ้างอิงไปยังออบเจ็คอื่นได้แต่สามารถ เปลี่ยนแปลงค่าแอตทริบิวต์ของออบเจ็คนั้นได้

ตัวอย่างที่ 4 โปรแกรมแสดงการทำงานของเมธอด

*ไฟล์ Employee2.java

วิธีคอมไพล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม

บรรทัดที่ 7-9 เมธอด setTimeIn รับค่าพารามิเตอร์ time ซึ่งเป็นข้อมูลชนิด String เข้ามา เพื่อเซ็ตค่าเวลา เข้างานให้กับตัวแปร timeIn
บรรทัดที่ 10-12 เมธอด setTimeOut รับค่าพารามิเตอร์ time ซึ่งเป็นข้อมูลชนิด String เข้ามาเพื่อ เซ็ตค่าเวลา ออกงานให้กับตัวแปร timeOut
บรรทัดที่ 13-17 เมธอด getSalary รับค่าพารามิเตอร์ empId ซึ่งเป็นข้อมูลชนิด int เข้ามาเพื่อนำค่าของ empId มาทำการตรวจสอบว่าพนักงานที่มีรหัสพนักงานนั้นๆมีเงินเดือนเป็นเท่าไร โดยจะ พบว่าถ้ารหัสพนักงานเป็น 2264 พนักงานคนนั้นจะมีเงินเดือน 30000 บาท แต่ถ้าเป็นรหัส พนักงานอื่นๆที่ไม่ใช่ 2264 จะมีเงินเดือน 20000 บาท จากนั้นใช้คำสั่ง return Salary เพื่อ คืนค่าเงินเดือนเป็นข้อมูลเลขจำนวนจริง double กลับออกไปจากเมธอดสังเกตว่าค่าของ เงินเดือนที่ได้จากเมธอต getSalary เป็น 30000. 0 ไม่ใช่ 30000 นั้น เพราะค่าที่ return ออกมาถูกกำหนดไว้เป็นเลขจํานวนจริง double นั้นเอง
บรรทัดที่ 20 กำหนดค่า 2264 ให้กับแอตทริบิวต์ empId ของออบเจ็คที่สร้างขึ้น
บรรทัดที่ 22 เรียกใช้งานเมธอด setTime In โดยส่งพารามิเตอร์เป็นค่าสตริง 08. 20 เข้าไปยังเมธอดนี้ เพื่อเซ็ตเวลาเข้างาน
บรรทัดที่ 24 เรียกใช้งานเมธอด getSalary โดยส่งพารามิเตอร์เป็นเลขจำนวนเต็ม int คือ employee empId (ซึ่งมีค่าเท่ากับ 2264) เข้าไปยังเมธอด เพื่อตรวจสอบเงินเดือนของพนักงานตาม รหัสพนักงานที่ระบุ

*ไฟล์ Data.java

อธิบายโปรแกรม

บรรทัดที่ 4-6 นี่คือคอนสตรัคเตอร์ ซึ่งคอนสตรัคเตอร์จะมีชื่อเหมือนกับชื่อคลาสเสมอ คอนสตรัคเตอร์ เป็นส่วนที่จำเป็นสำหรับการกำหนดค่าเริ่มต้นให้กับแอตทริบิวต์ต่างๆของออบเจ็ค โดยใน ที่นี้เป็นการกำหนดค่าให้กับแอตทริบิวต์ myNumber รายละเอียดของคอนสตรัคเตอร์ จะกล่าวถึงอีกครั้งในบทที่ 9

*ไฟล์ TestParameter.java

อธิบายโปรแกรม
บรรทัดที่ 15 ตัวแปร num มีชนิดข้อมูลเป็น primitive data type คือ มีชนิดข้อมูลเป็นชนิดข้อมูล พื้นฐานประเภท int
บรรทัดที่ 16 คำสั่ง new Data(100); จะทำให้คอนสตรัคเตอร์ Data ในบรรทัดที่ 4-6 เข้าไฟล์ Data. Java ทำงานโดยคอนสตรัคเตอร์นี้นำตัวแปร number มารับค่า 100 กำหนดค่า 100 ที่ให้แอตทริบิวต์ my number ดังนั้นจึงทำให้แอตทริบิวต์ my number มีค่าเป็น 100
บรรทัดที่ 21 เรียกใช้งานเมธอด changePrimitive โดยส่งค่าของตัวแปร num ซึ่งมีค่าเท่ากับ 2547 ไปยังเมธอด changePrimitive และเมธอด changePrimitive ก็นำเอาตัวแปรnum2 มารับค่า 2547 นี้ ซึ่งแม้ว่าในบรรทัดที่ 4 เมธอด changePrimitive จะกำหนด num2 = 10; ไว้ก็ตาม ก็จะไม่ทำให้ค่าของตัวแปร num2 เปลี่ยนจาก 2547 ไปเป็น 10
บรรทัดที่ 25 สั่งพิมพ์ค่าแอตทริบิวต์ My number ของออบ เจ็ค Data ซึ่งจากบรรทัดที่ 16 ค่าแอตทริบิวต์ my number มีค่าเท่ากับ 100
บรรทัดที่ 27 เรียกใช้งานเมธอด ChangeObjectRef โดยส่งค่าตัวแปรออบเจ็ค Data เป็นพารามิเตอร์ไปยังเมธอดด้วย ซึ่งการทำงานของเมธอดนี้คำสั่ง New Data(20); จะไม่ส่งผลให้ตัวแปรออบเจ็ค Data ชี้ไปที่ออบเจ็คใหม่ ดังนั้นเมื่อสั่งพิมพ์ค่าแอตทริบิวต์ Number ค่าของแอตทริบิวต์จึงมีค่าเป็น 100 เช่นเดิมรู้จักตัวแปรอออบเจ็ค Data ยังคงชี้อยู่ที่ออบเจ็คเดิมนั่นเอง

วิธีคอมไฟล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

ในการคอมไพล์โปรแกรมให้สั่งคอมไฟล์โปรแกรม TestParameter.java สายเดียวก็เพียงพอทั้งนี้เนื่องจากคลาส TestParameter มีการเรียกใช้งานคลาส Data ดังนั้น เมื่อจากคอมไพล์คลาส TestParameter แล้ว ก็จะทำให้คลาส Data ถูกคอมไพล์ไปด้วย จากนั้นก็สั่งงานโปรแกรม

* Accessor Method คือ เมธอดที่ใช้สำหรับดึงค่าแอตทริบิวต์ของออบเจ็ค และส่งค่าแอตทริบิวต์ที่ได้คืนกลับออกไปจากเมธอด
* Mutator Method คือ เมธอดที่ใช้สำหรับเปลี่ยนแปลงแก้ไขแอตทริบิวต์ของออบเจ็ค
การตั้งชื่อ Accessor Method นั้น ชื่อของเมธอดจะขึ้นต้นด้วย คำว่า “ get ” และตามด้วยชื่อของแอตทริบิวต์เสมอ ( ชื่อแอตทริบิวต์ที่ตามหลัก get จะต้องขึ้นต้นด้วยตัวอักษรตัวใหญ่ )เช่น ถ้าแอตทริบิวต์ชื่อ name แล้ว Accessor Method จะเชื่อว่า getname ถ้าแอตทริบิวต์ชื่อ age แล้ว Accessor Methodก็จะชื่อว่า getAge เป็นต้น

การตั้งชื่อ Mutator Method นั้น ชื่อของเมธอดจะขึ้นต้นด้วย คำว่า “set” และตามด้วยชื่อของแอตทริบิวต์เสมอ (ชื่อแอตทริบิวต์ที่ตามหลัก set จะต้องขึ้นต้นด้วยตัวอักษรตัวใหญ่)เช่น ถ้าแอตทริบิวต์ชื่อ name แล้ว Mutator Method จะเชื่อว่า setname ถ้าแอตทริบิวต์ชื่อ age แล้ว Mutator Method ก็จะชื่อว่า getAge เป็นต้น

รูปแบบของ Accessor Method คือ

เช่นสมมุติว่าแอตทริบิวต์ชื่อ name จะประกาศ Accessor Method ได้ดังนี้

Accessor Method นี้จะดึงค่าแอตทริบิวต์ name (มีชนิดข้อมูลเป็น String) ของออบเจ็คออกมาและส่งคืนแอตทริบิวต์นี้กลับออกไปจาเมธอด

เช่น สมมติว่าแอตทริบิวต์ชื่อ name จะประกาศ Mutator Method ได้ดังนี้

Mutator Method จะนำตัวแปรชื่อ name ซึ่งมีชนิดข้อมูลเป็น Staring มารับค่าพารามิเตอร์ที่ส่งเข้ามาในเมธอด และดำเนินการเปลี่ยนแปลงแก้ไขค่าของแอตทริบิวต์ name ให้มีค่าเท่ากับค่าของพารามิเตอร์ที่รับเข้ามา

ตัวอย่างที่ 6 โปรแกรมแสดงการทำงานของ Accessor Method และ Mutator Method

*ไฟล์ Banner.java

อธิบายโปรแกรม

โปรแกรมนี้เป็นโปรแกรมสำหรับเช็คค่าของข้อความที่ใช้โฆษณาประชาสัมพันธ์ ซึ่งโดยปกติข้อความที่ใช้โฆษณานั้นจะต้องถูกเปลี่ยนแปลงแก้ไขโดยผู้มีสิทธิ์แก้ไขเท่านั้น ไม่เช่นนั้นอาจก่อให้เกิดความเสียหายต่อการโฆษณาได้ ดังนั้น

• คลาส Banner เช่นกำหนดให้แอตทริบิวต์ text มี modify เป็น private เนื่องจากแอตทริบิวต์นี้ใช้สำหรับเก็บข้อความโฆษณาประชาสัมพันธ์คลาสจะได้ไม่มีสิทธิ์เข้ามาเปลี่ยนแปลงแก้ไขข้อความแอตทริบิวต์ text

• คลาส Banner เตรียม Accessor Method และ Mutator Method ไว้ให้คลาสอืดเรียกใช้เพื่อเข้าถึงแอตทริบิวต์ text

บรรทัดที่ 2 ประกาศแอตทริบิวต์ text เป็นชนิดข้อมูล String กำหนด modify เป็น private เพื่อทำ Information hiding โดยแอตทริบิวต์นี้จะเก็บข้อความ 1-9 NOV 2009 : Commart at Impact Arina เพื่อใช้สำหรับโฆษณาประชาสัมพันธ์
บรรทัดที่ 4-6 Public void setText (Staring text) เป็นการประกาศ Mutator Method ชื่อ setText โดยรับพารามิเตอร์ text เข้ามาในเมธอดด้วย โดย this.text = text; นั้นthis.text หมายถึงค่าแอตทริบิวต์ text ของคลาส banner ซึ่งปัจจุบันมีค่าเป็น 1-9 NOV 2009 : Commart at Impact Arina และ Text หมายถึง ค่าพารามิเตอร์ text ที่รับเข้ามาในเมธอด ดังนั้นประโยคthis.text = text; จึงหมายถึง การนำค่าพารามิเตอร์ text ที่รับเข้ามาในเมธอด มาเซ็ตให้กับค่าของแอตทริบิวต์ text ของคลาส banner นี้
บรรทัดที่ 8-10 คือAccessor Method ชื่อ getText โดย บรรทัดที่ 9 คำสั่ง return this.text; หมายถึงการคือค่าแอตทริบิวต์ text ของคลาส Banner ซึ่งมีชนิดข้อมูลเป็น String กลับออกไปจากเมธอด โดยในที่นี้จะคืนค่า 1-9 NOV 2009 : Commart Arina ออกไปจากเมธอดนั่นเอง

*ไฟล์ Advertisement.java

วิธีคอมไฟล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม

บรรทัดที่ 6 เรียกเมธอด getText เพื่อเป็นค่าของแอตทริบิวต์ text ออกมา ในที่นี้จะได้ค่าออกมาเป็น 1-9 NOV 2009 : Commart at Impact Arina โดยค่าที่ได้จะถูกเก็บไว้ที่ตัวแปร adverText
บรรทัดที่ 8 เรียกเมธอด setText เพื่อเป็นค่าของแอตทริบิวต์ text จากเดิม คือ 1-9 NOV 2009 : Commart at Impact Arina ไปเป็นค่า 1-9 NOV 2009 : Commart at Queen Sirikit Nationalconvention Center

จากตัวอย่าง ผู้อ่านอาจเกิดข้อสงสัยว่าแม้ว่าจะกำหนด modifier เป็น private ให้กับแอตทริบิวต์เพื่อทำ information hiding ไม่ให้คลาสอื่นสามารถเปลี่ยนแปลงค่าของแอตทริบิวต์ได้โดยตรงก็ตามแต่Mutator Methodก็ช่วยให้คนอื่นสามารถเปลี่ยนแปลงค่าของแอตทริบิวต์ได้อยู่ดีแล้วอย่างนี้จะต่างอะไรกับการที่เรากำหนด Modify เป็น Public ให้กับแอตทริบิวต์เพราะเหตุอื่นก็สามารถเปลี่ยนแปลงค่าของแอตทริบิวต์ได้เช่นกันลองพิจารณาตัวอย่างดังต่อไปนี้

ตัวอย่างที่ 7 โปรแกรมแสดงการเซ็ตค่าโปรโมชั่นไอศกรีม (ไม่ใช้หลักการของ Information hiding คือ กำหนด modifier เป็น public ให้กับแอตทริบิวต์

*ไฟล์ PromotionPublic.java

อธิบายโปรแกรม

บรรทัดที่ 1 ทำการอิมพอร์ดคลาส calendar ซึ่งเก็บอยู่ในแพ็กเกจ java.util เข้ามาในโปรแกรม
บรรทัดที่ 4 เมธอด getInstance จะดึงค่าวันเวลาในปัจจุบันออกมา
บรรทัดที่ 5 cal .get( Cal.get(Calendar.MONTH ) +1 ; จะดึงเฉพาะค่าของเดือนปัจจุบันออกมา และกำหนดเป็นค่าเริ่มต้นให้กับแอตทริบิวต์ month โดยมี modifier เป็น public ดังนั้น คลาสอื่นจึงสามารถเปลี่ยนแปลงแก้ไข้ค่าของแอตทริบิวต์นี้ได้โดยตรง
บรรทัดที่ 6 อากาศแอตทริบิวต์ promotion ให้มีชนิดข้อมูลเป็น String และกำหนดค่าเริ่มต้นให้เป็น buy1Scoop,free 1 Scoop โดยในที่นี้กำหนดให้แอตทริบิวต์ที่มี Modify เป็น Public ดังนั้นคลาสอื่นจึงสามารถเปลี่ยนแปลงแก้ไขค่าของแอตทริบิวต์นี้ได้โดยตรงเช่นเดียวกับแอตทริบิวต์ mouth
บรรทัดที่ 8-24 เมธอด mouthString จะรับค่าพารามิเตอร์ผ่านทางตัวแปร mouthNumber เข้ามาในเมธอดเพื่อเปลี่ยนแปลงค่าของเดือนจากตัวเลขเป็นตัวอักษรเช่นถ้าเป็นเดือน 1 ก็จะคืนค่า january ออกไปจากไปเมธอดเป็นต้น

*ไฟล์ IceCresmPromotionPublic.java

วิธีคอมไฟล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม

บรรทัดที่ 6 ประกาศตัวแปรออบเจ็ค promotionPublic พร้อมกับซ่าออบเจ็คของคลาส promotionPublicขึ้น และใช้ตัวแปรออบเจ็ค promotionPublic อ้างอิงไปยังออบเจ็คที่สร้างขึ้นนั้น
บรรทัดที่ 8 กำหนดค่าตัวแปร mymouth โดยค่าของแอตทริบิวต์ month
บรรทัดที่ 9 บรรทัดนี้มีการเรียกใช้งานเมธอด monthString เพื่อส่งคืนค่าของเดือนออกทางจอภาพเลยส่งค่าพารามิเตอร์เป็น mymonth ไปยังเมธอดด้วย ซึ่งเมธอดก็จะเป็นค่าของเดือนจากตัวเลขเป็นชื่อเดือน เช่น สมมุติว่าปัจจุบันเป็นเดือน 11 เมธอดก็จะคืนค่าเป็น Number กลับมาให้ ดังนั้นบรรทัดนี้จึงพิมพ์ข้อความ promotion in this month [ November ] ออกทางจอภาพ
บรรทัดที่ 10 สั่งสินค้าแอตทริบิวต์ promotion ออกทางจอภาพซึ่งขณะนี้ค่าของแอตทริบิวต์promotionมีค่าเป็น buy 1 Scoop , free 1 Scoop
บรรทัดที่ 12 นำค่า 13 มาเช็คให้กับแอตทริบิวต์ month บรรทัดที่
13 กำหนดค่าให้ตัวแปร mymonth ด้วยค่าของแอตทริบิวต์ month ดังนั้นขณะนี้ตัวแปร mymonth จะมีค่าเป็น 13
บรรทัดที่ 14 กำหนดค่า Buy 1 cup of Banana Split , Free Ice Tea ให้กับแอตทริบิวต์promotion
บรรทัดที่ 16-17 สั่งพิมพ์ค่าของเดือนและโปรโมชั่นออกทางจอภาพ

สาเหตุโปรแกรมแสดงผลออกมาเป็น promotion This is my month [ERROR] เนื่องจากบรรทัดที่ 12 promotion public.month = 13 ;กำหนดค่าของเดือนเป็น 13 ซึ่งในความเป็นจริงเป็นไปไม่ได้ที่ค่าของเดือนจะมากกว่า 12 แต่อย่างไรก็ดี แม้ว่าการเช็คค่าของเดือนจะผิดพลาดแต่ความเป็นจริง แต่โปรแกรมก็ยังคงทำงานต่อไปได้คือยังคงส่งข้อความ Buy 1 cup of Banana Split , Free Ice Tea ออกทางจอภาพได้ ตัวอย่างนี้แสดงให้เห็นแล้วว่า การกำหนด month เป็น Public ให้กับแอตทริบิวต์นั้นไม่ได้เป็นการป้องกันการเข้าถึงข้อมูลจากคลาสภายนอกเลย คลาสอื่นๆสามารถแก้ไขค่าของแอตทริบิวต์ได้อย่างอิสระ คลาสเป็นเจ้าของแอตทริบิวต์จะไม่สามารถตรวจสอบหรือป้องกันความผิดพลาดของข้อมูลได้เลย

ต่อไปเราลองมาพิจารณากันว่า เมื่อเราทำ information hiding โดยกำหนด modifyเป็น private ให้กับแอตทริบิวต์ และให้คลาสอื่นเปลี่ยนแปลงแก้ไขข้อมูลผ่าน mutator method ที่กำหนดไว้ให้แล้ว ผลลัพธ์ที่ได้จะต่างกับการกำหนด modify เป็น Public ให้กับแอตทริบิวต์อย่างไร

ตัวอย่างที่ 8 โปรแกรมแสดงการเซ็ตค่าโปรโมชั่นไอศกรีม (ไม่ใช้หลักการของ Information hiding คือ กำหนด modifier เป็น private ให้กับแอตทริบิวต์

*ไฟล์ Promotion.java

อธิบายโปรแกรม

บรรทัดที่12-19 คือ Motator Method สำนักงานแปลงแก้ไขค่าของแอตทริบิวต์ month โดยไม่เมธอดนี้จะรับค่าพารามิเตอร์ month เข้ามาในโปรแกรม จากนั้นจะนำค่าตรวจสอบว่าค่าของเดือนมีค่าน้อยกว่า 0 หรือมากกว่า 12 หรือไม่ ถ้าว่าค่าของเดือนน้อยกว่า 0 หรือมากกว่า 12 ซึ่งในความเป็นจริงเป็นไปไม่ได้มีค่าของเดือนจะน้อยกว่า 0 หรือมากกว่า 12 เมธอดนี้ก็จะสั่งพิมพ์ข้อความ Set month Error ออกทางจอภาพคำสั่ง System. Exit (0) จะสั่งให้ออกจากการทำงานของโปรแกรมทันที แต่ถ้าค่าของเดือนเป็นค่าปกติ คือ เป็นค่าที่อยู่ระหว่าง1-12 แล้ว เมธอด ก็จะนำค่าพารามิเตอร์ที่รับเข้ามานำมาเช็คให้กับแอตทริบิวต์ month ของคลาสด้วยคำสั่ง this.month = month;

*ไฟล์ IceCreamPromotion.java

วิธีคอมไฟล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม

สาเหตุโปรแกรมแสดงผลลัพธ์ออกมาเป็น set month error แล้วจะวันที่ 23 มีการเรียกมีเมธอด setmonth ที่เป็น Mutator Method ของคลาส promotion โดยส่งค่าพารามิเตอร์เป็นค่า 13 ไปยังเมธอด ซึ่งเมธอด setmonth จะส่งพิมพ์ข้อความ set month error ออกทางจอภาพและออกจากการทำงานโปรแกรมทันที่ 15-21 ของคลาส IceCreamPromotion ไม่ถูกทำงาน

ให้ผู้อ่านในคอมเม้นในบรรทัดที่ 13 ของโปรแกรมแล้วทดลองคอมไพล์และรันโปรแกรมใหม่อีกครั้งจะพบว่าผลลัพธ์ของโปรแกรมเปลี่ยนแปลงไปดังนี้

ผลลัพธ์ของโปรแกรม

จากตัวอย่างด้านบนจะพบว่า เรากำหนด modifier เป็น private ให้กับแอตทริบิวต์ month เพื่อทำ information hiding ไม่ให้คลาสอื่นสามารถแปลงค่าของแอตทริบิวต์ได้โดยตรง และแม้ว่า Mutator Method จะช่วยให้คลาสอื่นสามารถเปลี่ยนแปลงค่าของแอตทริบิวต์ month ได้ก็ตาม แต่ Mutator Method ให้ผลต่างกับการที่เรากำหนด modifier เป็น Public ให้กับแอตทริบิวต์ month
กล่าวคือ รักเรากำหนด modifier เป็น Public ให้กับแอตทริบิวต์ month แล้วคลาสอื่นก็จะสามารถเปลี่ยนแปลงแก้ไขค่าของแอตทริบิวต์ month ได้โดยตรง ดังนั้น เราจะไม่สามารถตรวจสอบได้เลย ว่าค่าของแอตทริบิวต์ month เป็นค่าที่ถูกต้องหรือไม่ คลาสอื่นอาจจะเปลี่ยนแปลงแก้ไขค่าของแอตทริบิวต์ month เป็นค่าที่ไม่ได้อยู่ระหว่าง 1-12 ก็เป็นได้ ซึ่งก็จะทำให้ข้อมูลแอตทริบิวต์ month เกิดความผิดพลาด
แต่ด้วยหลักการของ information hiding ที่เราซ่อนแอตทริบิวต์ month เอาไว้ไม่ให้คลาสอื่นแก้ไขให้ได้โดยตรง การแก้ไขจะต้องทำผ่านเมธอด setmonth ซึ่งเป็น Mutator Method เท่านั้น ตรงนี้ Mutator Method ก็จะช่วยตรวจสอบและควบคุมให้แก้ไขแอตทริบิวต์ month มีความถูกต้อง คือ ค่าของเดือนจะมีค่าอยู่ระหว่าง 1-12 เท่านั้น ค่าของแอตทริบิวต์ month จึงไม่เกิดความผิดพลาดขึ้นอย่างแน่นอน

ตัวอย่างที่ 9 แสดงการทำงานของ access modifier : public

                                              *ไฟล์ Mother.java                    *ไฟล์ Child.java

วิธีคอมไฟล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

อธิบายโปรแกรม

คลาส mother ในไฟล์ mother.Java ประกาศตัวแปร x เป็น Public ดังนั้น ไม่ว่าจะอยู่ในคลาสเดียวกัน ต่างคลาสกัน อยู่ในแพ็กเกจเดียวกัน หรืออยู่ต่างแพ็กเกจกันก็ตาม ก็จะสามารถเรียกใช้งานตัวแปร x ได้ทั้งหมด สำหรับตัวอย่างนี้จะเห็นว่าคลาส child ( ในไฟล์ Child.Java ) สามารถเข้าถึงตัวแปร x ในคลาส mother ได้ ซึ่งไม่เพียงเป็นการเข้าถึงตัวแปรในคลาสหนึ่งจากอีกคลาสหนึ่งเท่านั้น แต่ยังเป็นการเข้าถึงตัวแปรข้ามแพ็กเกจด้วย เนื่องจากคลาสทั้งสองถูกกำหนดให้อยู่คนละแพ็กเกจกัน ( คลาส mother อยู่ในแพ็กเกจ mainclass ส่วนขคลาส Child อยู่ในแพ็กเกจ subclass )

ตัวอย่างที่ 10 แสดงการทำงานของ access modifier : protected

                                           *ไฟล์ Mother.java                    * ไฟล์ Child.java

วิธีคอมไฟล์โปรแกรม

อธิบายโปรแกรม

คลาส mother ในไฟล์ Mother.Java ได้ประกาศตัวแปร x เป็น protected จึงทำให้คลาสอื่นๆที่อยู่ต่างแพ็กเกจกันและไม่มีความเกี่ยวข้องสัมพันธ์กับคลาส mother สามารถเข้าใช้งานตัวแปร x ได้ จากตัวอย่างจะเห็นว่าคลาส Child อยู่ต่างแพ็กเกจกับคลาส mother ไม่ได้เกี่ยวข้องกับคลาส Mother เลย ทำให้ไม่สามารถเรียกใช้งานตัวแปร x ได้ จึงก่อให้เกิดข้อผิดพลาดขึ้นในการคอมไพล์โปรแกรม

วิธีแก้ไขโปรแกรม

การแก้ไขโปรแกรมนี้ในคอมไพล์ผ่าน วิธีหนึ่งทำได้โดยกำหนดให้คลาส Child สืบทอดคุณสมบัติมาจากคลาส Motherโดยแก้ไขวิธีประกาศคลาสในบรรทัดที่ 4 ของไฟล์ Child. Java ไปเป็น Public Class Child extends mother {แล้วแก้ไขวาระที่ 6 ของไฟล์Child. Javaไปเป็น System.out.println(x); หลังจากนั้นให้ทดลองคอมไพล์และรันโปรแกรมใหม่ จะได้ผลดังนี้}

ตัวอย่างที่ 11 แสดงการทำงานของ access modifier : package

                                                *ไฟล์ Mother.java               * ไฟล์ Child.java

วิธีคอมไฟล์โปรแกรม

อธิบายโปรแกรม

คลาส mother ในไฟล์ Mother.Java ได้ประกาศตัวแปร x โดยไม่ระบุ acceaa modifier ใดๆ จึงจะทำให้ระดับการเข้าถึงของตัวแปร x นี้เป็น Package หมายถึง คลาสอื่นๆที่อยู่ต่างแพ็กเกจกันกับคลาส mother จะไม่สามารถเรียกใช้งานตัวแปร x ได้ แม้ว่าคลาสนั้นจะสืบทอดคุณสมบัติไปจากคลาส mother ก็ตาม แต่ในตัวอย่างคลาส Child ซึ่งอยู่คนละแพ็กเกจกับคลาส mother พยายามที่จะเข้าถึงตัวแปร x ดังนั้นเมื่อคอมไพล์โปรแกรมจึงเกิดข้อผิดพลาดขึ้น

วิธีแก้ไขโปรแกรม

การแก้ไขโปรแกรมนี้ในคอมไพล์ผ่าน วิธีหนึ่งทำได้โดยกำหนดให้คลาส Child อยู่ในแพ็กเกจเดียวกันกับคลาส Mother โดยแก้ไขบรรทัดที่ 1 ของไฟล์ Child. Java ไปเป็น package mainclass; และลบคำสั่งในบรรทัดที่ 2 คือ import mainclass.*; ออกจากโปรแกรมหนังจากนั้นให้ทดลองคอมไพล์แลรันโปรแกรมใหม่จะได้ผลดังนี้

ตัวอย่างที่ 12 แสดงการทำงานของ access modifier : private

                                            *ไฟล์ Mother.java                   *ไฟล์ Child.java

วิธีคอมไฟล์โปรแกรม

อธิบายโปรแกรม

คลาส mother ในไฟล์ Mother.Java ได้ประกาศตัวแปร x เป็น private ดังนั้นคลาสอื่นจึงไม่มีสิทธิ์ใช้งานตัวแปร x นี้ได้โดยตรง ไม่ว่าคลาสนั้นจะอยู่ในแพ็กเกจเดียวกัน อยู่ต่างแพ็กเกจกัน หรืออยู่ต่างแพ็กเกจกันแต่มีความสัมพันธ์กันกับคลาส mother ก็ตาม
ก่อนจะแยกเก็บคลาสไว้คนละไฟล์ ให้ทดลองคอมไพล์และรันโปรแกรม TestIncludeClassMain.java ในตัวอย่างที่ 7.13 และดูผลลัพธ์ก่อน หลังจากนั้นเราจะแยกคลาส TestIncludeClassMain และคลาส TestIncludeClass ออกจากกันเป็นคนละไฟล์ โดยบันทึกชื่อไฟล์เป็นTestSeperateClassMain.java และ TestSeperateClass.java ตามลำดับ ดังนั้นตัวอย่างที่ 7.14 แล้วจึงคอมไพล์และรันโปรแกรมใหม่อีกครั้ง จะพบว่า ไม่ว่าจะเก็บคลาสไว้ในไฟล์เดียวกันหรือแยกเก็บไว้คนละไฟล์ก็ตาม ก็ยังคงเรียกใช้งานคลาสได้ในลักษณะเดิม และได้ผลลัพธ์เหมือนเดิมทุกประการ

ตัวอย่างที่ 13 แสดงการเรียกใช้งานคลาสที่ถูกเก็บไว้ในไฟล์เดียวกัน

*ไฟล์ TestIncludeClassMain.java

วิธีคอมไฟล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม

ตัวอย่างที่ 14 แสดงการเรียกใช้งานคลาสที่ถูกแยกเก็บไว้คนละไฟล์

ไฟล์ TestIncludeClass.java

ไฟล์ TestSeperateClassMain.java

วิธีคอมไฟล์โปรแกรม รันโปรแกรม และผลลัพธ์ของโปรแกรม