Transcript 8

LOGO
การเขียนโปรแกรมภาษาจาวาเชิงออปเจ็ค
(Object Oriented Java Programming)
07/08/59
Nerissa Onkhum
1
Outline
ทบทวนวัตถุและคลาส
อธิบายเมธอด และการเรี ยกใช้เมธอด
อธิบายคียเ์ วิร์ดที่ใช้เป็ น modifier ของเมธอด
แนะนาการเขียนโปรแกรมภาษาจาวาเชิงออปเจ็ค
อธิบายคุณลักษณะเด่นของโปรแกรมเชิงออปเจ็ค
อธิบายความหมายของ Constructor
การเขียนโปรแกรมภาษาจาวาเชิงออปเจ็ค
ตัวอย่างโปรแกรมในบทที่ผา่ นมาจะเขียนทุกคาสัง่ อยู่
ภายในเมธอดที่ชื่อ main() ซึ่ งไม่ได้ใช้หลักการเชิงออปเจ็ค
และไม่เหมาะที่จะนาไปใช้ในทางปฏิบตั ิเมื่อโปรแกรม
มีขนาดใหญ่ข้ ึน
การเขียนโปรแกรมเชิงออปเจ็คที่ดีจะต้องมีการกาหนด
เมธอดต่างๆให้กบั คลาส
ตัวอย่ างโปรแกรมทีท่ ุกคาสั่ งอยู่ในเมธอด main()
public class AllInMain {
public static void main(String args[]) {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is
} else if (score >= 70) {
System.out.println("Grade is
} else if (score >= 60){
System.out.println("Grade is
} else if (score >= 50){
System.out.println("Grade is
} else {
System.out.println("Grade is
}
}
}
A");
B");
C");
D");
F");
ตัวอย่ างโปรแกรมที่ใช้ หลักการเชิงออปเจ็ค
public class NumericalClass {
public void calculate() {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is A");
} else if (score >= 70) {
System.out.println("Grade is B");
} else if (score >= 60){
System.out.println("Grade is C");
} else if (score >= 50){
System.out.println("Grade is D");
} else {
System.out.println("Grade is F");
}
}
}
public class MyMain {
public static void main(String args[]) {
NumericalClass obj = new NumericalClass();
obj.calculate();
}
}
ตัวอย่ างโปรแกรมทีท่ ุกเมธอดอยู่ในคลาสเดียวกัน
public class NumericalClassV1 {
public void calculate() {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is A");
} else if (score >= 70) {
System.out.println("Grade is B");
} else if (score >= 60){
System.out.println("Grade is C");
} else if (score >= 50){
System.out.println("Grade is D");
} else {
System.out.println("Grade is F");
}
}
public static void main(String args[]) {
NumericalClassV1 obj = new NumericalClassV1();
obj.calculate();
}
}
วัตถุ (object)
โปรแกรมพจนานุกรมฉบับราชบัณฑิตยสถาน พ.ศ. ๒๕๒๕ นิยามคาว่า
“วัตถุ” ว่าหมายถึงสิ่ งของ และนิยามคาว่า “สิ่ งของ” ว่าหมายถึงวัตถุ
ต่างๆ
ในโปรแกรมจะจาลองลักษณะและความสามารถของวัตถุต่างๆ ที่อยูใ่ น
โลกจริ ง
 สิ่ งไม่มีชีวิต เช่น รู ปสี่ เหลี่ยม โทรทัศน์ หรื อบ้าน
 สิ่ งมีชีวิต เช่น พนักงาน นก หรื อต้นไม้
 สิ่ งที่เป็ นนามธรรม เช่น แนวความคิด หลักการ หรื อวิธีการ
07/08/59
7
คลาส (class)
สิ่ งที่เราใช้อธิบายลักษณะและความสามารถของวัตถุ
คลาสอาจจะเปรี ยบได้กบั พิมพ์เขียวหรื อแบบแปลนของวัตถุ
วัตถุกเ็ ป็ นที่สร้างขึ้นมาจากแบบแปลนนั้น
สามารถสร้างวัตถุจานวนมากได้ตามแบบแปลน
07/08/59
8
วัตถุและคลาส
07/08/59
9
การกาหนดสาระสาคัญ (abstraction)
เลือกจาลองลักษณะที่สาคัญ
 จาลองเฉพาะความสามารถของวัตถุที่เราสนใจหรื อเกี่ยวข้องกับ
ปัญหาที่เราต้องการจะแก้ไข
 เช่น ถ้าเราต้องการคานวณหาน้ าหนักเฉลี่ยของแมว เราก็อาจจะ
ให้แมวจาลองมี "น้ าหนัก" เป็ นลักษณะที่สาคัญ
ไม่จาลองลักษณะทั้งหมดของวัตถุ
 การจาลองแมวจะไม่จาลองหนวดทุกเส้นของแมว
 การดึงเอาลักษณะหรื อความสามารถที่สาคัญออกมาเรี ยกว่า
“abstraction”
10
07/08/59
คลาสในภาษาจาวา
คลาสหรื อแบบแปลนของวัตถุ จะถูกเขียนอยูใ่ นไฟล์ที่มีนามสกุล java
 เช่น คลาสสี่ เหลี่ยมอาจจะถูกเขียนอยูใ่ นไฟล์ชื่อ Rectangle.java
class สี่ เหลี่ยม
{
}
07/08/59
11
ส่ วนประกอบของคลาส
แอททริบิวท์ (Attribute) เป็ นสิ่ งที่ใช้บอกถึงลักษณะต่างๆของ
วัตถุในคลาส
เมธอด(Method) เป็ นสิ่ งที่ใช้อธิบายการทางานของวัตถุใน
คลาส
07/08/59
12
ส่ วนประกอบของคลาส
class ชื่ อคลาส {
แอททริบิวท์ 1;
แอททริบิวท์ 2;
คลาส
07/08/59
}
เมธอด1(){
//วิธีการทางาน
}
เมธอด2(){
//วิธีการทางาน
}
แอททริบิวต์
เมธอด
13
ตัวอย่ างแอททริบิวท์
คลาส
แอททริบิวท์
นก
สี , เพศ, น้ าหนัก
โทรทัศน์
ยีห่ อ้ , รุ่ น, หมายเลข, ขนาดจอภาพ
สี่ เหลี่ยม
ความกว้าง, ความสู ง
07/08/59
14
ตัวอย่ างเมธอด
เมธอด
คลาส
07/08/59
นก
กิน(), บิน(), ร้องเพลง()
โทรทัศน์
เปิ ด(), ปิ ด(), เปลี่ยนช่อง(), ปรับเสี ยง()
สี่ เหลี่ยม
คานวณพื้นที่()
15
การสร้ างวัตถุ
หลังจากที่คลาสถูกสร้างขึ้น เราจึงจะสร้างวัตถุจากคลาส โดยการใช้
คาสัง่ new
รู ปแบบ
คลาส เรฟเฟอร์ เรนซ์ = new คลาส();
ตัวอย่าง
Rectangle a = new Rectangle();
สี่ เหลี่ยม ก = new สี่ เหลี่ยม();
Rectangle b = new Rectangle();
สี่ เหลี่ยม ข = new สี่ เหลี่ยม();
07/08/59
16
การสร้ างวัตถุ
เรฟเฟอร์เรนซ์เปรี ยบได้กบั รี โมตคอนโทรลที่ใช้ควบคุมสัง่ การวัตถุที่
อ้างถึง
เรฟเฟอร์เรนซ์ ก อ้างถึงวัตถุสี่เหลี่ยมที่
ถูกสร้างขึ้นมาใหม่ดว้ ยคาสัง่ new
เรฟเฟอร์เรนซ์ ข อ้างถึง
วัตถุสี่เหลี่ยมอีกรู ปหนึ่ง
วัตถุในคลาสเดียวกันไม่จาเป็ นต้องมีลกั ษณะเหมือนกัน เช่น สี่ เหลี่ยมเรฟเฟอร์เรนซ์
ก อ้างถึง อาจมีความกว้างและสู งเท่ากับ 10,5 ในขณะที่ ข มีขนาด 7,3 เป็ นต้น
07/08/59
17
แอททริบิวท์
ข้อมูลที่ใช้อธิบายความแตกต่างของวัตถุ
เช่น วัตถุแมว มีชื่อ สี พันธุ์ น้ าหนัก แตกต่างกัน
ตัวแปรวัตถุ (instance variable)
07/08/59
18
แอททริบิวท์
class สี่ เหลี่ยม {
double ความกว้าง;
double ความสู ง;
}
07/08/59
class Rectangle {
double width;
double height;
}
19
การใช้ งานแอททริบิวท์
รู ปแบบ
เรฟเฟอร์ เรนซ์ .แอททริบิวท์
ตัวอย่าง
สี่ เหลี่ยม ส = new สี่ เหลี่ยม();
ส.ความกว้าง = 10;
ส.ความสู ง = 5;
07/08/59
20
Rectangle r = new Rectangle();
r.width = 10;
r.height = 5;
}
ข้ อความและเมธอด
สัง่ ให้วตั ถุทางานโดยการส่ งข้อความ (message)
หรื อคาสัง่ ไปหาวัตถุ
เมื่อวัตถุได้รับข้อความแล้ว วัตถุน้ นั ก็จะทางานตาม
วิธีการหรื อคาสัง่ ต่างๆที่เขียนไว้ใน เมธอด (method)
07/08/59
21
การเรียกเมธอด (การส่ งข้ อความ)
รู ปแบบ
เรฟเฟอร์ เรนซ์ .เมธอด();
ตัวอย่าง
สี่ เหลี่ยม ส = new สี่ เหลี่ยม();
System.out.println(ส.คานวณพื้นที่());
07/08/59
22
รูปแบบการเรียกใช้ เมธอด
รู ปแบบของคาสั่งที่มีการเรี ยกใช้เมธอดเป็ นดังนี้
obj.methodName([arguments]);
 arguments อาจจะเป็ นข้อมูลค่าคงที่หรื อตัวแปร
ชนิดข้อมูลของ arguments ที่ใช้ในการเรี ยกเมธอด จะต้อง
สอดคล้องกันกับชนิดข้อมูลของ arguments ของเมธอด
การเรียกใช้ เมธอด
เมธอดที่กาหนดขึ้นในคลาสใดๆสามารถเรี ยกใช้งานได้สองรู ปแบบคือ
 การเรี ยกใช้งานจากคลาสที่ต่างกัน
 การเรี ยกใช้งานภายในคลาสเดียวกัน
การเรี ยกใช้เมธอดจากคลาสที่ต่างกัน จะต้องมีการสร้างออปเจ็คของ
คลาสที่มีเมธอดที่จะถูกเรี ยกใช้งานก่อน จึงจะสามารถเรี ยกใช้เมธอดได้
การเรี ยกใช้เมธอดภายในคลาสเดียวกัน สามารถทาได้โดยไม่จาเป็ นต้อง
สร้างออปเจ็คของคลาสขึ้นมาก่อน และสามารถเรี ยกเมธอดได้ทุกเมธอด
ตัวอย่ างโปรแกรมที่มีการเรียกใช้ เมธอดในคลาสเดียวกัน
public class NumericalClassV2 {
public void calculate() {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is
} else if (score >= 70) {
System.out.println("Grade is
} else if (score >= 60){
System.out.println("Grade is
} else if (score >= 50){
System.out.println("Grade is
} else {
System.out.println("Grade is
}
}
public void callMethod() {
calculate();
}
}
A");
B");
C");
D");
F");
การส่ งผ่ าน argument
กรณี ที่เมธอดมี argument ที่จะรับค่าเพื่อนาไปใช้ในเมธอด อาทิเช่น
public void setGPA(double GPA) {
...
}
คาสัง่ ที่เรี ยกใช้เมธอดนี้ จะต้องส่ ง argument ที่มีชนิดข้อมูลเป็ น double
ไปพร้อมกับชื่อเมธอด เช่น setGPA(3.0);
ตัวอย่ างโปรแกรม
public class Student {
String id;
String name;
double gpa;
public void setGPA(double GPA) {
gpa = GPA;
}
public double getGPA() {
return gpa;
}
}
public class MyMain2 {
public static void main(String args[]) {
Student s1 = new Student();
s1.setGPA(3.0);
}
}
argument ของเมธอด
argument ของเมธอดจะมีชนิดข้อมูลเป็ นสองแบบตามชนิดข้อมูลของ
ตัวแปรดังนี้
 argument ที่มีชนิดข้อมูลแบบพื้นฐาน
 argument ที่มีชนิดข้อมูลแบบอ้างอิง
argument ของเมธอด
ในกรณี ของ argument ที่มีชนิดข้อมูลแบบพื้นฐาน เราสามารถที่จะส่ ง
ค่าคงที่ขอ้ มูล ตัวแปร หรื อนิพจน์ให้กบั argument ได้ ตัวอย่างเช่น
 ค่าคงที่ขอ้ มูล เช่น
s1.setGPA(3.0);
 ตัวแปร เช่น
double x = 3.0;
s1.setGPA(x);
 นิพจน์ เช่น
s1.setGPA(3.0+0.05);
argument ทีม่ ีชนิดข้ อมูลแบบอ้ างอิง
เราจะต้องส่ งออปเจ็คที่มีชนิดข้อมูลที่สอดคล้องไปเท่านั้น
ยกเว้นกรณี ที่ argument นั้นมีชนิดข้อมูลเป็ น String ซึ่งในกรณี
นี้จะสามารถส่ งข้อมูลค่าคงที่ได้
ตัวอย่ างโปรแกรมที่มกี ารส่ ง argument ที่เป็ นออปเจ็ค
import java.util.*;
public class StudentV1 {
String id;
String name;
Date dob;
public void setDOB(Date d) {
dob = d;
}
public Date getDOB() {
return dob;
}
}
public class TestStudentV1 {
public static void main(String args[]) {
StudentV1 s1 = new StudentV1();
Date d1 = new Date(16,12,1980);
s1.setDOB(d1);
}
}
ชนิดข้ อมูลและจานวนของ argument
ชนิดข้อมูลของ argument ที่จะส่ งผ่านไปยังเมธอดไม่จาเป็ นที่
จะต้องเป็ นชนิดข้อมูลเดียวกัน แต่ตอ้ งเป็ นชนิดข้อมูลที่สามารถ
แปลงข้อมูลให้กว้างขึ้นได้โดยอัตโนมัติ
เมธอดใดๆอาจมี argument สาหรับรับค่ามากกว่าหนึ่งตัว แต่
การเรี ยกใช้เมธอดเหล่านี้จะต้องส่ ง argument ที่มีชนิดข้อมูลที่
สอดคล้องกันและมีจานวนเท่ากัน
ตัวอย่ างโปรแกรมที่มีการส่ ง argument จานวนสองตัว
public class NumericalSample {
public void calMax(int i, double d) {
if (i > d) {
System.out.println("Max = "+i);
} else {
System.out.println("Max = "+d);
}
}
public static void main(String args[]) {
NumericalSample obj = new NumericalSample();
obj.calMax(3,4.0);
}
}
การเปลีย่ นแปลงค่ าของ argument
การส่ ง argument ที่มีชนิดข้อมูลเป็ นแบบพื้นฐาน หากมีการ
เปลี่ยนแปลงค่าของ argument ภายในเมธอดที่ถูกเรี ยกใช้งาน จะไม่มีผล
ทาให้ค่าของ argument ที่ส่งไปเปลี่ยนค่าไปด้วย
การส่ ง argument ที่มีชนิดข้อมูลเป็ นแบบอ้างอิง จะเป็ นการส่ งตาแหน่ง
อ้างอิงของออปเจ็คไปให้กบั เมธอดที่ถูกเรี ยกใช้งาน ดังนั้นการ
เปลี่ยนแปลงค่าของคุณลักษณะของออปเจ็คจะมีผลทาให้ค่าของ
คุณลักษณะของออปเจ็คที่ส่งไปเปลี่ยนไปด้วย
ตัวอย่ างโปรแกรมทีแ่ สดงการเปลีย่ นแปลงค่ าของ argument
import java.util.*;
public class ArgumentPassing {
public void method1(int x) {
x = 3;
}
public void method2(Date d) {
d.setDate(1);
d.setMonth(1);
d.setYear(2002);
}
public int method3() {
return 0;
}
ตัวอย่ างโปรแกรมทีแ่ สดงการเปลีย่ นแปลงค่ าของ argument
public static void main(String args[]) {
int x = 4;
ArgumentPassing obj = new ArgumentPassing();
Date d1 = new Date(16,12,1980);
obj.method1(x);
System.out.println("x = "+x);
obj.method2(d1);
System.out.println("Date = "+d1);
obj.method3();
}
}
การรับค่ าที่ส่งกลับมาจากเมธอด
เมธอดใดๆของคลาสสามารถที่จะมีค่าที่ส่งกลับมาได้ ซึ่ งชนิดข้อมูลของค่าที่จะ
ส่ งกลับอาจเป็ นชนิดข้อมูลแบบพื้นฐาน หรื อเป็ นชนิดข้อมูลแบบอ้างอิง
เมธอดที่มีค่าที่จะส่ งกลับมาจะต้องมีคาสั่ง return ซึ่ งจะระบุค่าที่ส่งกลับโดยมี
รู ปแบบดังนี้
return value;
คาสัง่ ที่เรี ยกใช้เมธอด อาจจะรับค่าที่ส่งกลับมาเก็บไว้ในตัวแปรหรื อเป็ นตัวถูก
ดาเนินการในนิพจน์ ตัวอย่างเช่น
double d = getGPA();
System.out.println("GPA:"+getGPA());
การประกาศเมธอด
class สี่ เหลี่ยม {
double คานวณพื้นที่() {
// คานวณหาพื้นที่ของสี่ เหลี่ยม
…
}
}
07/08/59
class Rectangle {
double getArea() {
....
}
}
38
เมธอดทีค่ ืนค่ าเป็ นชนิดข้ อมูลพืน้ ฐาน
class Rectangle {
class สี่ เหลี่ยม {
double width;
double คานวณพื้นที่() {
double height;
// คานวณหาพื้นที่ของสี่ เหลี่ยม
double getArea() {
…
return width * height;
// ส่ งคืนค่าพื้นที่ให้กบั ผูเ้ รี ยก
}
}
return พื้นที่ของสี่ เหลี่ยม;
}
}
07/08/59
39
เมธอดที่คืนค่ าเป็ นเรฟเฟอร์ เรนซ์
class สี่ เหลี่ยม {
String ขอข้อมูล() {
…
return สตริ งที่แสดงข้อมูลสี่ เหลี่ยม;
}
}
07/08/59
40
เมธอดที่ไม่ คืนค่ า
class สี่ เหลี่ยม {
void เพิ่มขนาดสองเท่า() {
…
return; // มีหรื อไม่มีกไ็ ด้
}
}
* สามารถใช้คาสัง่ return ในกรณี ที่ตอ้ งการออกจากเมธอดทันที โดยไม่
ต้องรอจนถึงคาสัง่ สุ ดท้ายในเมธอด
07/08/59
41
modifier ของเมธอด
modifier ของเมธอดประกอบด้วย
 access modifier
 static
 abstract
 synchronized
 final
access modifier ใช้เพื่อระบุระดับการเข้าถึง โดยมีคียเ์ วิร์ดต่าง ๆ ดังนี้
 public
 protected
 private
 default (ไม่ระบุคียเ์ วิร์ดใดๆ)
modifiers
ประกอบกับการประกาศแอททริ บิวต์หรื อเมธอด
private
 วัตถุต่างคลาสไม่สามารถเข้าใช้ได้
 การปกป้องข้อมูลทาได้
 มักจะให้แอททริ บิวท์มีการเข้าใช้แบบ private
public
 อนุญาตให้คลาสอื่นใช้ได้
 มักจะให้เมธอดมีการเข้าใช้แบบ public
07/08/59
43
คาประกอบการเข้ าใช้
class Rectangle {
public Rectangle (double w,double h) {
width = w;
height = h;
}
public double getArea() {
เมธอดทีม่ ีการเข้ าใช้ แบบ
สาธารณะ(public)
return width * height;
}
private double width;
private double height;
แอทริบิวต์ ทมี่ ีการเข้ าใช้
แบบส่ วนตัว(private)
}
07/08/59
44
ทดลองเข้ าใช้ แอททริบิวท์ ทถี่ ูกปกป้ อง
public class TestPrivate {
public static void main( String[] args) {
Rectangle rect = new Rectangle();
rect.width = 10;
}
ต้ องการเปลีย่ นแปลงแอตทริบิวต์ ที่
}
เป็ นส่ วนตัวของคลาส Rectangle
07/08/59
45
ทดลองเข้ าใช้ แอททริบิวท์ ทถี่ ูกปกป้ อง
07/08/59
46
ทาไมเราควรกาหนดการปกป้องแอททริบิวท์
ความเป็ นส่ วนตัวสามารถป้องกันวัตถุอื่นๆเข้ามาทาลายคุณสมบัติ
บางอย่าง
 เลขบัญชีธนาคารติดลบแทนที่จะเป็ นเลขศูนย์หรื อเลขบวก
 ความกว้างและความสู งของสี่ เหลี่ยมน้อยกว่าหรื อเท่ากับศูนย์
ทาให้เราสามารถเปลี่ยนแปลงชนิดของตัวแปรเหล่านั้นได้ โดยไม่
กระทบกระเทือนคลาสอื่นที่ใช้คลาสของเรา
ทาให้โปรแกรมที่เขียนด้วยภาษาเชิงวัตถุมีโอกาสผิดพลาดน้อยลง
07/08/59
47
การซ่ อนวิธีการทางาน (Information
hiding)
สามารถเปลี่ยนแปลงวิธีการทางานของวัตถุได้โดยไม่กระทบต่อผูใ้ ช้
วัตถุ
เกิดความยืดหยุน่
 เช่น ถ้าเปรี ยบวัตถุเหมือนกับรถ และผูใ้ ช้วตั ถุคือคนขับรถ
บริ ษทั ผูผ้ ลิตรถสามารถเปลี่ยนเครื่ องยนต์รุ่นใหม่ เปลี่ยนระบบเบรค
ฯลฯ โดยที่คนขับยังสามารถขับรถได้เหมือนเดิม
07/08/59
48
การเข้ าใช้ แบบอื่นๆ
protected
 เกี่ยวข้องกับการสื บทอด
 กล่าวถึงในบทที่ 11
การเข้าใช้แบบแพ็คเกจ (package)
 แพ็คเกจเป็ นที่เก็บรวมรวมคลาสที่เกี่ยวข้องกัน
 แพ็คเกจเปรี ยบได้กบั โฟลเดอร์
 การเข้าใช้แบบแพ็คเกจไม่ตอ้ งใช้คาประกอบใดๆ
07/08/59
49
การเข้ าใช้ แบบอื่นๆ
private
package
protected
เข้มงวดที่สุด
07/08/59
public
อิสระที่สุด
50
ตัวอย่ างโปรแกรมทีแ่ สดงการประกาศเมธอดและคุณลักษณะ
public class PrivateStudent {
private String id;
private String name;
private double gpa;
public void setDetails(String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
public void showDetails() {
System.out.println("ID: "+id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}
ตัวอย่ างโปรแกรมทีแ่ สดงการประกาศเมธอดและคุณลักษณะ
public class TestPrivateStudent {
public static void main(String args[]) {
PrivateStudent ps = new PrivateStudent();
/*
ps.id = "12345";
illegal
ps.name = "Thana";
illegal
ps.gpa = 3.25;
illegal */
ps.setDetails("12345","Thana",3.25);
ps.showDetails();
}
}
เมธอดแบบ static
เมธอดโดยทัว่ ไปจะมี modifier เป็ นแบบ non-static
เมธอดที่มี modifier เป็ นแบบ static จะสามารถถูกเรี ยกใช้งาน โดยใช้ชื่อคลาส
ได้เลยไม่จาเป็ นต้องสร้างออปเจ็กของคลาสนั้นขึ้นมาก่อน ซึ่งมีรูปแบบดังนี้
className.methodName();
ตัวอย่างเช่น เมธอดทุกเมธอดในคลาส Math เป็ นแบบ static ดังนั้นการเรี ยกใช้
งานทุกเมธอดในคลาสสามารถทาได้ เช่น
Math.sqrt(4);
เมธอดแบบ static จะไม่สามารถเรี ยกใช้เมธอดหรื อตัวแปรของออปเจ็คได้
โดยตรง
คุณลักษณะแบบ static
ตัวแปรคลาสที่มี modifier เป็ นแบบ static จะเป็ นตัวแปรของ
คลาสที่ใช้ร่วมกันสาหรับทุกออปเจ็ค
ตัวแปรที่มี modifier เป็ นแบบ static จะสามารถถูกเรี ยกใช้งาน
โดยใช้ชื่อคลาสได้เลย ไม่จาเป็ นต้องสร้างออปเจ็กของคลาส
ขึ้นมาก่อน เช่นเดียวกันกับเมธอดที่มี modifier เป็ นแบบ static
ตัวอย่ างโปรแกรม
public class StaticDemo {
static int x;
int y;
public static void main(String args[]) {
StaticDemo s1 = new StaticDemo();
StaticDemo s2 = new StaticDemo();
s1.x = 3; s2.x = 5;
s1.y = 3; s2.y = 5;
System.out.println("s1.x="+s1.x+" s2.x="+s2.x);
System.out.println("s1.y="+s1.y+" s2.y="+s2.y);
StaticDemo.x++;
System.out.println("s1.x="+s1.x+" s2.x="+s2.x);
}
}
ผลลัพธ์ที่ได้จากการรันโปรแกรม
s1.x=5 s2.x=5
s1.y=3 s2.y=5
s1.x=6 s2.x=6
สแตติกเมธอด (static method)
เมธอดของคลาส สามารถเรี ยกใช้ได้เลยโดยไม่จาเป็ นต้องสร้างวัตถุ
ขึ้นมาก่อน
รู ปแบบการประกาศ
 public static ชนิดข้ อมูลที่ส่งกลับ เมธอด(พารามิเตอร์ ) { … }
ตัวอย่างการเรี ยกใช้ที่เราคุน้ เคยกันดี
public static void main( String[] args)
07/08/59
56
สแตติกเมธอด (static method)
รู ปแบบการเรี ยกใช้
 คลาส.สแตติกเมธอด(พารามิเตอร์ )
ตัวอย่างการเรี ยกใช้
 int m = Math.round(12.5);
 int n = String.valueOf(1234);
07/08/59
57
ตัวแปรของคลาส
ถ้าจะนับว่าเราสร้างวัตถุมากี่จานวนแล้ว เราไม่สามารถใช้ตวั แปรวัตถุ
นับจานวนวัตถุได้ ทางแก้คือ ต้องสร้างตัวแปรที่วตั ถุทกุ ตัวในคลาส
สร้างร่ วมกันได้ เรี ยกว่า “ตัวแปรของคลาส”
รู ปแบบ
 private static ชนิดข้ อมูล ตัวแปร;
ตัวอย่าง
 private static int count;
07/08/59
58
 class Rectangle {

private static int counter = 0;

counter เป็ นตัวแปรคลาส ค่า
เริ่มต้ น = 0
public static int getCounter() {
return counter; }





public Rectangle() {
counter++;
width = 7;
height = 3;
}

public Rectangle(double w,double h) {

if( w <= 0 || h <= 0)

throw new IllegalArgumentException();

counter++;

width = w;

height = h;
 07/08/59
}
59
นับทุกครั้งทีว่ ตั ถุถูกสร้ าง
ถ้าต้องการพิมพ์จานวนสี่ เหลี่ยมทั้งหมดที่เคยสร้างมาสามารถเขียนได้เป็ น
System.out.println(Rectangle.getCounter());
07/08/59
60
Constructor
constructor เป็ นเมธอดที่มีชื่อเดียวกับชื่อคลาส ซึ่ งมีรูปแบบดังนี้
[modifier] ClassName([arguments]) {
[statements]
}
constructor เป็ นเมธอดที่ไม่มีค่าที่จะส่ งกลับแต่ไม่ตอ้ งระบุคียเ์ วิร์ด void
โดยทัว่ ไปคลาสทุกคลาสจะมี default constructor ซึ่ งมีรูปแบบดังนี้
public ClassName() {
}
เราสามารถที่จะเขียน constructor ในคลาสใดๆขึ้นมาก็ได้
default constructor จะหายไปเมื่อมีการเขียน constructor ขึ้นใหม่
คอนสตรัคเตอร์ (constructor)
เมธอดที่มีชื่อเหมือนกับคลาส
ใช้กาหนดค่ าเริ่มต้ นให้กบั แอททริ บิวต์
ถูกเรี ยกใช้เมื่อเราสร้างวัตถุดว้ ยคาสัง่ new
สี่ เหลี่ยม ก = new สี่ เหลี่ยม();
สี่ เหลี่ยม ข = new สี่ เหลี่ยม(10,7);
สี่ เหลี่ยม ค = new สี่ เหลี่ยม(5,11);
07/08/59
62
การประกาศคอนสตรัคเตอร์
class สี่ เหลี่ยม {
double ความกว้าง;
double ความสู ง;
สี่ เหลี่ยม(){
ความกว้าง=7;
ความสู ง=3;
}
สี่ เหลี่ยม(double ก, double ส) {
ความกว้าง = ก;
ความสู ง = ส;
}
}
คอนสตรัคเตอร์ ที่กาหนดค่าความกว้างและ
ความสู งเป็ น 7 และ 3 หน่วยตามลาดับ
คอนสตรัคเตอร์ ที่กาหนดค่าความกว้าง
และความสู งตามความต้องการผูใ้ ช้
ตัวอย่ างโปรแกรมแสดงการเรียกใช้ constructor
public class Student {
private String id;
private String name;
public Student(String ID,String n) {
id = ID;
name = n;
}
}
public class TestConstructor {
public static void main(String args[]) {
Student s = new Student();
//illegal
Student s = new Student("1122","Somchai");
}
}
คาสั่ ง new()
มีข้นั ตอนการทางานดังนี้
 กาหนดเนื้อที่ในหน่วยความจาให้กบั ออปเจ็ค
 กาหนดค่าเริ่ มต้นให้กบั คุณลักษณะของออปเจ็ค
 กาหนดค่าของคุณลักษณะของออปเจ็คตามคาสั่งกาหนดค่าที่
ประกาศไว้
 เรี ยกใช้ constructor
คาสั่ ง new()
ตัวอย่างเช่น
public class MyDate {
private int day = 1;
private int month = 1;
private int year = 2000;
public MyDate(int d,int m,int y) {
day = d;
month = m;
year = y;
}
}
รูปแสดงตัวอย่ างการทางานขั้นตอนคาสั่ ง new
คาสัง่
MyDate d1 = new MyDate(16,8,1972);
ขันตอนที
้
ห่ นึ่ง
ขัน้ ตอนทีส่ อง
การโอเวอร์ โหลดคอนสตรัคเตอร์
class สี่ เหลี่ยม {
{
สี่ เหลีย่ ม() { ... }
สี่ เหลีย่ ม(double ก, double ส) { ... }
}
07/08/59
68
คอนสตรัคเตอร์เป็ นเมธอด
ชนิดหนึ่ง ภาษาจาวาอนุญาตให้
ในคลาสเดียวกันมีเมธอด ชื่อช้ า
กันได้ แต่ตอ้ งรับพารามิเตอร์ที่
ต่างกัน
เมธอดที่มีชื่อเหมือนกันแต่รับ
ชนิดหรื อจานวนพารามิเตอร์ที่
แตกต่างกัน เรี ยกว่า “โอเวอร์
โหลดเมธอด” (Overloaded
methods)
Constructor แบบ Overloaded
เราสามารถที่จะสร้าง constructor แบบ overloaded ของคลาสได้
constructor แบบ overloaded จะมีจานวนหรื อชนิดข้อมูลที่แตกต่างกันของ
arguments
คาสั่ง new ที่ใช้ในการสร้างออปเจ็คจะเรี ยกใช้ constructor ที่มี argument ที่ส่งผ่าน
มาสอดคล้องกับ constructor ที่กาหนด
ข้อดีของการสร้าง constructor แบบ overloaded คือทาให้เราสามารถที่สร้างออป
เจ็คเริ่ มต้นได้หลายรู ปแบบ
เมธอดที่ชื่อ this() เป็ นการเรี ยกใช้ constructor ของคลาสตัวเอง โดยจะต้องเป็ น
คาสั่งแรกสุ ดที่อยูใ่ น constructor แบบ overloaded
ตัวอย่ างโปรแกรมแสดง constructor แบบ overloaded
public class Student {
private String id;
private String name;
private double gpa;
public Student(String ID,String n) {
id = ID;
name = n;
}
public Student(String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
}
ตัวอย่ างโปรแกรมแสดงการใช้ คาสั่ ง this()
public class Student {
private String id;
private String name;
private double gpa;
public Student(String ID,String n) {
id = ID;
name = n;
}
public Student(String ID,String n,double GPA) {
this(ID,n);
gpa = GPA;
}
}
เมธอดแบบ Overloaded
ภาษาจาวาอนุญาตให้คลาสใดๆมีเมธอดที่มีชื่อเดียวกันมากกว่าหนึ่งเมธอดได้
แต่เมธอดเหล่านั้นจะต้องมีจานวนหรื อชนิดข้อมูลของ argument ที่ต่างกัน
ตัวอย่างต่อไปนี้เป็ นการเขียนเมธอดแบบ overloaded ที่ถูกต้อง
public void setDetails(String ID, String n) {
}
public void setDetails(String ID, double GPA) {
}
public double setDetails(double GPA, String n) {
}
เมธอดแบบ Overloaded
ตัวอย่างต่อไปนี้เป็ นการเขียนเมธอดแบบ overloaded ที่ไม่
ถูกต้อง
public void setDetails(String ID,double GPA) {
}
public void setDetails(String n,double GPA) {
}
ตัวอย่ างโปรแกรม
public class StudentV2 {
private String id;
private String name;
private double gpa;
public void setDetails(String ID,String n) {
id = ID;
name = n;
}
public void setDetails(String ID,String n,double GPA) {
id = ID;
name = n;
gpa = GPA;
}
}
การโอเวอร์ โหลดเมธอด
class Rectangle {
Rectangle(){…}
Rectangle(double w, double h){
width = w;
height = h;
}
double getArea() { ... }
int getArea(int n) { ... }
}
75
constructor
Method
คีย์เวิร์ด this
คียเวิร์ด this หมายถึงออปเจ็คของตัวเอง
เราสามารถที่จะเรี ยกใช้เมธอดหรื อคุณลักษณะภายในคลาสได้
โดยใช้คียเ์ วิร์ด this ซึ่งมีรูปแบบ ดังนี้
this.methodName();
this.attributeName
โดยทัว่ ไปเราจะไม่ใช้คียเ์ วิร์ด this ในคาสัง่ ยกเว้นในกรณี ที่จาเป็ น
ตัวอย่ างโปรแกรม
public class ThisStudent {
private String id;
private String name;
private double gpa;
public void setDetails(String id,String name, double gpa) {
this.id = id;
this.name = name;
this.gpa = gpa;
}
public void showDetails() {
System.out.println("ID: "+this.id);
System.out.println("Name: "+name);
System.out.println("GPA: "+gpa);
}
}
ค่ าคงทีข่ องคลาส
รู ปแบบ
 public static final ชนิดข้ อมูล ตัวแปร=ค่ า;
ตัวอย่าง
 public static final int TOTAL_SIDES = 4;
07/08/59
78
ประกาศคลาส
class สี่ เหลีย่ ม {
class Rectangle {
}
}
07/08/59
79
เพิม่ แอททริบิวท์
class สี่ เหลี่ยม {
double ความกว้าง;
double ความสู ง;
}
07/08/59
class Rectangle {
double width;
double height;
}
80
เพิม่ เมธอด
class สี่ เหลี่ยม {
double ความกว้าง;
double ความสู ง;
double คานวณพื้นที่() {
....
}
}
07/08/59
class Rectangle {
double width;
double height;
double getArea() {
....
}
}
81
เขียนวิธีการทางานของเมธอด คานวณพืน้ ที่()
class สี่ เหลี่ยม {
double ความกว้าง;
double ความสู ง;
double คานวณพื้นที่() {
class Rectangle {
double width;
double height;
double getArea() {
return ความกว้าง * ความสูง;
return width * height;
}
}
07/08/59
}
}
82
เขียนคอนสตรัคเตอร์
class สี่ เหลี่ยม {
double ความกว้าง;
double ความสูง;
class Rectangle {
double width;
double height;
สี่ เหลี่ยม(double ก, double ส) {
ความกว้ าง = ก;
ความสูง = ส;
}
double คานวณพื้นที่() {
Rectangle(double w,double h) {
width = w;
height = h;
}
double getArea() {
return ความกว้าง * ความสู ง;
return width * height;
}
}
}
}
07/08/59
83
ทดสอบคลาส Rectangle
class TestRectangle {
public static void main(String[] args) {
Rectangle r = new Rectangle(2, 3);
System.out.println(r.getArea());
Rectangle p = new Rectangle(5, 7);
System.out.println(p.getArea());
}
}
07/08/59
84
สร้ างวัตถุสี่เหลีย่ ม R ขึน้
คอมไพล์และรัน
07/08/59
85
เมธอด toString()
เมธอด toString () เป็ นเมธอดที่ช่วยในการพิมพ์แอทริ บิวต์
ของวัตถุ เมธอดนี้จะส่ งสตริ งกลับมาเพื่อที่เราสามารถนามา
พิมพ์ออกไปที่จอภาพได้ดว้ ยคาสัง่
System.out.println( rect.toString() );
หรื อ
System.out.println( rect );
07/08/59
86
เมธอด toString()
 เมธอด toString() ของคลาส Rectangle เขียนได้ดงั นี้
class Rectangle {
public String toString() {
String result = “Width = “ + width;
result += “Height = “+ height;
return result;
// return "Width = " + width + " Height = " + height;
}
}
07/08/59
87
เมธอด toString()
class Rectangle {
double width;
double height;
Rectangle(){
width = 7;
height = 3;
}
Rectangle(double w, double h){
width = w;
height = h;
}
public String toString() {
String result = "Width = " + width;
result += "Height = "+ height;
return result;
// return "Width = " + width + " Height = " + height;
}
double getArea(){
return width * height;
}
}
TestToString
class TestToString
{
public static void main(String[] args)
{
Rectangle rect = new Rectangle(10,5);
System.out.println(rect);
System.out.println("Area = " + rect.getArea());
}
}
เมธอด equals()
เปรี ยบเทียบแอททริ บิวท์
ไม่ใช้เครื่ องหมาย == เพื่อเปรี ยบเทียบวัตถุ
class Rectangle {
public boolean equals(Rectangle other) {
return (width == other.width) && (height == other.height);
}
...
}
07/08/59
90
เมธอด equals()
class TestEquals{
public static void main(String[] arg){
Rectangle a = new Rectangle(10,5);
Rectangle a = new Rectangle(5,10);
Rectangle a = new Rectangle(10,5);
if(a.equals(b))
System.out.println(“Rectangle a is equal to b”);
else
System.out.println(“Rectangle a is not equal to b”);
if(a.equals(c))
System.out.println(“Rectangle a is equal to c”);
else
System.out.println(“Rectangle a is not equal to c”);
}
91
}
สรุปเนื้อหาของบท
คลาสจะประกอบไปด้วยคุณลักษณะและเมธอด
การเขียนโปรแกรมเชิงออปเจ็คเป็ นการแบ่งโปรแกรมออกเป็ นโมดูลย่อยๆ
ทาให้สามารถปรับเปลี่ยนแก้ไขโปรแกรมได้ง่ายขึ้น
เมธอดที่กาหนดขึ้นในคลาสใดๆสามารถเรี ยกใช้งานได้สองรู ปแบบคือ การ
เรี ยกใช้งานจากคลาสที่ต่างกัน และการเรี ยกใช้งานภายในคลาสเดียวกัน
เมธอดที่กาหนดขึ้นในคลาสอาจมี argument ที่รับค่าเพื่อนาไปใช้ในเมธอด
เมธอดใดๆของคลาสสามารถที่จะมีค่าที่ส่งกลับมาได้ ทั้งนี้การประกาศ
เมธอดจะต้องระบุชนิดข้อมูลของค่าที่จะส่ งกลับ
เมธอดสามารถแบ่งเป็ นเมธอดของออปเจ็ค (หรื อเรี ยกว่าเมธอดแบบ nonstatic) และเมธอดของคลาส (หรื อเรี ยกว่าเมธอดแบบ static)
สรุปเนื้อหาของบท
เมธอดของคลาสใดที่มี modifier เป็ นแบบ static จะทาให้สามารถ
ถูกเรี ยกใช้งาน โดยใช้ชื่อของคลาสนั้นได้เลย
เมธอดแบบ overloaded คือ มีเมธอดที่มีชื่อเดียวกันแต่จะมีจานวน
หรื อชนิดข้อมูลของ argument ที่ต่างกัน
โดยทัว่ ไป คุณลักษณะของคลาสจะมี modifier เป็ นแบบ private
ทั้งนี้เพื่อป้องกันการเข้าถึงจากคลาสอื่น
โดยทัว่ ไป เมธอดของคลาสจะมี modifier เป็ นแบบ public ทั้งนี้
เพื่อให้ เมธอดจากคลาสอื่นเรี ยกใช้ได้
สรุปเนื้อหาของบท
ชื่อของเมธอดที่เกี่ยวข้องกับคุณลักษณะของคลาส นิยมใช้ setXxx สาหรับ
เมธอดที่มีไว้เพื่อกาหนดค่าให้กบั คุณลักษณะ xxx และใช้ getXxx สาหรับ
เมธอดที่จะส่ งค่ากลับเป็ นคุณลักษณะ xxx
Constructor หมายถึง เมธอดที่มีชื่อเดียวกันกับชื่อคลาส แต่จะไม่มีการส่ ง
ค่ากลับและจะไม่มีการใส่ คียเ์ วิร์ด void โดยคลาสทุกคลาสจะมี default
constructor มาให้อยูแ่ ล้ว แต่เราสามารถที่จะกาหนด constructor ขึ้นใหม่
เองได้
เมธอดที่ชื่อ this() เป็ นการเรี ยกใช้ constructor ของคลาสตัวเอง
แบบทดสอบ
public class NumericalClass {
public void calculate() {
double score = Math.random()*100;
if (score >= 80) {
System.out.println("Grade is A");
} else if (score >= 70) {
System.out.println("Grade is B");
} else if (score >= 60){
System.out.println("Grade is C");
} else if (score >= 50){
System.out.println("Grade is D");
} else {
System.out.println("Grade is F");
}
}
}
public class MyMain {
public static void main(String args[]) {
NumericalClass obj = new NumericalClass();
obj.calculate();
}
}
ปรับให้ method
calculate สามารถ
รับ arguments
score เพื่อนาไป
ประมวลผลได้
ต่อไป
LOGO
07/08/59
96