Embedded Files
ภาษาจาวา (Java Language) คือ ภาษาคอมพิวเตอร์ที่ถูกพัฒนาขึ้นโดยบริษัท ซันไมโครซิสเต็มส์ เป็นภาษาสำหรับเขียนโปรแกรมที่สนับสนุนการเขียนโปรแกรมเชิงวัตถุ (OOP : Object-Oriented Programming) โปรแกรมที่เขียนขึ้นถูกสร้างภายในคลาส ดังนั้นคลาส (Class) คือที่เก็บเมทธอด (Method) หรือพฤติกรรม (Behavior) ซึ่งมีสถานะ (State) และรูปพรรณ (Identity) ประจำพฤติกรรม
ภาษาจาวา(Java Language) คือ ภาษาที่ถูกพัฒนาขึ้นโดยบริษัท ซันไมโครซิสเต็มส์ (Sun Microsystems Inc.) เป็นภาษาสำหรับเขียนโปรแกรมภาษาหนึ่ง มีลักษณะสนับสนุนการเขียนโปรแกรมเชิงวัตถุ (OOP : Object-Oriented Programming) ที่ชัดเจน โปรแกรมต่าง ๆ ถูกสร้างภายใน class โปรแกรมเหล่านั้นถูกเรียกว่า method หรือ behavior โดยปกติจะเรียกแต่ละคลาสว่าวัตถุ โดยแต่ละวัตถุมีพฤติกรรมมากมาย โปรแกรมที่สมบูรณ์จะเกิดจากหลายวัตถุ หรือหลายคลาสมารวมกัน โดยแต่ละคลาสจะมีเมทธอด หรือพฤติกรรมแตกต่างกันไป
ชื่อโปรแกรมที่เกี่ยวกับภาษาจาวา
J2SE : Java 2 Platform, Standard Edition (Core/Desktop)
J2EE : Java 2 Platform, Enterprise Edition (Enterprise/Server)
J2ME : Java 2 Platform, Micro Edition (Mobile/Wireless)
การเขียนโปรแกรมเชิงวัตถุ (OOP = Object-Oriented Programming)
การเขียนโปรแกรมที่ประกอบด้วยกลุ่มของวัตถุ (Objects) แต่ละวัตถุจะจัดเป็นกลุ่มในรูปของ Class ซึ่งแต่ละ Class อาจมีคุณสมบัติ การปกป้อง (Encapsulation) การสืบทอด (Inheritance) การพ้องรูป (Polymorphism) หรือ การเรียกเกินกำลัง (Overloading) โดยถือว่า Class คือ ต้นแบบของวัตถุ
แนวคิดของการโปรแกรมเชิงวัตถุ (OOP Concepts)
1) การปกป้อง (Encapsulation) คือ การรวมกลุ่มของข้อมูล และกลุ่มของเพื่อการปกป้อง และเลือกตอบสนอง 2) การสืบทอด (Inheritance) คือ การยอมให้นำไปใช้ หรือเขียนขึ้นมาทดแทนของเดิม 3) การพ้องรูป (Polymorphism) มาจากภาษากรีก หมายถึง หลายรูป (Many Shapes) ซึ่งมี 2 หลักการที่สำคัญคือ โอเวอร์โหลดดิ้ง (Overloading) มีชื่อโปรแกรมเดียวกัน แต่รายการตัวแปร (Parameter List) ต่างกัน และโอเวอร์ไรดิ้ง (Overriding) มีชื่อและตัวแปรเหมือนกัน เพื่อเขียนพฤติกรรม (Behavior) ขึ้นมาใหม่
1.1 ตัวแปลภาษา การแปล และการประมวลผล
1.1 ตัวแปลภาษา การแปล และการประมวลผล
ภาษาจาวาถูกออกแบบให้มีความสามารถทำงานได้ในระบบปฏิบัติการที่หลากหลาย โดยติดตั้งส่วนรับการประมวลผลเพิ่มเติมที่ชื่อว่า จาวาเวอร์ชวลแมชชีน (Java Virtual Machine) และมีวิธีพัฒนาโปรแกรมตอบสนองการเข้าใช้งานของผู้ใช้ได้อย่างหลากหลายวิธี เช่น โปรแกรมประยุกต์ (Application) แอพเพลท (Applet) เซิร์ฟเรต (Servlet) เจเอสพี (JSP = Java Server Page) แพ็คเกจ (Package) จาร์ (Jar) เป็นต้น
ตัวแปลภาษา (Compiler)
For version 1.4 DOS> cd c:\j2sdk1.4.1_01\bin
For version 5.0 DOS> cd c:\sun\sdk\jdk\bin
การแปลภาษา (Compiling)
DOS> javac x.java
การประมวลผล (Execution)
DOS> java x
นามสกุลของแฟ้มเกี่ยวกับภาษาจาวา
.java คือ แฟ้มรหัสต้นฉบับ (Source Code) เมื่อผ่านการแปล (Compile) จะได้แฟ้ม .class
.class คือ แฟ้มที่ได้หลังจากแปล เป็นแบบ Bytecode ทำงานได้บน JVM
.jsp คือ แฟ้มเก็บรหัสต้นฉบับที่ใช้ผ่านเครื่องบริการเว็บ จะแปลเมื่อถูกเรียกใช้
.jar คือ แฟ้มที่รวมแฟ้ม .class หรือแฟ้มที่จำเป็น เพื่อให้เรียกใช้โดยสะดวก
คำแนะนำในการเริ่มต้นเขียนโปรแกรม
1. เลือกภาษา สำหรับนักเรียน นักศึกษานั้นง่ายที่จะเลือก เพราะอาจารย์คอยชี้แนะ
2. หาแหล่งข้อมูลอ้างอิงจากห้องสมุด ถ้าท่านไม่มีอะไรอยู่ในมือเลย คงนึกโครงสร้างภาษาไม่ออกเป็นแน่
3. หาตัวแปลภาษา ทุกภาษาต้องมีตัวแปลภาษา มีหลายภาษาที่ถูกสร้างเป็น Free compiler ต้องหาดู
4. เขียนโปรแกรมตัวแรกที่ง่าย เช่น พิมพ์เลข 5 เป็นต้น
5. ศึกษาการทำซ้ำ และการเลือกตามเงื่อนไข เช่นพิมพ์สูตรคูณ หรือพิมพ์ 1 ถึง 10 เป็นต้น
6. ติดต่อแฟ้มข้อมูล เพื่ออ่านมาแสดงผล หรือปรับปรุงข้อมูลได้
7. เขียนเมนู เพื่อเลือกกระทำโปรแกรมตามตัวเลือก
8. ทำรายงานจากการเชื่อมแฟ้มหลายแฟ้ม โดยกำหนดได้หลายตัวเลือก
9. เขียนโปรแกรมเพิ่มข้อมูล เช่น ซื้อ ขาย ยืม คืน หรือโปรแกรมลงทะเบียนนักศึกษาแต่ละภาคเรียนเป็นต้น
10. สร้างโปรแกรมขึ้นมาระบบหนึ่งให้สมบูรณ์ (ความสมบูรณ์ก็คือการสนองทุกความต้องการของผู้ใช้)
ตัวอย่าง 1.1 แสดงตัวเลขผ่านเมธอด main
class x {
public static void main(String arg[]) {
System.out.println(5);
}
}
ตัวอย่าง 1.2 สร้างสแตติก อินสแตนท์ และเมธอด
class x {
static int a = 5;
public static void main(String arg[]) {
a++;
printMe(); // 6
x b = new x();
b.helpMe(); // 7
b.printMe(); // 6
b.a++;
x c = new x();
c.a++;
System.out.println(a); // 8
}
static void printMe() { System.out.println(6); }
void helpMe() { System.out.println(7); }
}
1.2 ประเภทของข้อมูล (Data Types)
1.2 ประเภทของข้อมูล (Data Types)
ประเภทของข้อมูลแบบดั้งเดิม (Primitive Data Type) และแบบวัตถุ (Object Type) สำหรับแบบ Primitive Data Type นั้นมีอยู่ 8 แบบคือ char, boolean, byte, short, int, long, float และ double
1. boolean : A value indicating true or false.
2. char : A single Unicode character (16-bit unsigned)
3. byte : An 8-bit integer (signed).
4. short : A 16-bit integer (signed).
5. int : A 32-bit integer (signed).
6. long : A 64-bit integer (signed).
7. float : A 32-bit floating-point number (signed).
8. double : A 64-bit floating-point number (signed).
วิธีประกาศตัวแปรแบบ Object Type และแบบ Primitive Data Type
กรณีที่ 1 Integer s1 = new Integer(1); ใช้พื้นที่ 16 Bytes
กรณีที่ 2 Integer s2 = new Integer(1); ถ้าประกาศทั้ง s1 และ s2 ใช้พื้นที่ 32 Bytes
กรณีที่ 3 int s3 = 5; ไม่พบว่าใช้หน่วยความจำเมื่อตรวจด้วย freeMemory()
กรณีที่ 4 String s4 = “a”; ไม่พบว่าใช้หน่วยความจำเมื่อตรวจด้วย freeMemory()
ตัวอย่าง 1.3 การคำนวณและแคสติ้ง (Casting)
int x;
x = 8/3;
System.out.println(x); // 2
float a = 5/(float)3; // 1.6666666
float b = (float)5/3; // 1.6666666 มี 7 หลัก
double c = 5/(double)3; // 1.6666666666666667 มี 16 หลัก
float d = (float)(5/3); // 1.0
float e = 5/3; // 1.0
1.4 การแปลงประเภทข้อมูล (Data Conversion)
1.4 การแปลงประเภทข้อมูล (Data Conversion)
ตัวแปร (Variable) หรือวัตถุ (Object) ที่มีความสามารถในการเก็บข้อมูล (Data) มีรูปแบบอย่างใดอย่างหนึ่ง เช่น เป็นตัวเลข หรือตัวอักษร เมื่อมีการกำหนดค่าข้อมูลให้กับตัวแปร ย่อมต้องส่งค่าและประเภทที่ถูกต้องเข้าไปยังตัวแปรให้ถูกต้อง ถ้าส่งผิดประเภทย่อมเกิดข้อผิดพลาดขึ้นได้
การส่งข้อมูลผิดประเภทเข้าไปอาจเกิดขึ้นได้ในกรณีที่วางแผนไว้ล่วงหน้า ซึ่งภาษาจาวาเตรียมวิธีการส่งข้อมูลต่างประเภทกันเข้าไปในตัวแปร หรือวัตถุที่ต้องการได้ เช่น แปลงข้อมูลจากตัวอักษรเป็นตัวเลข แล้วส่งเข้าตัวแปร หรือวัตถุเป้าหมาย
บางครั้งมีข้อมูลแบบตัวอักษร หากต้องการแปลงเป็นตัวเลขเพื่อนำไปประมวลผล ก็ต้องใช้คลาส และเมธอดที่ตัวแปลภาษามีให้ เช่น Byte.parseByte( ) ซึ่งรับตัวอักษร แล้วคืนค่ากลับมาเป็นตัวเลข
String a = “5”;
String b = “6”;
System.out.println(Byte.parseByte(a) + Byte.parseByte(b));
ตัวอย่าง 1.7 การแปลงข้อมูลให้เป็นแบบไบท์
- คำถาม : ถ้ามี String 2 ตัวแปร ให้นำมาหาผลรวม ต้องทำอย่างไร
int a = 260;
byte b = (byte)a; // ค่าของ b คือ 4 = 1 0000 0100
byte c = (byte)260; // ค่าของ c คือ 4 = 1 0000 0100
byte d = Byte.parseByte("10"); // ค่าของ d คือ 10
byte e = Byte.valueOf("5").byteValue(); // ค่าของ e คือ 5
byte f = (byte)129; // ค่าของ f คือ -127
129 = 1000 0001
0111 1110 = 112 + 14 = - 126 – 1 = -127
128 64 32 16 8 4 2 1
1.5 กฏของการโปรแกรมเชิงวัตถุ (Object Oriented Programming Rule)
1.5 กฏของการโปรแกรมเชิงวัตถุ (Object Oriented Programming Rule)
กฏของโอโอพี (OOP = Object Oriented Programming) ถูกนำเสนอครั้งแรกโดย อาลัน เคร์(Alan Kay) เป็นผู้บุกเบิกแนวความคิดการเขียนโปรแกรมเชิงวัตถุคนหนึ่ง และมีส่วนพัฒนาภาษา Small Talk ได้เสนอกฎ 5 ข้อของ OOP ไว้ดังนี้ 1. ทุกสิ่งเป็นวัตถุ (Everything is an object) 2. โปรแกรมคือกลุ่มของวัตถุที่ส่งข่าวสารบอกกันและกันให้ทำงาน (A program is a bunch(พวง) of objects telling each other what to do by sending messages) 3. แต่ละวัตถุต้องมีหน่วยความจำ และประกอบด้วยวัตถุอื่น (Each object has its own memory made up of other objects) 4. วัตถุต้องจัดอยู่ในประเภทใดประเภทหนึ่ง (Every object has a type) 5. วัตถุประเภทเดียวกันย่อมได้รับข่าวสารเหมือนกัน (All objects of a particular type can receive the same messages)
1.6 คำสงวน (JAVA Keywords)
1.6 คำสงวน (JAVA Keywords)
คำสงวน (Keywords or Reserved Word) คือ คำที่ถูกสงวน หรือสำรองไว้โดยตัวแปลภาษา ที่ผู้พัฒนาไม่สามารถนำมาใช้เป็นชื่อตัวแปร ชื่อเมธอด หรือชื่อคลาส เพราะคำสงวนจะมีหน้าที่ของตนเอง ในการควบคุมโครงสร้างของโปรแกรม (Structure) เป็นชนิดของข้อมูล (Data Type) หรือคำขยายแบบของข้อมูล (Modifier) ดังนั้นตัวแปลภาษาจะประกาศคำที่ถูกสงวนไว้ล่วงหน้า มิให้ผู้พัฒนานำไปใช้ และเกิดความสับสนในการพัฒนาโปรแกรม
คำสงวน 49 คำ ประกอบด้วย abstract, assert, boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, extends, final, finally, float, for, goto, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while
1.7 สแตติก (Static) และอินสแตนท์ (Instance)
1.7 สแตติก (Static) และอินสแตนท์ (Instance)
สแตติก (Static) คือ คำขยาย (Modifier) ของเมทธอด (Method) หรือคลาส (Class) ทำให้นำเข้าหน่วยความจำทันทีเมื่อคลาสถูกประมวลผล ทำให้เมทธอดหรือคลาสเข้าไปอยู่ในหน่วยความจำ และถูกเรียกใช้โดยเมทธอดที่มีลักษณะเป็นสแตติกได้ทันที เช่น main ในการเขียนโปรแกรมที่ประมวลผลในคอนโซล (Console)
ดังนั้นเมทธอดในคลาสเดียวกันที่ไม่เป็นสแตติก จะไม่สามารถถูกเรียกใช้ผ่าน main ซึ่งเป็นสแตติกได้ การเรียกใช้วัตถุที่ไม่เป็นสแตติกต้องจองพื้นที่ในหน่วยความจำผ่านการนิว (New) จึงจะเรียกใช้วัตถุเหล่านั้นได้
อินสแตนท์ (Instance) คือ การสร้างการอ้างอิงในหน่วยความจำจากวัตถุที่ถูกอ้างอิงไว้ โดยปกติวัตถุจะถูกอ้างอิง (Reference) และเกิดอินสแตนท์ขึ้นในหน่วยความจำที่มาจากคลาสต้นแบบผ่านคอนสตักเตอร์
อินสแตนท์สามารถถูกสร้างได้ทั้งภายใต้คลาส และภายใต้เมทธอด
เช่น Plane b; // b ถูกอ้างอิง แต่ยังไม่เกิดอินสแตนท์
b = new b( ); // เกิดอินสแตนท์ขึ้นแล้ว
b.tax = 6; // ใช้งานอินสแตนท์จากคลาสต้นแบบ
System.out.println( b.caltax( 100 ) ); // ใช้งานอินสแตนท์จากคลาสต้นแบบ
ภายในอินสแตนท์ตัวหนึ่งมีสิ่งที่เรียกว่าตัวอ้างอิง (Reference) หมายถึง ตัวชี้ (Pointer) ที่ถูกเรียกในภาษาซี ถูกใช้สำหรับอ้างอิง (Reference) วัตถุที่อยู่ภายในสิ่งที่ถูกอ้างอิงมา
Stack
Heap
int a = 5
“aaa”
“jkl”
String s;
s = new String(“aaa”);
======>
int b;
b = 6;
String x = “jkl”;
String y = x;
x = null;
y = null;
======>
======>
วัตถุที่เป็นอินสแตนท์จะมีค่าจากเมทธอดชื่อ hashCode( ) ถูกใช้สำหรับอ้างอิง และนำไปเปรียบเทียบด้วยเมทธอดชื่อ equals( ) ได้
เช่น Human h ; h หมายถึง ตัวอ้างอิง (Reference) ของอินสแตนท์ (Instance)
h = new Human( ); บรรทัดนี้เป็นการสร้างอินสแตนท์ และเป็นการใช้หน่วยความจำ
String xx = "abc";
String yy = "abc";
System.out.println(xx.hashCode()); // 96354
System.out.println(yy.hashCode()); // 96354
System.out.println(xx.equals(yy)); //true
System.out.println("A".hashCode()); // 65 = 0100 0001
System.out.println("AA".hashCode());// 2080
System.out.println("AB".hashCode());// 2081
System.out.println("BA".hashCode());// 2111
อ้างอิงจาก http://www.webthaidd.com/java/webthaidd_article_260_2.html
อ้างอิงจาก http://www.cp.eng.chula.ac.th/~somchai/Java/info/toString-Why.html
1.8 ลักษณะของวัตถุ (Object Characteristic)
1.8 ลักษณะของวัตถุ (Object Characteristic)
ภาษาจาวามองทุกอย่างเป็นวัตถุ ซึ่งมีลักษณะร่วมที่คล้ายกัน 3 ประการ คือ พฤติกรรม (Behavior) ลักษณะจำเพาะ (Identity) และสถานะของลักษณะจำเพาะ (State) เช่น การวิ่งเป็นพฤติกรรม ระยะทางเป็นลักษณะจำเพาะ และ 20 เมตรเป็นสถานะของลักษณะจำเพาะ
โมเดลวัตถุ
(Object Model)
ทั่วไปหรือยูเอ็มแอล
(General, UML)
การโปรแกรมเชิงวัตถุ
(OOP)
การเขียนโปรแกรมในจาวา
(Coding in Java)
- Behavior
- Behavior/Action
- Method
- Method
- Identity
- Attribute
- Property
- Variable/Attribute
- State
- Value of Attribute
- Value of Property
- Value of Variable/Attribute
1.9 หน่วยความจำแบบสแตก และฮีป (Stack and Heap Memory)
1.9 หน่วยความจำแบบสแตก และฮีป (Stack and Heap Memory)
หน่วยความจำที่ภาษาจาวาเข้าไปใช้งานแบ่งได้ 2 ประเภทคือ หน่วยความจำแบบฮีปและหน่วยความจำแบบสแตก โดยหน่วยความจำแบบสแตก (Stack Memory) ทำหน้าที่เก็บ Primitive Data type และ Address of Object แต่หน่วยความจำแบบฮีป(Heap Memory) ทำหน้าที่เก็บวัตถุ
ตัวอย่าง 1.13 แสดงหน่วยความจำที่เหลือในฮีปเมโมรี่
Runtime r = Runtime.getRuntime();
r.gc(); // garbage collector
System.out.println(r.totalMemory()); // 5177344
long f1 = r.freeMemory(); // can not use int
int s[] = new int[10000];
r.gc();
try{
Thread.currentThread().sleep(1000); //sleep for 1000 ms
} catch(Exception e) { }
System.out.println(f1 - r.freeMemory()); // 40016
}
1.10 ตัวแปลภาษามีสองแบบ (Interpreter and Compiler)
1.10 ตัวแปลภาษามีสองแบบ (Interpreter and Compiler)
เมื่อเขียนโปรแกรมด้วยการสร้างรหัสต้นฉบับ (Source Code) เพื่อทำงานอย่างใดอย่างหนึ่ง ที่สามารถอ่านเข้าใจได้โดยโปรแกรมเมอร์ การจะทำให้โปรแกรมนั้นประมวลผลได้จำเป็นต้องผ่านการแปล ซึ่งการแปลภาษาคอมพิวเตอร์มี 2 แบบ คือ แบบอินเทอร์พรีเตอร์ (Interpreter) และแบบคอมไพเลอร์ (Compiler)
ภาษาจาวาถูกออกแบบให้แปลรหัสต้นฉบับเป็นไบท์โค้ดแบบคอมไพเลอร์ ซึ่งแปลทั้งโปรแกรมจนหมด และไม่พบข้อผิดพลาด ผลการแปลแฟ้มรหัสต้นฉบับที่มีสกุลเป็น .java จะได้แฟ้มผลลัพธ์ที่มีสกุลเป็น .class ซึ่งนำไปประมวลผลได้
แต่การแปลแบบอินเทอร์พรีเตอร์ จะไม่สร้างแฟ้ม .class แต่ประมวลผลทีละบรรทัด และทำงานที่ละบรรทัดตั้งแต่บรรทัดแรกไปถึงบรรทัดสุดท้าย หากบรรทัดใดผิดพลาดก็จะหยุดการทำงาน ต่างกับการแปลแบบคอมไพเลอร์ที่จะแปลทั้งโปรแกรม ถ้าพบบรรทัดใดผิดพลาดจะยกเลิกการทำงานทันที
ตัวอย่างการ
ตัวอย่าง 1.14 การเขียน แปล และประมวลผล
1. ตัวอย่างแฟ้มรหัสต้นฉบับ สร้างขึ้นด้วย edit , notepad , editplus หรือ copy con
class x {
public static void main(String args[]) {
System.out.println(5);
}
}
2. สร้างแฟ้มรหัสต้นฉบับ เช่น DOS> edit x.java
3. แปลแฟ้มรหัสต้นฉบับ เช่น DOS> javac x.java
4. ประมวลผลแฟ้มไบท์โค้ด เช่น DOS> java x
1.11 ข้อควรระวังในการเขียนโปรแกรม (Caution in Programming)
1.11 ข้อควรระวังในการเขียนโปรแกรม (Caution in Programming)
1. ประกาศตัวแปรก่อนเรียกใช้เสมอ ถ้าเรียกใช้โดยไม่ประกาศย่อม compile error
2. ประกาศประเภทตัวแปรให้ตรงกับการใช้งาน
3. จำนวนสัญลักษณ์ที่ต้องใช้เป็นคู่ จำเป็นต้องมีให้ครบคู่
4. Case Sensitive คือ พิมพ์ใหญ่ (Upper Case) และพิมพ์เล็ก (Lower Case) มีความแตกต่างกัน
5. ใช้สัญลักษณ์ผิด หรือ ลืมใช้ เช่น ; หรือ { หรือ (
6. แปลโปรแกรมที่ไม่มี หรือเรียกใช้ Class ที่ไม่มี
7. ความผิดพลาดมีได้ 2 ลักษณะ เมื่อตรวจด้วยตัวแปลภาษาคือ compile time กับ runtime
8. ความผิดพลาดบางอย่างที่ไม่ป้องกันด้วย Exception เช่น หารด้วย 0 หรือใช้อาร์เรย์ที่ไม่ประกาศ
9. การเรียกใช้คลาสที่ไม่สืบทอดจาก java.lang.Object โดยตรงจำเป็นต้องมีการ import ก่อนเสมอ
เช่น System.out.println(5);
Report abuse