อ็อบเจ็กต์และคลาส Java

ก่อนที่จะทำความเข้าใจคลาสและอ็อบเจ็กต์ Java เรามาแนะนำการเขียนโปรแกรมเชิงวัตถุกันก่อน การเขียนโปรแกรมคือการออกแบบโปรแกรมผ่านวัตถุ วัตถุแสดงถึงเอนทิตีและสามารถระบุเอนทิตีได้อย่างชัดเจน

Java เป็นภาษาเชิงวัตถุ รองรับแนวคิดพื้นฐานต่อไปนี้:

• ความแตกต่าง

• สืบทอด

• การห่อหุ้ม

• เชิงนามธรรม

• ใจดี

• วัตถุ

• ตัวอย่าง

• วิธี

• การแยกวิเคราะห์ข้อความ

ในส่วนนี้เรามุ่งเน้นไปที่แนวคิดของวัตถุและคลาส

• วัตถุ : วัตถุเป็นตัวอย่างของคลาสและมีสถานะและพฤติกรรม ตัวอย่างเช่น สุนัขเป็นวัตถุ สถานะ ได้แก่ สี ชื่อ และสายพันธุ์ พฤติกรรม ได้แก่ การกระดิกหาง การเห่า การกิน เป็นต้น

• คลาส : คลาสคือเทมเพลตที่อธิบายพฤติกรรมและสถานะของคลาสของออบเจ็กต์

วัตถุใน Java

ทีนี้เรามาดูกันดีกว่าว่าวัตถุคืออะไร หากมองโลกแห่งความจริงรอบตัวจะพบว่ามีสิ่งของมากมายรอบตัว เช่น รถยนต์ สุนัข คน เป็นต้น วัตถุทั้งหมดเหล่านี้มีสถานะและพฤติกรรมของตัวเอง

ดูสุนัขเป็นตัวอย่าง สถานะ ได้แก่ ชื่อ สายพันธุ์ และสี และพฤติกรรม ได้แก่ การเห่า การกระดิกหาง และการวิ่ง

เมื่อเปรียบเทียบวัตถุจริงและวัตถุซอฟต์แวร์จะคล้ายกันมาก

ออบเจ็กต์ซอฟต์แวร์ก็มีสถานะและพฤติกรรมเช่นกัน สถานะของออบเจ็กต์ซอฟต์แวร์คือคุณลักษณะของมัน และพฤติกรรมของมันจะสะท้อนให้เห็นผ่านวิธีการต่างๆ

ในการพัฒนาซอฟต์แวร์ วิธีการดำเนินการกับการเปลี่ยนแปลงสถานะภายในของออบเจ็กต์ และการเรียกร่วมกันระหว่างออบเจ็กต์ก็ทำได้สำเร็จเช่นกันผ่านวิธีการ

ชั้นเรียนในภาษาชวา

คลาสสามารถถือเป็นเทมเพลตสำหรับการสร้างอ็อบเจ็กต์ Java

มาทำความเข้าใจคำจำกัดความของคลาสใน Java ผ่านคลาสง่ายๆ ดังต่อไปนี้:

 สุนัขคลาสสาธารณะ{
สายพันธุ์สตริง;
อายุจริง;
สีสาย;
โมฆะเห่า () {
-

โมฆะหิว () {
-

เป็นโมฆะนอน () {
-
-

คลาสสามารถมีตัวแปรประเภทต่อไปนี้:

• ตัวแปรท้องถิ่น : ตัวแปรที่กำหนดในเมธอด ตัวสร้าง หรือบล็อกคำสั่งเรียกว่าตัวแปรท้องถิ่น การประกาศตัวแปรและการเริ่มต้นทั้งหมดอยู่ในวิธีการ หลังจากสิ้นสุดวิธีการแล้ว ตัวแปรจะถูกทำลายโดยอัตโนมัติ

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

• ตัวแปรคลาส : ตัวแปรคลาสจะถูกประกาศในคลาสเช่นกัน นอกเนื้อหาของวิธีการ แต่จะต้องประกาศเป็นประเภทคงที่

คลาสสามารถมีได้หลายวิธี ในตัวอย่างข้างต้น: barking() , hungry() และ sleeping() ล้วนเป็นวิธีการของคลาส Dog

ตัวสร้าง

ทุกคลาสมีเมธอดคอนสตรัคเตอร์ หากไม่มีการกำหนดคอนสตรัคเตอร์ไว้อย่างชัดเจนสำหรับคลาส คอมไพลเลอร์ Java จะจัดเตรียมคอนสตรัคเตอร์เริ่มต้นสำหรับคลาสนั้น

เมื่อสร้างวัตถุ จะต้องเรียกเมธอดคอนสตรัคเตอร์อย่างน้อยหนึ่งวิธี ชื่อของตัวสร้างจะต้องเหมือนกับคลาส

นี่คือตัวสร้างตัวอย่าง:

 ลูกสุนัขคลาสสาธารณะ{
publicPuppy(){
-

ลูกสุนัขสาธารณะ (ชื่อสตริง) {
// Constructor นี้มีพารามิเตอร์เดียวเท่านั้น: name
-
-

สร้างวัตถุ

วัตถุถูกสร้างขึ้นตามคลาส ใน Java ให้ใช้คีย์เวิร์ด new เพื่อสร้างอ็อบเจ็กต์ใหม่ การสร้างวัตถุต้องมีสามขั้นตอนต่อไปนี้:

• Declaration : ประกาศวัตถุ รวมถึงชื่อวัตถุและประเภทวัตถุ

• การสร้างอินสแตนซ์ : ใช้คีย์เวิร์ด new เพื่อสร้างออบเจ็กต์

• การเริ่มต้น : เมื่อใช้ new เพื่อสร้างอ็อบเจ็กต์ เมธอด Constructor จะถูกเรียกเพื่อเริ่มต้นอ็อบเจ็กต์

นี่คือตัวอย่างการสร้างวัตถุ:

 ลูกสุนัขคลาสสาธารณะ{
ลูกสุนัขสาธารณะ (ชื่อสตริง) {
//ตัวสร้างนี้มีพารามิเตอร์เดียวเท่านั้น: ชื่อ
System.out.println("ชื่อลูกสุนัขคือ :" + ชื่อ );
-
โมฆะคงที่สาธารณะ main (สตริง [] args) {
//คำสั่งต่อไปนี้จะสร้างวัตถุ Puppy Puppy myPuppy = new Puppy( "tommy" );
-
-

คอมไพล์และรันโปรแกรมด้านบน และผลลัพธ์ต่อไปนี้จะถูกพิมพ์:

 ลูกสุนัขชื่อ:ทอมมี่

เข้าถึงตัวแปรอินสแตนซ์และวิธีการ

เข้าถึงตัวแปรสมาชิกและวิธีการสมาชิกผ่านวัตถุที่สร้างขึ้นดังต่อไปนี้:

 /* สร้างอินสแตนซ์ของวัตถุ */
ObjectReference = ตัวสร้างใหม่ ();
/* เข้าถึงตัวแปร */
ObjectReference.variableName;
/* วิธีการเข้าถึงในคลาส */
ObjectReference.MethodName();

ตัวอย่าง

ตัวอย่างต่อไปนี้แสดงวิธีการเข้าถึงตัวแปรอินสแตนซ์และวิธีการเรียกสมาชิก:

 ลูกสุนัขคลาสสาธารณะ{
intpuppyAge;
ลูกสุนัขสาธารณะ (ชื่อสตริง) {
// Constructor นี้มีพารามิเตอร์เดียวเท่านั้น: name
System.out.println("ชื่อที่ส่งคือ :" + ชื่อ );
-

setAge โมฆะสาธารณะ (อายุ int) {
ลูกสุนัขอายุ = อายุ;
-

สาธารณะ int getAge( ){
System.out.println("อายุของลูกสุนัขคือ :" +puppyAge );
กลับลูกสุนัขอายุ;
-

โมฆะคงที่สาธารณะ main (สตริง [] args) {
/* สร้างวัตถุ */
ลูกสุนัข myPuppy = ลูกสุนัขตัวใหม่ ( "ทอมมี่" );
/* กำหนดอายุด้วยวิธีต่างๆ */
myPuppy.setAge(2);
/* เรียกวิธีอื่นในการรับอายุ */
myPuppy.getAge( );
/*คุณสามารถเข้าถึงตัวแปรสมาชิกได้ดังนี้ */
System.out.println("ค่าตัวแปร :" + myPuppy.puppyAge );
-
-

การคอมไพล์และรันโปรแกรมข้างต้นจะให้ผลลัพธ์ดังต่อไปนี้:

 ชื่อที่ผ่านคือ:ทอมมี่
ลูกสุนัขอายุ :2
ค่าตัวแปร:2

กฎการประกาศไฟล์ต้นฉบับ

ในส่วนสุดท้ายของส่วนนี้ เราจะเรียนรู้เกี่ยวกับกฎการประกาศสำหรับไฟล์ต้นฉบับ ให้ความสนใจเป็นพิเศษกับกฎเหล่านี้เมื่อกำหนดหลายคลาสในไฟล์ต้นฉบับและเมื่อมีคำสั่ง import และคำสั่ง package

• ในซอร์สไฟล์จะมีคลาส public ได้เพียงคลาสเดียวเท่านั้น

• ไฟล์ต้นฉบับสามารถมีคลาสที่ไม่ใช่แบบ public ได้หลายคลาส

• ชื่อของไฟล์ต้นฉบับควรสอดคล้องกับชื่อคลาสของคลาส public ตัวอย่างเช่น: ชื่อคลาสของคลาส public ในไฟล์ต้นฉบับคือ Employee ดังนั้นไฟล์ต้นฉบับควรตั้งชื่อเป็น Employee.java

• หากมีการกำหนดคลาสไว้ในแพ็คเกจ คำสั่ง package ควรอยู่ในบรรทัดแรกของไฟล์ต้นฉบับ

• หากไฟล์ต้นฉบับมีคำสั่ง import ควรวางไว้ระหว่างคำสั่ง package และคำจำกัดความของคลาส หากไม่มีคำสั่ง package คำสั่ง import ควรอยู่อันดับแรกในไฟล์ต้นฉบับ

• คำสั่ง import และคำสั่ง package ถูกต้องสำหรับคลาสทั้งหมดที่กำหนดไว้ในไฟล์ต้นฉบับ ในไฟล์ต้นฉบับเดียวกัน ไม่สามารถกำหนดการประกาศแพ็กเกจที่แตกต่างกันให้กับคลาสที่ต่างกันได้

คลาสมีระดับการเข้าถึงหลายระดับ และคลาสยังแบ่งออกเป็นประเภทต่าง ๆ เช่น คลาสนามธรรม คลาส final ฯลฯ สิ่งเหล่านี้จะถูกนำมาใช้ในบทการควบคุมการเข้าถึง

นอกเหนือจากประเภทที่กล่าวข้างต้น Java ยังมีคลาสพิเศษบางคลาส เช่น คลาสภายในและคลาสที่ไม่ระบุชื่อ

แพ็คเกจจาวา

แพ็คเกจส่วนใหญ่จะใช้เพื่อจำแนกคลาสและอินเทอร์เฟซ เมื่อพัฒนาโปรแกรม Java คุณอาจเขียนคลาสเป็นร้อยหรือหลายพันคลาส ดังนั้นจึงจำเป็นต้องจำแนกคลาสและอินเทอร์เฟซ

คำสั่งนำเข้า

ใน Java หากระบุชื่อแบบเต็ม รวมถึงชื่อแพ็กเกจและชื่อคลาส คอมไพเลอร์ Java จะสามารถค้นหาซอร์สโค้ดหรือคลาสได้อย่างง่ายดาย คำ Import ใช้เพื่อจัดเตรียมเส้นทางที่เหมาะสมเพื่อให้คอมไพเลอร์สามารถค้นหาคลาสที่ต้องการได้

ตัวอย่างเช่น บรรทัดคำสั่งต่อไปนี้จะสั่งให้คอมไพเลอร์โหลดคลาสทั้งหมดในพาธ java_installation/java/io

 นำเข้า java.io.*;

ตัวอย่างง่ายๆ

ในตัวอย่างนี้ เราสร้างสองคลาส: Employee และ EmployeeTest

ขั้นแรกให้เปิดโปรแกรมแก้ไขข้อความและวางโค้ดต่อไปนี้ลงไป โปรดทราบว่าไฟล์จะถูกบันทึกเป็น Employee.java

คลาส Employee มีตัวแปรสมาชิก 4 ตัว ได้แก่ ชื่อ อายุ ตำแหน่ง และเงินเดือน คลาสประกาศเมธอดคอนสตรัคเตอร์อย่างชัดเจนโดยมีเพียงพารามิเตอร์เดียวเท่านั้น

 นำเข้า java.io.*;
พนักงานระดับสาธารณะ{
ชื่อสตริง;
อายุจริง;
การกำหนดสตริง
เงินเดือนสองเท่า
// ตัวสร้างคลาสพนักงานพนักงานสาธารณะ (ชื่อสตริง) {
this.name = ชื่อ;
-
//ตั้งค่าอายุ public void empAge(int empAge){
อายุ = ว่าง;
-
/*กำหนดค่าการกำหนด*/
empDesignation โมฆะสาธารณะ (สตริง empDesig) {
การกำหนด = empDesig;
-
/*กำหนดมูลค่าเงินเดือน*/
empSalary โมฆะสาธารณะ (empSalary สองเท่า) {
เงินเดือน = เงินเดือนพนักงาน;
-
/* พิมพ์ข้อมูล */
โมฆะสาธารณะ printEmployee(){
System.out.println("ชื่อ:"+ ชื่อ );
System.out.println("อายุ:" + อายุ );
System.out.println("การกำหนด:" + การกำหนด );
System.out.println("เงินเดือน:" + เงินเดือน);
-
-

การรันโปรแกรมเริ่มต้นจากวิธี main ในการรันโปรแกรมนี้ จะต้องรวมวิธี main ไว้และต้องสร้างออบเจ็กต์อินสแตนซ์

คลาส EmployeeTest ได้รับด้านล่าง ซึ่งสร้างอินสแตนซ์สองอินสแตนซ์ของคลาส Employee และวิธีการเรียกใช้เพื่อตั้งค่าของตัวแปร

บันทึกรหัสต่อไปนี้ในไฟล์ EmployeeTest.java

 นำเข้า java.io.*;
EmployeeTest ระดับสาธารณะ{

โมฆะคงที่สาธารณะ main (String args []) {
/* สร้างวัตถุสองชิ้นโดยใช้ Constructor */
พนักงาน empOne = พนักงานใหม่ ("เจมส์ สมิธ");
พนักงาน empTwo = พนักงานใหม่ ("แมรี่ แอนน์");

//เรียกเมธอดสมาชิกของทั้งสองอ็อบเจ็กต์ empOne.empAge(26);
empOne.empDesignation("วิศวกรซอฟต์แวร์อาวุโส");
empOne.empSalary(1,000);
empOne.printEmployee();

empTwo.empAge(21);
empTwo.empDesignation("วิศวกรซอฟต์แวร์");
empTwo.empSalary(500);
empTwo.printEmployee();
-
-

คอมไพล์ไฟล์ทั้งสองนี้และเรียกใช้คลาส EmployeeTest คุณสามารถดูผลลัพธ์ต่อไปนี้:

 C:>javacEmployee.java
C :> vi EmployeeTest.java
C:>javacEmployeeTest.java
C :>javaEmployeeTest
ชื่อ:เจมส์ สมิธ
อายุ:26
ตำแหน่ง:วิศวกรซอฟต์แวร์อาวุโส
เงินเดือน:1,000.0
ชื่อ:แมรี่ แอนน์
อายุ:21
ตำแหน่ง:วิศวกรซอฟต์แวร์
เงินเดือน:500.0