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