ข้อมูลองค์ความรู้โดย
ณัฐพล วัฒนวิภัทรเจริญ
ตำแหน่ง IT

Java ตอนที่ 1 ความรู้เบื้องต้นเกี่ยวกับจาวา

ประเภททางด้าน IT หลัก :   Development & Integration
ประเภททางด้าน IT ย่อย :   Java
  ลงข้อมูลเมื่อ 10:29:27 10/08/2010
  Page View (4720) แบ่งปัน

ภาษาจาวา (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 ตัวแปลภาษา การแปล และการประมวลผล

                ภาษาจาวาถูกออกแบบให้มีความสามารถทำงานได้ในระบบปฏิบัติการที่หลากหลาย โดยติดตั้งส่วนรับการประมวลผลเพิ่มเติมที่ชื่อว่า จาวาเวอร์ชวลแมชชีน (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.3 แสดงค่าของอินสแตนท์ในคนละพื้นที่

class x {

  int a = 5;

  public static void main(String arg[]) {

    x b = new x();

    x c = new x();

    c.a = 6;

    System.out.println(c.a + b.a);  // 11

  }

}

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.4 การคำนวณและแคสติ้ง (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.5 การรับค่าผ่านคอนโซล หรือบรรทัดคำสั่ง

                - ปรับจากตัวอย่าง http://www.thaiall.com/perlphpasp/source.pl?j0100

                - การประมวลผลแบบที่ 1 เช่น DOS>java  j0100  abc  def

                - การประมวลผลแบบที่ 2 เช่น DOS>java  j0100

class j0100 {

public static void main(String args[]) {

  System.out.println(args.length);

  System.out.println(args[0]);   // abc

}

}

ตัวอย่าง 1.6 การใช้ตัวแปรดั้งเดิมทั้งแปด

class j0101 {

public static void main(String args[]) {

// 1. boolean true of false

  boolean b = true;

  System.out.println("boolean = " + b);

// 2. character (2 Byte = 65536 ตัวอักษร)

  char y;

  y = 'a';

  System.out.println("character = " + y);

// 3. byte -2^7 to 2^7-1 (1 Byte)

  byte c;

  c = 127;

  System.out.println("byte = " + c);

// 4. short -2^15 to 2^15-1 (2 Byte)

  short a;

  a = 32767;

  System.out.println("Short = " + a);

  // 5. integer -2^31 to 2^31-1 (4 Byte)

  int x;

  x = 2147483647;

  System.out.println("Integer = " + x);

  // 6. long -2^63 to 2^63-1 (8 Byte)

  long b;

  b = 9223372036854775807L;

  System.out.println("long = " + b);

  // 7. float -3.4e38 to 3.4e38 (4 Byte)

  float d;

  d = 340000000000000000000000000000000000000f;

  System.out.println("float = " + d);

  // 8. double -1.7e308 to 1.7e308 (8 Byte)

  double e;

  e = 17900000000000000000000000000000000000000d;

  System.out.println("double = " + e);

}

}

1.3 การแปลงประเภทข้อมูล (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.4 กฏของการโปรแกรมเชิงวัตถุ (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.5 คำสงวน (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

แหล่งอ้างอิง http://www.thaiall.com/class/indexsign.htm

การแบ่งกลุ่มคำสงวนแบบ 4 กลุ่ม

DATA = 13

CONTROL = 18

OBJECTS = 16

UNUSED = 2

1. boolean

2. byte

3. char

4. double

5. float

6. int

7. long

8. short

9. final

10. static

11. void

12. strictfp

13. transient

 

1. assert

2. break

3. case

4. catch

5. continue

6. default

7. do

8. else

9. finally

10. for

11. if

12. return

13. switch

14. synchronized

15. throw

16. throws

17. try

18. while

1. abstract

2. class

3. extends

4. implements

5. import

6. instanceof

7. interface

8. native

9. new

10. package

11. private

12. protected

13. public

14. super

15. this

16. volatile

 

1. const

2. goto

 

การแบ่งกลุ่มคำสงวนแบบ 9 กลุ่ม

1. ขยายการเข้าถึง (Access Modifiers)

2. ขยายคลาส เมธอด และตัวแปร (Class, Method, and Variable Modifiers)

3. ควบคุมการไหลในโปรแกรม (Flow Control)

4. การจัดการกับข้อผิดพลาด (Error Handling)

5. ควบคุมแพกเกจ (Package Control)

6. แบบข้อมูลดั่งเดิม (Primitives)

7. คำหลักตัวแปร (Variable Keywords)

8. คำแบบไม่คืนค่า (Void Return Type Keyword)

9. คำที่ไม่ใช้ (Unused Reserved Words)

1. ขยายการเข้าถึง (Access Modifiers)

1. private : Makes a method or a variable accessible only from within its own class.

2. protected : Makes a method or a variable accessible only to classes in the same package or subclasses of the class.

3. public : Makes a class, method, or variable accessible from any other class.

2. ขยายคลาส เมธอด และตัวแปร (Class, Method, and Variable Modifiers)

4. abstract : Used to declare a class that cannot be instantiated, or a method that must be implemented by a nonabstract subclass.

5. class : Keyword used to specify a class.

6. extends : Used to indicate the superclass that a subclass is extending.

7. final : Makes it impossible to extend a class, override a method, or reinitialize a variable.

8. implements : Used to indicate the interfaces that a class will implement.

9. interface : Keyword used to specify an interface.

10. native : Indicates a method is written in a platform-dependent language, such as C.

11. new : Used to instantiate an object by invoking the constructor.

12. static : Makes a method or a variable belong to a class as opposed to an instance.

13. strictfp : Used in front of a method or class to indicate that floating-point numbers will follow FP-strict rules in all expressions.

14. synchronized : Indicates that a method can be accessed by only one thread at a time.

15. transient : Prevents fields from ever being serialized. Transient fields are always skipped when objects are serialized.

16. volatile : Indicates a variable may change out of sync because it is used in threads.

3. ควบคุมการไหลในโปรแกรม (Flow Control)

17. break : Exits from the block of code in which it resides.

18. case : Executes a block of code, dependent on what the switch tests for.

19. continue : Stops the rest of the code following this statement from executing in a loop and then begins the next iteration of the loop.

20. default : Executes this block of code if none of the switch-case statements match.

21. do : Executes a block of code one time, then, in conjunction with the while statement, it performs a test to determine whether the block should be executed again.

22. else : Executes an alternate block of code if an if test is false.

23. for : Used to perform a conditional loop for a block of code.

24. if : Used to perform a logical test for true or false.

25. instanceof : Determines whether an object is an instance of a class, superclass, or interface.

26. return : Returns from a method without executing any code that follows the statement (can optionally return a variable).

27. switch : Indicates the variable to be compared with the case statements.

28. while : Executes a block of code repeatedly while a certain condition is true.

4. การจัดการกับข้อผิดพลาด (Error Handling)

29. catch : Declares the block of code used to handle an exception.

30. finally : Block of code, usually following a try-catch statement, which is executed no matter what program flow occurs when dealing with an exception.

31. throw : Used to pass an exception up to the method that called this method.

32. throws : Indicates the method will pass an exception to the method that called it.

33. try : Block of code that will be tried, but which may cause an exception.

34. assert : Evaluates a conditional expression to verify the programmer’s assumption.

5. ควบคุมแพกเกจ (Package Control)

35. import : Statement to import packages or classes into code.

36. package : Specifies to which package all classes in a source file belong.

6. แบบข้อมูลดั่งเดิม (Primitives)

37. boolean : A value indicating true or false.

38. byte : An 8-bit integer (signed).

39. char : A single Unicode character (16-bit unsigned)

40. double : A 64-bit floating-point number (signed).

41. float : A 32-bit floating-point number (signed).

42. int : A 32-bit integer (signed).

43. long : A 64-bit integer (signed).

44. short : A 16-bit integer (signed).

7. คำหลักตัวแปร (Variable Keywords)

45. super : Reference variable referring to the immediate superclass.

46. this : Reference variable referring to the current instance of an object.

8. คำแบบไม่คืนค่า (Void Return Type Keyword)

47. void : Indicates no return type for a method.

9. คำที่ไม่ใช้ (Unused Reserved Words)

48. const : Do not use to declare a constant; use public static final.

49. goto : Not implemented in the Java language. It’s considered harmful.

1.6 ตัวดำเนินการ (Operator)

1. =         การส่งค่า จากทางขวาไปทางซ้าย

            เช่น      if ((x = true) || (y = false))

                  if ((x = true) && (y = false))

2. >         เปรียบเทียบ หมายถึงมากกว่า

3. <         เปรียบเทียบ หมายถึงน้อยกว่า

4. !          ไม่เท่ากับ

5. ~         กลับบิทจาก 0 เป็น 1 (one's complement)

6. ? :        เปรียบเทียบเพื่อเลือกกระทำ เช่น System.out.println((1 == 2) ? "3" : "4"); // 4

7. ==      เปรียบเทียบความเท่ากับของตัวเลข หรือตัวอักษร

8. <=      เปรียบเทียบความน้อยกว่า หรือเท่ากับ

9. >=      เปรียบเทียบความมากกว่า และเท่ากับ

10. !=     เปรียบเทียบความไม่เท่ากับ

11. &&    และ

12. ||       หรือ

13. ++    เพิ่มค่าให้ตัวแปรอีก 1

14. --       ลดค่าจากตัวแปรอีก 1

15. +       บวก

16. -        ลบ

17. *        คูณ

18. /        หาร

19. &       และ สำหรับตัวปฏิบัติการบิท (and)

20. |        หรือ สำหรับตัวปฏิบัติการบิท (or)

21. ^       ตัวปฏิบัติการบิทแบบเอ็กครูซิฟออร์ (exclusive or)

22. %      หาร แล้วใช้เฉพาะเศษ

            for (int i=0;i<=10;i++) System.out.println(i % 2);

23. <<    เลื่อนบิทไปทางซ้าย

                System.out.println( (char)(“z”<<1));  // ๔ = 244

24. >>    เลื่อนบิทไปทางขวา

char x;

x  = 122 >> 1;          // ‘z’ = 7a = 0111 1010

System.out.println(x); // ‘=’ = 3d = 0011 1101

25. >>> เลื่อนบิทไปทางขวาแบบไม่คิดเครื่องหมาย

26. +=    บวกกับตัวตั้ง แล้วเปลี่ยนค่าตัวตั้ง

            เช่น     x = x + y;

x += y;

27. -=     ลบกับตัวตั้ง แล้วเปลี่ยนค่าตัวตั้ง

28. *=     คูณกับตัวตั้ง แล้วเปลี่ยนค่าตัวตั้ง

29. /=      หารกับตัวตั้ง แล้วเปลี่ยนค่าตัวตั้ง

                30. //       หมายเหตุบรรทัด ข้อความหลังเครื่องหมายนี้ไม่ถูกนำมาประมวลผล

                31. /*  ..  */              หมายเหตุหลายบรรทัด

            เช่น     /*    System.out.println(1);

                        System.out.println(2);

System.out.println(3);      

*/

                http://www.jarticles.com/tutorials/basic/javaoperator.html

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 ตรวจสอบผลการจองพื้นที่ในหน่วยความจำ

                - สมาชิกของอาร์เรย์แบบ String 100 สมาชิก ใช้พื้นที่ใน Heap Memory 488 Bytes

                - ทดสอบจองไป 1000 สมาชิก ใช้พื้นที่ใน Heap Memory 4880 Bytes

                - โจทย์ : จงเขียนโปรแกรมแสดงการใช้พื้นที่ในหน่วยความจำผ่านอาร์เรย์แบบ String จำนวน 10 ครั้ง

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

class x{

static String a[ ];

public static void main(String args[ ]) {

  Runtime r = Runtime.getRuntime();

  r.gc(); // Garbage Collector

  long f,t;

  System.out.println("Total memory:" + r.totalMemory());

  t = r.freeMemory();

  for(int i=1;i<=10;i++) {

    f = r.freeMemory();

    a = new String[100];              // 488 Bytes for 100 Strings

    System.out.println("Memory Used:" + (f - r.freeMemory())); // 488

  }

  System.out.println("TUsed:"+ (t - r.freeMemory())); //  > 4880 Bytes

}

}

ตัวอย่าง 1.9 เมทธอดที่เป็นสแตติกกับไม่เป็นสแตติก

class x {

  public static void main(String arg[]) {

    System.out.println( x1() );

    x oho = new x();

    System.out.println( oho.x2() );

    System.out.println( new x().x2() );

  }

  static int x1 () { return 5; }

  int x2 () { return 6; }

}

http://203.158.173.30/fbla/Power%20point/OOP/Chapter%208.ppt

http://www.programmersheaven.com/2/FAQ-JAVA-What-Is-Static-Modifier-And-Class

ตัวอย่าง 1.10 อินสแตนท์ที่เป็นสแตติกกับไม่เป็นสแตติก

class x {

static int a;

int b = 8;

public static void main(String arg[]) {

System.out.println(a++ + ++a); // 2

x oho = new x();

System.out.println(oho.b);

}

}

 

 

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.11 แสดงพฤติกรรมและลักษณะจำเพาะด้วยภาษาจาวา

เป็นการแสดงให้เห็นว่า method ชื่อ running ซึ่งเป็นพฤติกรรม เมื่อประมวลผลจะทำให้ลักษณะจำเพาะคือ distance เปลี่ยนไป ในความเป็นจริงพฤติกรรมนี้อาจมีลักษณะจำเพาะหลายอย่าง เช่น การเต้นของหัวใจ ความเร็ว

class Human {

private int running (int distance) {

  distance += 1;

  return distance;

}

}

ตัวอย่าง 1.12 แสดงพฤติกรรมและลักษณะจำเพาะด้วยภาษาวิชวลเบสิกดอทเน็ต

นอกจากภาษาจาวาแล้ว ภาษายุคใหม่สามารถสร้างวัตถุ มีการกำหนดพฤติกรรม และลักษณะจำเพาะได้ นี่เป็นตัวอย่างการเขียนโปรแกรมใน Console Application และ Class ด้วยวิชวลเบสิกดอทเน็ต ซึ่งมีตัวอย่างเกี่ยวกับภาษานี้ใน http://www.thaiall.com/vbnet

Imports System.Console

Module Module1

    Sub Main()

        Dim h As New human()

        WriteLine(h.running(10))

    End Sub

End Module

Public Class human

    Public Function running(ByVal i As Integer) As Integer

        i = i + 1

        Return i

    End Function

End Class

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)

                เมื่อเขียนโปรแกรมด้วยการสร้างรหัสต้นฉบับ (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. ประกาศตัวแปรก่อนเรียกใช้เสมอ ถ้าเรียกใช้โดยไม่ประกาศย่อม 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);

                                                java.io.BufferedReader

                http://www.thaiall.com/class/java_error.ppt

สรุปเนื้อหาท้ายบท

- แนะนำเอกสารประกอบการเรียน

http://www.thaiall.com/class

http://www.thaiall.com/uml

http://www.thaiall.com/class/javaintro.doc

http://www.thaiall.com/class/java_intro.ppt

http://www.thainame.net/weblampang/vbnet/java511_01.doc

- แนะนำ Reference และ API จากเว็บไซต์ และแหล่งอ้างอิง

http://yn1.yonok.ac.th/burin/javadocs/api/java/lang/String.html

http://www.yonok.ac.th/pmy/j2sdk-1_4_2-doc.zip

แบบฝึกหัดท้ายบท

- จงเขียนบรรยายสรุปเนื้อหาในบทเรียนนี้มาอย่างน้อย 2 หน้า

- จงสรุปว่าข้อสอบ 10 ข้อ แต่ละข้อตอบอะไรจาก thaiall.com/quiz

บทที่ 2 การเขียนโปรแกรมเบื้องต้น (Introduction to Programming)

บทนำ

                หลายครั้งที่ผู้เขียนเริ่มสอนเขียนโปรแกรมให้นักเรียนกลุ่มใหม่ หรือสอนเขียนภาษาใหม่ให้นักศึกษากลุ่มเดิม มักเริ่มต้นด้วยประโยคติดปากว่า "แนวการเขียนโปรแกรมในทุกภาษานั้นคล้ายกัน เข้าใจภาษาหนึ่งย่อมเข้าใจภาษาอื่นไปด้วย เรียนภาษาเดียวแต่เหมือนเรียนแนวคิดพื้นฐานในทุกภาษา" สิ่งที่แตกต่างกันในแต่ละภาษา คือ โครงสร้างภาษา คำสั่ง ฟังก์ชัน และวิธีการใช้งานตัวแปลภาษา แต่สิ่งที่เหมือนกันของทุกภาษา คือ มีกระบวนการพัฒนาโปรแกรม (Development Process) แนวคิดการโปรแกรมโครงสร้าง (Structure Programming) การออกแบบโปรแกรม (Program Design) ความเข้าใจในพื้นฐานการเขียนโปรแกรม เช่น ใช้ฟังก์ชัน สร้างฟังก์ชัน เครื่องมือ โมดูล ตัวแปร รูปแบบข้อมูล เป็นต้น

                เมื่อถูกถามว่าจะเริ่มต้นเขียนโปรแกรมอย่างไร เลือกภาษาใดดี เพื่อนำไปประกอบอาชีพ ในความเห็นของผู้เขียนมีขั้นตอน 4 ขั้น ดังนี้ 1) หาข้อมูลเกี่ยวกับภาษาที่สนใจ โดยเฉพาะจุดเด่น จุดด้อย และความเป็นไปได้ที่จะนำมาใช้เป็นเครื่องมือของโปรแกรมเมอร์ (Programmer)  ที่สัมพันธ์กับความรู้เดิมของผู้ศึกษา ซึ่งแหล่งข้อมูลที่ดีที่สุด คือ หนังสือที่จำหน่ายตามร้านหนังสือ เพราะจะได้เห็นถึงแนวโน้มเกี่ยวกับภาษาคอมพิวเตอร์ในปัจจุบัน ภาษาใดมีนักเขียนแต่งหนังสือออกมาขายมากย่อมเชื่อได้ว่ากำลังเป็นที่นิยม  แต่ภาษาใดหาหนังสืออ่านไม่ได้แล้วก็เป็นได้ว่ากำลังจะเป็นภาษาถูกเลิกใช้ 2) จัดหาเครื่องคอมพิวเตอร์ที่เหมาะกับตัวแปลภาษา และเลือกซื้อตัวแปลภาษาในรุ่นที่เหมาะสมกับเครื่องมือที่เกี่ยวข้อง และสรรหาเครื่องมือประกอบการพัฒนาระบบที่จำเป็น เช่น อิดิเตอร์ (Editor) ระบบฐานข้อมูล (Database) เครื่องคอมพิวเตอร์สำหรับทดสอบโปรแกรม (Computer for Testing) และเครื่องมือจัดการภาพกราฟฟิก 3) วางแผนการศึกษาด้วยตนเอง และแบ่งเวลาให้กับการเรียนรู้ตามแผนการเรียนรู้ที่กำหนดขึ้น ความเข้าใจในการเขียนโปรแกรมเกิดขึ้นจากการทดลองปฏิบัติด้วยตนเอง (Learning by Doing) มักเป็นการลองผิดลองถูกหาวิธีการที่ดีที่สุด เพราะการเขียนโปรแกรมไม่มีกฎตายตัว ความต้องการอย่างหนึ่งสามารถใช้วิธีการแก้ไปัญหาได้หลายวิธี ขึ้นอยู่กับโปรแกรมเมอร์จะเป็นผู้วางโปรแกรมให้ทำงานอย่างไร 4) สร้างระบบงาน หรือโปรเจค (Project) ที่แสดงผลการเรียนรู้ที่ผ่านมา ซึ่งเกิดจากความคิดรวบยอด สร้างชิ้นงานที่สามารถนำมาใช้ประโยชน์ และเผยแพร่สู่สาธารณะ โดยมีการเก็บข้อเสนอแนะ หรือผลการใช้งาน นำมาพัฒนาแก้ไขจุดบกพร่อง และนำประสบการณ์ที่ได้ไปพัฒนางานชิ้นใหม่ที่จะมีขึ้นในอนาคต

                การจัดการความรู้ (Knowledge Management) และคำว่าวิทยาทานเป็นสิ่งที่สอดคล้องกัน ถ้านักพัฒนา หรือนักศึกษาเรียนรู้ที่จะนำผลการเรียนรู้ไปสร้างงาน หาข้อมูลเพิ่มเติม แลกเปลี่ยนกับผู้เชี่ยวชาญ เกิดกระบวนการเรียนรู้ เมื่อนำความรู้ไปพัฒนาจนผลงานเสร็จสมบูรณ์ก็นำไปเผยแพร่ผ่านเว็บบล็อก หรือเว็บไซต์เครือข่ายสังคม และนำข้อเสนอแนะ (Feedback) ที่ได้รับกลับมาปรับปรุงโปรแกรม และเผยแพร่ผลงานรุ่นปรับปรุง ก็จะกลายเป็นผลงานที่มีคุณค่าของสังคมเป็นที่ประจักษ์

ที่มาจาก www.thaiall.com



องค์ความรู้ที่มีผู้อ่านมากสุด
Java ตอนที่ 3 รับข้อมูลทางแป้นพิมพ์ และแสดงผล
การติดต่อกับผู้ใช้เป็นความสามารถของภาษาคอมพิวเตอร์ที่จะเปิดให้ผู้ใช้เข้าควบคุมการทำงานของเครื่องคอมพิวเตอร์ ซึ่งการติดต่อของอุปกรณ์อิเล็กทรอนิกส์หรือฮาร์ดแวร์กับผู้ใช้นั้นสามารถกระทำได้หลายวิธี เช่น แป้นพิมพ์ (Keyboard) เมาส์ (Mouse) หรือเซนเซอร์ต่าง ๆ แต่ที่นิยมใช้และมีประสิทธิภาพสำหรับงานทั่วไปคือการรับคำสั่งจากผู้ใช้ผ่านแป้นพิมพ์ ส่วนการตอบสนองของเครื่องคอมพิวเตอร์ให้ผู้ใช้ได้ทราบถึงผลของการประมวลผลคำสั่งที่ได้รับจากผู้ใช้ก็คือจอภาพ (Screen) และเครื่องพิมพ์ (Printer) เป็นต้น ในบทนี้จะกล่าวถึงการเชื่อมต่อกับผู้ใช้ที่รับข้อมูลผ่านแป้นพิมพ์ และการแสดงผลให้ผู้ใช้ทราบทางจอภาพเป็นหลัก

โดย... ณัฐพล วัฒนวิภัทรเจริญ

่Java ตอนที่ 10 แอพเพลท
เมื่อสร้าง Applet ซึ่งเป็นแฟ้ม .class แล้ว จะต้องสร้างแฟ้ม .htm เพื่อเรียกใช้ Applet แสดงผล ซึ่งมีหลักการเช่นเดียวกับการสร้าง Application ที่ประมวลผลใน console คือได้โปรแกรม .class ก็ต้องสั่งประมวลผลผ่านโปรแกรม java แต่ Applet มีวิธีเรียกใช้ที่ต่างออกไป ซึ่งทำได้ 2 วิธี หลังสร้างแฟ้ม .htm แล้ว

โดย... ณัฐพล วัฒนวิภัทรเจริญ

ลำดับการทำงาน 3D Animation
โครงการสร้าง 3D Animation ขนาดใหญ่จะเป็นไปตามลำดับการทำงานที่เฉพาะเจาะจง แม้แต่โครงการเล็กๆ ที่มีศิลปินเพียง 1 – 2 คนก็ยังใช้ประโยชน์จากการทำงานตามลำดับขั้นที่โครงงานใหญ่ๆ ที่มีความพร้อมสูงใช้กัน โดยอาจจะนำมาใช้เป็นบางส่วนหรือทั้งหมดเลยก็มี

โดย... ณัฐพล วัฒนวิภัทรเจริญ

Java ตอนที่ 14 เจเอสพี
ภาษาเจเอสพี (JSP = Java Server Pages) คือ ภาษาสคริปต์ที่ทำงานบนเครื่องบริการ เช่นเดียวกับภาษา perl, php หรือ asp มีโครงสร้างภาษาแบบจาวา หรือภาษาซี โดยมีตัวแปลภาษาที่ถูกพัฒนาโดยบริษัทซันไมโครซิสเต็ม ซึ่งเป็นเทคโนโลยีของจาวา สำหรับสร้างรหัสเอชทีเอ็มแอล (HTML)

โดย... ณัฐพล วัฒนวิภัทรเจริญ

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

โดย... ณัฐพล วัฒนวิภัทรเจริญ

การประยุกต์ใช้งานอินทราเน็ตและเอ็กทราเน็ตเพื่อสนับสนุนการค้าบนเวบ (Intranet/Extranet)
ตามความหมายแล้ว ทั้งสองระบบนี้ หมายถึง ระบบเครือข่ายที่สร้างขึ้นจากการนำหลักการหรือระบบการทำงานของอินเทอร์เนตมาใช้งานภายในองค์กร (Intranet) และระหว่างองค์กรเฉพาะกลุ่ม (Extranet) ซึ่งหน้าที่ต่างๆในการใช้งานไม่ว่าจะเป็นเรื่องเว็บบราวเซอร์ การรับ-ส่งอีเมล์ การทำการโอนย้ายแฟ้มข้อมูล (FTP) จะเหมือนกันกับที่ใช้อยู่บนระบบอินเทอร์เน็ตปกติ ซึ่งระบบนี้ทำงานด้วยการตั้งอินทราเน็ตเซิร์ฟเวอร์ขึ้นมาภายในองค์กรหรือศูนย์กลางของกลุ่มองค์กรของเรา เช่น ระหว่างบริษัทของเรากับกับกลุ่มตัวแทนจำหน่าย

โดย... ณัฐพล วัฒนวิภัทรเจริญ

Java ตอนที่ 13 จาร์
Jar (ava Archieve) หมายถึง ที่เก็บเอกสาร เป็นแฟ้มที่มีสกุลเป็น .jar สามารถเก็บแฟ้มต่าง ๆ ได้เหมือนกับแฟ้ม .zip แต่ผู้พัฒนาสามารถเรียกใช้โปรแกรมภายในแฟ้ม .jar ได้ทันที โดยไม่ต้องแตกแฟ้มออกมาก่อน แล้วจึงเรียกใช้เหมือนกับแฟ้ม .zip

โดย... ณัฐพล วัฒนวิภัทรเจริญ

Java ตอนที่ 12 แพ็คเกจ
ในอนาคต หากมี .class หลายร้อยแฟ้ม และเก็บแยก directory อย่างเป็นระเบียบ เช่น ห้อง c:\java\bin\aaa เก็บ .class 100 แฟ้ม และ c:\java\bin\burin เก็บ . class 150 แฟ้ม การเรียกใช้จากแต่ละห้อง สามารถทำได้ด้วยการใช้คำสั่ง import แต่ class ที่อยู่ในแต่ละห้องจะประกาศด้วยคำสั่ง package และมีข้อมูลว่าแต่ละห้อง จะต้องมีชื่อ class ที่ไม่ซ้ำกัน

โดย... ณัฐพล วัฒนวิภัทรเจริญ

ระบบ SAN (Storage Area Network)
ยุคการจัดการความรอบรู้ได้เริ่มต้นขึ้นแล้ว อิเล็กทรอนิกส์ทำให้ระบบการเรียนรู้ต่าง ๆ เปลี่ยนแปลงไปมาก เรามีระบบการเรียนรู้แบบใหม่ที่ชื่อ eLearning ใช้สื่อข้อมูลเป็นแหล่งการเรียนรู้ใหญ่ มีระบบ eLibrary เก็บข้อมูลหนังสือที่เป็นแบบ eBook รวมทั้งสิ่งพิมพ์ประเภท eMagazine eJournal และ eProceeding ระบบ e ยังทำให้เกิดการเรียนรู้แบบ eEducation on Demand หรือ eEOD

โดย... ณัฐพล วัฒนวิภัทรเจริญ

Java ตอนที่ 11 แอพพลิเคชั่น
การสั่งและเลิกประมวลผล 1. สั่งประมวลผล Application ด้วย DOS> java x 2. การปิด Application ที่ไม่มีคำสั่ง exit ในตัวโปรแกรมให้กดปุ่ม CTRL-C ใน DOS

โดย... ณัฐพล วัฒนวิภัทรเจริญ