ในการเขียนโปรแกรมเชิงวัตถุนั้นคลาสเป็นเหมือนแผนผังสำหรับการสร้างวัตถุโดยในคลาสประกอบด้วยฟิลด์ซึ่งเป็นสถานะของวัตถุและเมธอดคือพฤติกรรมของวัตถุ พื้นฐานของการเขียนโปรแกรมเชิงวัตถุในภาษาจาวาที่สำคัญที่เราต้องเรียนรู้และเข้าใจ คือ คลาส ออบเจกต์ และ เมธอดคอนสตรักเตอร์ (constructor method) บวกกับหลักการในการเขียนโปรแกรมเชิงวัตถุ คือ คุณสมบัติการห่อหุ้ม(encapsulation)  คุณสมบัติการสืบทอด(inheritance)  คุณสมบัติความหลากหลายรูปแบบ(polymorphism) และคุณสมบัติการประกาศรูปแบบ(abstraction)

การออกแบบคลาส

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

การสร้างคลาส

     ประโยคคำสั่งในการสร้างคลาสประกอบด้วย

class ชื่อคลาส;  

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

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

     การตั้งชื่อคลาสนิยมขึ้นต้นคำด้วยตัวอักษรใหญ่และในคำถัดไปให้ขึ้นต้นด้วยตัวอักษรใหญ่เช่นกันเพื่อให้อ่านง่ายและต้องสื่อถึงวัตถุประสงค์คลาส เช่น CurrenAccount EmployeeArrayList Car เป็นต้น   

     ใน IntelliJ IDEA การสร้างคลาสทำโดยไปที่พื้นที่แสดงโครงสร้างไฟล์ทางด้านซ้าย ไปที่ชื่อโครงงาน > src และคลิกขวาที่ชื่อแพคเกจซึ่งในที่นี้คือ com.company เลือก New และเลือก Java Class 

     จากนั้นให้ใส่ชื่อคลาสและกด enter เพื่อสร้างคลาส

     IntelliJ IDEA จะสร้างคลาสขึ้นมาให้พร้อมกับสร้างไฟล์ใหม่ขึ้นมาโดยเราจะเห็นไฟล์ใหม่ภายใต้ src สังเกตุว่าไฟล์ทั้งหมดจะอยู่ภายใต้ com.company ซึ่งหมายความว่าคลาสทั้งหมดอยู่ในแพคเกจเดียวกัน 

การสร้างออบเจกต์จากคลาส

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

ชื่อคลาส ชื่อตัวแปร;

ชื่อตัวแปร = new ชื่อคลาส( );

     หรือเขียนด้วยกันได้ดังนี้

ชื่อคลาส ชื่อตัวแปร = new ชื่อคลาส( );

     ตัวอย่างเช่นการกำหนดตัวแปรชื่อ myCar เป็นตัวแปรที่ใช้เก็บออบเจกต์ที่สร้างขึ้นมาจากคลาส Car

     ตัวอย่างด้านล่างเป็นการสร้างคลาส Car และสร้างออบเจกต์จากคลาส Car  ดังนี้

     คำสั่ง Car somchaiCar; คือการประกาศว่าตัวแปร somchaiCar มีชนิดข้อมูลเป็น Car และให้จองหน่วยความจำสำหรับตัวแปร somchaiCar ส่วนขั้นตอนการสร้างออบเจกต์คือ somchaiCar = new Car(); จะเป็นการจองหน่วยความจำเพื่อเก็บข้อมูลของออบเจกต์ที่สร้างขึ้นมาและกำหนดให้ตัวแปร somchaiCar เก็บที่อยู่ของหน่วยความจำที่เก็บข้อมูลของออบเจกต์อีกทีหนึ่งตามแบบของข้อมูลชนิด reference data type 

    ในการระบุชื่อคลาสโปรแกรม IntelliJ IDEA จะแสดงชื่อคลาสที่สอดคล้องกับตัวอักษรที่เราพิมพ์ลงไปเพื่อช่วยให้เราทำงานได้เร็วขึ้น ดังนั้นให้เลือกคลาสจากแพคเกจที่เราต้องการให้ถูกต้อง เช่น ในกรณีนี้เราระบุคลาส Car ที่อยู่ในแพคเกจ com.company ที่เราสร้างขึ้นมาเอง

     จากตัวอย่างจะเห็นว่าถึงแม้ว่าคลาส Car ที่เราสร้างจะไม่มีฟิลด์หรือเมธอดเราก็สามารถสร้างออบเจกต์ขึ้นมาได้ แต่ถ้าเราลองเรียกใช้งานออบเจกต์ที่สร้างขึ้นมา เช่น พิมพ์ somchaiCar. จะพบว่ามีเมธอดต่างๆแสดงออกมามากมาย เมธอดเหล่านี้เป็นเมธอดที่ภาษาจาวาสืบทอดมาให้โดยอัตโนมัติจากคลาส Object ซึ่งเป็นคลาสแรกสุดของทุกๆคลาสในภาษาจาวา และทุกๆคลาสสืบทอดมาจากคลาส Object โดยอัตโนมัติ

     ตัวอย่างการใช้งานของบางเมธอดที่สืบทอดมาจากคลาส Object มีดังนี้

มองคลาสเป็นชนิดข้อมูล

     จากตัวอย่างจะเห็นว่าการสร้างออบเจกต์จะคล้ายกับการกำหนดชนิดข้อมูลให้กับตัวแปร แต่ต่างกันตรงที่ข้างหลังเครื่องหมายเท่ากับไม่ใช่ข้อมูล แต่เป็นคีย์เวิร์ดคำว่า new ตามด้วยชื่อคลาสเพื่อบอกว่าเป็นการสร้างออบเจกต์ ดังนั้นเราสามารถมองได้ว่าคลาสเป็นเหมือนชนิดข้อมูลแบบพิเศษที่เราสร้างขึ้นมา แต่ที่พิเศษกว่าก็คือเราสามารถมีฟิลด์และเมธอดในออบเจกต์ ในขณะที่ไม่สามารถมีเช่นนี้ได้กับข้อมูลแบบ primitive data type

การประกาศฟิลด์ในคลาส

     การประกาศฟิลด์ในคลาสจะเหมือนกับการประกาศตัวแปร แต่ต่างกันตรงที่เราจะไม่กำหนดค่าตั้งต้นให้กับฟิลด์และจะกำกับฟิลด์ด้วยคีย์เวิร์ดควบคุมการเข้าถึงแบบ private เสมอตามหลักการของคุณสมบัติการห่อหุ้ม (encapsulation) ซึ่งจะกล่าวถึงต่อไป

     แม้ว่าเรายังไม่ได้กำหนดค่าให้กับฟิลด์แต่ภาษาจาวาจะกำหนดค่าเริ่มต้นให้ตามชนิดของตัวแปร เช่น ตัวแปรชนิด int ค่าเริ่มต้นจะเป็น 0 ตัวแปรชนิด double ค่าเริ่มต้นจะเป็น 0.00 ส่วนตัวแปรที่เป็นชนิด reference data type อย่างเช่น String หรือคลาสที่เราสร้างขึ้นมา ค่าเริ่มต้นจะเป็น null จากตัวอย่างด้านล่างเรากำหนดฟิลด์ให้กับคลาส Car ดังนี้

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

ออบเจกต์ดังตัวอย่างด้านล่าง

     ถึงแม้ว่าเราจะควรกำกับด้วยคีย์เวิร์ดควบคุมการเข้าถึงแบบ private กับฟิลด์เสมอแต่ก็มีบางกรณีที่เราสามารถกำกับด้วยคีย์เวิร์ดควบคุมการเข้าถึงแบบ public หากเราต้องการให้ฟิลด์สามารถถูกเข้าถึงได้ ตัวอย่างของการกำหนดการเข้าถึงแบบ public ให้กับฟิลด์ ให้นึกถึงการใช้งาน Wrapper Class เพื่ออ่านค่าต่ำสุดและค่าสูงสุดที่ชนิดข้อมูลแบบต่างๆรองรับ เช่น Integer.MAX_VALUE ซึ่ง MAX_VALUE ก็คือฟิลด์แบบค่าคงที่และเราสามารถเรียกใช้งานฟิลด์นี้ได้เพราะฟิลด์ถูกกำกับด้วยคีย์เวิร์ดควบคุมการเข้าถึงแบบ public 

     ถึงแม้รูปแบบในการประกาศฟิลด์จะไม่จำเป็นต้องมีการกำหนดค่าเริ่มต้นให้กับฟิลด์ก็ตาม แต่เพื่อป้องกันความผิดพลาดในการทำงาน การกำหนดค่าที่ถูกต้องให้กับแต่ละฟิลด์ในออบเจกต์ตั้งแต่ขั้นตอนการสร้างออบเจกต์จะเป็นวิธีการที่ปลอดภัยมากกว่าการไม่กำหนดค่าเริ่มต้น ซึ่งเราสามารถทำได้โดยการสร้างเมธอดคอนสตรัคเตอร์ (constructor method) ซึ่งจะเป็นเมธอดแรกที่ถูกเรียกใช้งานเสมอเมื่อมีการสร้างออบเจกต์ และกำหนดค่าให้กับฟิลด์ในเมธอดคอนสตรัคเตอร์ การสร้างเมธอดคอนสตรัคเตอร์จะกล่าวถึงในบทต่อๆไป

การสร้างเมธอดเพื่อกำหนดค่าและอ่านค่าฟิลด์

     ตามหลักการของคุณสมบัติการห่อหุ้ม (encapsulation) เราจะติดต่อกับออบเจกต์ผ่านทางเมธอดเท่านั้น ดังนั้นเมื่อเรากำกับคีย์เวิร์ดควบคุมการเข้าถึงแบบ private ให้กับฟิลด์ เราจึงต้องสร้างเมธอดแบบ public เพื่อใช้สำหรับการกำหนดค่าและอ่านค่าจากฟิลด์ ในการสร้างเมธอดเพื่อกำหนดค่าเรานิยมตั้งชื่อเมธอดให้ขึ้นต้นด้วยคำว่า set และสำหรับเมธอดเพื่อการอ่านค่าเรานิยมตั้งชื่อเมธอดให้ขึ้นต้นด้วยคำว่า get  เราสามารถใช้เครื่องมือที่โปรแกรม IntelliJ IDEA ให้มาเพื่อสร้างเมธอด set… และ get… โดยไปที่เมนู Code > Generate ซึ่งจะแสดงหน้าต่าง Generate  ขึ้นมาให้เลือก Getter and Setter หรือเราจะเลือกสร้างเฉพาะ Getter หรือ Setter ก็ได้ตามต้องการ โดย Getter หมายถึงการสร้างเมธอด get… เพื่ออ่านค่าจากฟิลด์ และ Setter คือการสร้างเมธอด set… เพื่อกำหนดค่าให้กับฟิลด์

     จากนั้นให้เลือกฟิลด์ที่ต้องการสร้างเมธอดเพื่ออ่านค่าหรือกำหนดค่าให้กับฟิลด์

     โปรแกรม IntelliJ IDEA  จะสร้างเมธอด set… และ get… ให้ตามตัวอย่างด้านล่าง สังเกตุว่าในเมธอด set … จะใช้พารามิเตอร์ชื่อเดียวกับฟิลด์ ดังนั้นจึงแยกความแตกต่างระหว่างฟิลด์และพารามิเตอร์โดยการกำกับด้วยคีย์เวิร์ด this ที่ชื่อที่เป็นฟิลด์ ดังนั้นการเขียนโปรแกรมโดยอ้างถึงฟิลด์ในคลาสให้กำกับด้วยคีย์เวิร์ด this เสมอเพื่อความชัดเจนและง่ายต่อการทำความเข้าใจเมื่อต้องกลับมาอ่านโปรแกรมในภายหลัง

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

เมธอดคอนสตรัคเตอร์ (constructor method)

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

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

     เราสามารถใช้เครื่องมือที่โปรแกรม IntelliJ IDEA ให้มาเพื่อสร้างเมธอดคอนสตรัคเตอร์ได้โดยไปที่เมนู Code > Generate และเลือก Constructor

      จากนั้นให้เลือกฟิลด์ที่ต้องการให้เป็นพารามิเตอร์ในเมธอดคอนสตรัคเตอร์

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

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

 การโอเวอร์โหลดคอนสตรัคเตอร์

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

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

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

คอมโพสิชั่น (composition)

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

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

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

     คลาสถัดมาเป็นคลาสของล้อรถยนต์คือคลาส Wheels โดยประกาศฟิลด์เพื่อเก็บขนาดล้อและชนิดของยาง คลาสนี้มีเฉพาะเมธอดคอนสตรัคเตอร์ เพราะเราไม่มีการกระทำใดๆกับยางรถยนต์

     คลาสรถยนต์คือคลาส Car เป็นคลาสหลักที่เอาคลาสอื่นๆมาประกอบเป็นรถยนต์ขึ้นมา โดยประกาศฟิลด์เพื่อเก็บค่าออบเจกต์ของเครื่องยนต์ ตัวถังรถยนต์ และล้อรถยนต์ สร้างเมธอดคอนสตรัคเตอร์เพื่อรับค่าของออบเจกต์ย่อยมาเก็บที่ฟิลด์ และสร้างเมธอด getEngine getBody และ getWheel เพื่อเอาไว้อ้างถึงออบเจกต์ที่ถูกใช้ในการสร้างออบเจกต์หลัก เช่น เมธอด getEngine ค่าที่ได้คือออบเจกต์ของ Engine ที่ถูกใช้ในการสร้างออบเจกต์ของ Car

     จะเห็นว่าแต่ละฟิลด์ของคลาส Car จะกำหนดชนิดข้อมูลเป็นคลาส Engine คลาส Body และคลาส Wheels ซึ่งเป็นไปตามที่อธิบายก่อนหน้านี้ว่าเราจะมองคลาสเป็นชนิดข้อมูลแบบ reference data type 

     ในการใช้งานเราจะสร้างออบเจกต์ของแต่ละชิ้นส่วนขึ้นมาก่อน จากนั้นจึงสร้างออบเจค์ของรถยนต์ขึ้นมาและเรียกใช้เมธอด startEngine จากคลาส  Engine เพื่อสตาร์ทเครื่องยนต์ 

     ดังตัวอย่างด้านล่าง เริ่มจากสร้างออบเจกต์ของเครื่องยนต์ในบรรทัดที่ 6 สร้างออบเจกต์ของตัวถังรถยนต์ที่บรรถัดที่ 7 สร้างออบเจกต์ของล้อรถยนต์ที่บรรทัดที่ 8 จากนั้นจึงสร้างออบเจกต์ของรถยนต์ที่บรรทัดที่ 9

     เมื่อเราต้องการใช้งานเมธอดของออบเจกต์ย่อยเราต้องอ้างอิงถึงออบเจกต์ย่อยนั้นก่อนดังนี้ myCar.getEngine() จากนั้นจึงจะเรียกใช้เมธอดในออบเจกต์ย่อยได้ดังนี้ myCar.getEngine().startEngine(); ดังนั้นเราจึงต้องสร้างเมธอด get… ในคลาส Car เพื่อใช้อ้างอิงถึงออบเจกต์ย่อย 

     เราสามารถผสมผสานการใช้คอมโพสิชั่นกับการสืบทอดได้ เช่น เราอาจจะสร้างคลาส SportCar ซึ่งสืบทอดมาจากคลาส Car ก็ได้ จากตัวอย่างด้านล่าง เราสร้างคลาส SportCar ซึ่งสืบทอดมาจากคลาส Car (สังเกตุว่าใช้คีย์เวิร์ด extends) และสร้างเมธอดคอนสตรัคเตอร์เพื่อสร้างออบเจกต์ (สังเกตุว่าคลาส SportCar ประกาศฟิลด์เพียงฟิลด์เดียว แต่ในเมธอดคอนสตรัคเตอร์ต้องการพารามิเตอร์มากกว่านั้นซึ่งเป็นผลมาจากคุณสมบัติการสืบทอดซึ่งจะได้เรียนต่อไป) 

     จากตัวอย่างเราพิมพ์สีของรถโดยอ้างอิงออบเจกต์ย่อยและเมธอดของออบเจกต์ย่อยตามลำดับดังนี้  mySportCar.getBody().getColour() 

อินเนอร์คลาส

     ในภาษาจาวาเราสามารถสร้างคลาสภายใต้คลาสอื่นได้เรียกว่า nested class แบ่งออกเป็น 4 ชนิดคือ static nested class, nonstatic nested class หรือ inner class , local class ซึ่งเป็นคลาสที่อยู่ภายใต้บล็อกของเมธอด และ anonymous class ซึ่งเป็นคลาสที่ไม่มีการกำหนดชื่อคลาส สำหรับบทเรียนนี้เราจะเรียนรู้เรื่องอินเนอร์คลาส (nonstatic nested class หรือ inner class) ซึ่งจะมีโอกาศใช้บ่อยที่สุดเมื่อเทียบกับ nested class ชนิดอื่นๆ

     ลักษณะของอินเนอร์คลาสคือคลาสที่ถูกสร้างอยู่ภายในบล็อกของคลาสอื่น บล็อกที่อินเนอร์คลาสอาศัยอยู่จะเรียกว่าเอาต์เตอร์คลาส (outter class) ตัวอย่างเช่น 

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

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