สอนใช้งาน JSF Step by Step: 2015

วันอาทิตย์ที่ 22 กุมภาพันธ์ พ.ศ. 2558

Basic Operators

Operator ใน Java นั้นก็คือสิ่งที่เอาไว้จัดการกับตัวแปรต่างๆ เช่น การ บวก ลบ คูณ หาร หรือการทำสิ่งต่างๆ

เราสามารถแบ่ง Operator เป็นกลุ่มได้ดังนี้

1. Arithmetic Operators

2. Relational Operators

3. Bitwise Operators

4. Logical Operators

5. Assignment Operators

6. Misc Operators

1. Arithmetic Operators

Arithmetic Operators ก็คือ Operator ทางคณิตศาสตร์ เช่น การบวก ลบ คูณ หาร

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

Operator	Description	Example
+	การบวก	x = 5 + 5
-	การลบ	x = 10 - 5
*	การคูณ	y = 2 * 2
/	การหาร	y = 4 / 2
%	การหารแล้วเอาแต่เศษ	z = 11 % 2 (จะได้ 1)
++	การเพิ่มค่าของจำนวนเต็ม 1	x = x++;
--	การลดค่าของจำนวนเต็ม 1	y = y--;

2. Relational Operators

Relational Operators ก็คือ Operator ทีเอาไว้เทียบความสัมพันธ์ เช่น เท่ากับ, มากกว่า, น้อยกว่า ซึ่งค่าที่ได้จากการเทียบนี้จะได้ค่า true หรือ false ซึ่งเอาไว้เช็คเงื่อนไข

Operator	Description	Example
==	การตรวจสอบค่าทั้งสองค่าว่ามีค่าเท่ากันไหม ถ้าเท่ากันจะได้ค่า true	(2 == 2)
!=	การตรวจสอบค่าทั้งสองค่าว่ามีค่าไม่เท่ากันไหม ถ้าไม่เท่ากันจะได้ค่า true	(2 != 3)
>	การตรวจสอบค่าทั้งสองค่าว่าค่าทางด้านซ้ายมีค่ามากกว่าค่าทางด้านขวาหรือไม่ ถ้าใช่จะได้ค่า true	(5 > 1)
<	การตรวจสอบค่าทั้งสองค่าว่าค่าทางด้านซ้ายมีค่าน้อยกว่าค่าทางด้านขวาหรือไม่ ถ้าใช่จะได้ค่า true	(1 < 5)
>=	การตรวจสอบค่าทั้งสองค่าว่าค่าทางด้านซ้ายมีค่ามากกว่าหรือเท่ากับค่าทางด้านขวาหรือไม่ ถ้าใช่จะได้ค่า true	(5 >= 5)
<=	การตรวจสอบค่าทั้งสองค่าว่าค่าทางด้านซ้ายมีค่าน้อยกว่าหรือเท่ากับค่าทางด้านขวาหรือไม่ ถ้าใช่จะได้ค่า true	(5 <= 5)

3. Bitwise Operators

Bitwise Operators ก็คือ การกระทำระดับ bit ของตัวแปรโดยมีเงื่อนไขว่า ตัวแปรที่จะนำมาใช้ใน Bitwise Operatos นั้นจะต้องเป็นตัวเลขจำนวนเต็ม (เช่น byte, short, int, long) หรือเป็นตัวอักษร (char)

โดย Bitwise Operator ยังแบ่งได้อีกเป็น 2 กลุ่ม

3.1 Logical Bitwise Operators ซึ่งจะได้แก่

3.1.1 ~ (bitwise unary NOT)

3.1.2 & (bitwise AND)

3.1.3 | (bitwise OR)

3.1.4 ^ (bitwise EXCLUSIVE OR)

3.1.5 >> (shift right)

3.1.6 >>> (shift right zero fill)

3.1.7 << (shift left)

- ตัวอย่างการทำ Logical Bitwise Operators เช่น

int a = 10; // 0000 1010 <- ค่านี้เกิดจากการใช้คำสั่ง System.out.println(Integer.toBinaryString(a));
int b = 99; // 0110 0011 <- ค่านี้เกิดจากการใช้คำสั่ง System.out.println(Integer.toBinaryString(b));

ใช้กับ Operator OR จะได้ดังนี้
a | b = 0110 1011

ใช้กับ Operator AND จะได้ดังนี้
a & b = 0000 0010

ใช้กับ Operator EXCLUSIVE OR จะได้ดังนี้
a ^ b = 0110 1001

ใช้กับ Operator NOT จะได้ดังนี้
~a = 1111 0101

ใช้กับ Operator shift right จะได้ดังนี้
b >> 2 (จะได้ 0001 1000)

ใช้กับ Operator shift right zero fill จะได้ดังนี้
b >>> 2 (จะได้ 0001 1000)

ใช้กับ Operator shift left จะได้ดังนี้
b << 2 (จะได้ 1000 1100)

3.2 Assignment bitwise operators ได้แก่

3.2.1 &= (bitwise AND assignment)

3.2.2 |= (bitwise OR assignment)

3.2.3 ^= (bitwise XOR assignment)

3.2.4 >>= (shift right assignment)

3.2.5 >>>= (shift right zero fill assignment)

3.2.5 <<= (shift left assignment)

- ตัวอย่างการทำ Assignment Bitwise Operators เช่น

a &= 5 จะมีค่าเหมือนกันกับ a = a & 5

a |= 5 จะมีค่าเหมือนกันกับ a = a | 5

a ^= 5 จะมีค่าเหมือนกันกับ a = a ^ 5

a >>= 5 จะมีค่าเหมือนกันกับ a = a >> 5

a >>>= 5 จะมีค่าเหมือนกันกับ a = a >>> 5

a <<= 5 จะมีค่าเหมือนกันกับ a = a << 5

4. Logical Operators

Logical Operators คือการนำ boolean มาทำการ AND, OR หรือ NOT กัน โดยผลลัพธ์ที่ได้ออกมาจะเเป็นเพียงค่า true หรือ false

สมมติว่าได้ประกาศค่าตัวแปรเอาไว้ 2 ตัวเป็นดังนี้

boolean a = true;
boolean b = false;

Operator	Description	Example
&&	จะเป็นค่า true ก็ต่อเมื่อค่าทั้งสองค่าเป็น true	(a && b) ได้ค่า false
\|\|	จะเป็นค่า false ก็ต่อเมื่อค่าทั้งสองค่าเป็น false	(a \|\| b) ได้ค่า true
!	จะทำการกลับค่าจาก true เป็น false หรือจาก false เป็น true	!a ได้ค่า false

5. Assignment Operators

Assignment Operators เป็น Operators ที่เอาไว้กำหนดค่าให้กับตัวแปร

Operator	Description	Example
=	เป็นการกำหนดค่าให้กับตัวแปร	a = 10
+=	นำตัวแปรด้านซ้ายมาบวกเพิ่ม ก่อนที่จะกำหนดค่าให้	a += 10 มีค่าเท่ากับ a = a + 10
-=	นำตัวแปรด้านซ้ายมาลบออก ก่อนที่จะกำหนดค่าให้	a -= 10 มีค่าเท่ากับ a = a - 10
*=	นำตัวแปรด้านซ้ายมาคูณ ก่อนที่จะกำหนดค่าให้	a = 10 มีค่าเท่ากับ a = a 10
/=	นำตัวแปรด้านซ้ายมาหาร ก่อนที่จะกำหนดค่าให้	a /= 10 มีค่าเท่ากับ a = a / 10
%=	นำตัวแปรด้านซ้ายมาหารเก็บเศษ ก่อนที่จะกำหนดค่าให้	a %= 10 มีค่าเท่ากับ a = a % 10
<<=	นำตัวแปรด้านซ้ายมาเลื่อนบิตไปทางซ้าย ก่อนที่จะกำหนดค่าให้	a <<= 10 มีค่าเท่ากับ a = a << 10
>>=	นำตัวแปรด้านซ้ายมาเลื่อนบิตไปทางขวา ก่อนที่จะกำหนดค่าให้	a >>= 10 มีค่าเท่ากับ a = a >> 10
&=	นำตัวแปรด้านซ้ายมาทำการ AND ระดับบิต ก่อนที่จะกำหนดค่าให้	a &= 10 มีค่าเท่ากับ a = a & 10
^=	นำตัวแปรด้านซ้ายมา XOR ระดับบิต ก่อนที่จะกำหนดค่าให้	a ^= 10 มีค่าเท่ากับ a = a ^ 10
\|=	นำตัวแปรด้านซ้ายมา OR ระดับบิต ก่อนที่จะกำหนดค่าให้	a \|= 10 มีค่าเท่ากับ a = a \| 10

6. Misc Operators

นอกเหนือจาก Operators ที่ได้กล่าวมาแล้วทั้งหมด ยังมี Operators อื่นๆอีกที่ใช้บ่อยในการเขียน JAVA อย่างเช่น

6.1 Conditional Operator ( ? : )

Conditional Operator เป็น Operator ที่เอาไว้ตรวจสอบเงื่อนไข If Else เช่น ถ้าเงื่อนไขเป็นจริงจะทำอะไร หรือเงื่อนไขเป็นเท็จจะทำอะไร ตัวอย่างการใช้เช่น

int a = 10;

int b = 3;

a = (b > 1) ? 5 : 15;

จากตัวอย่างที่ให้มาข้างบนนั้น b มีค่าเป็น 3 เมื่อแทนค่าในวงเล็บ จะได้ ( 3 > 1 ) ซึ่งจะได้ค่า true

ดังนั้น a จะถูกกำหนดค่าให้เป็น 5

แต่ถ้าเรากำหนดค่าให้ b = 0

int a = 10;

int b = 0;

a = (b > 1) ? 5 : 15;

เมื่อแทนค่าในวงเล็บจะได้ ( 0 > 1 ) ซึ่งไม่เป็นจริง ทำให้ได้ค่า false เมื่อเป็น false แล้วเงื่อนไขที่จะเลือกจะเป็นตัวด้านหลัง ซึ่งในที่นี้ก็คือ 15 โดย a จะถูกกำหนดค่าเป็น 15

6.2 instanceof Operator

instanceof Operator เป็น Operator ที่ใช้กับตัวแปรที่เป็น Object ได้เท่านั้น โดยจะนำตัวแปร object มาทำการตรวจสอบว่ามีชนิดของ Class หรือ Interface ถูกต้องตามที่ระบุเอาไว้หรือไม่โดยสามารถตรวจสอบการเป็นแม่ลูกได้ด้วย

ตัวอย่างการใช้เช่น

  String s = "";
  
  if(s instanceof String){
   System.out.println(true); // จะได้ค่านี้เพราะว่า s เป็นตัวแปรชนิด String
  }else{
   System.out.println(false);
  }
    
  if(s instanceof Object){
   System.out.println(true); // จะได้ค่านี้เพราะว่า object ทุกๆตัวจะเป็น sub class ของคลาส Object เสมอ
  }else{
   System.out.println(false);
  }

อ่านต่อ »

วันพฤหัสบดีที่ 5 กุมภาพันธ์ พ.ศ. 2558

Access Modifier

Java Access Modifier

ในภาษา Java นั้นจะมีระดับการเข้าถึงของ คลาส, ตัวแปร, เมธอด และ คอนสตรัคเตอร์ ซึ่งจะมีระดับการเข้าถึงทั้งหมด 4 แบบ

Modifier	Class	Package	Subclass	World
public	Y	Y	Y	Y
protected	Y	Y	Y	N
no modifier	Y	Y	N	N
private	Y	N	N	N

Public Access Modifier - public

class, method, constructor, interface หรืออะไรก็ตามที่สามารถประกาศโดยใช้คำว่า public

สิ่งที่ประกาศคำว่า public นั้นจะสามารถถูกเข้าถึงจาก Class อื่นๆได้ ถึงแม้ว่าจะอยู่ต่าง package และคลาสลูกยังสามารถใช้ตัวแปรของคลาสแม่ที่ได้ประกาศ public เอาไว้ได้ด้วย

- ตัวอย่างการใช้ public

public class MainClassExample {

         // ตัวอย่างการใช้ public กับ method main
 public static void main(String[] args) {

 }

}

Protected Access Modifier - protected

ตัวแปร, เมธอด และ คอนสตรัคเตอร์ ที่ประกาศโดยใช้คำสั่ง protected ในคลาสใดคลาสหนึ่ง จะทำให้ ตัวแปร, เมธอด และ คอนสตรัคเตอร์ที่ทำการประกาศในคลาสนั้น จะสามารถถูกเข้าถึงได้เฉพาะจากคลาสลูกเท่านั้น

คำสั่ง protected นั้นไม่สามารถนำไปประกาศข้างหน้า class หรือ interface ได้ แต่สำหรับ เมธอด และตัวแปรสามารถใช้ protected ได้ ยกเว้น เมธอดและตัวแปรใน interface

- ตัวอย่างการใช้ protected

class Dog{
 // คลาสแม่ที่ทำการประกาศเมธอดแบบ protected
 protected void run(){
  System.out.println("Dog run");
 }
}

class LittleDog extends Dog{ // คลาสลูก LittleDog สืบทอดคลาสจากคลาสแม่ที่ชื่อว่า Dog
 
 protected void run() {// ลูกสามารถ override เมธอดของคลาสแม่ได้
  super.run();
 }
 
 private void run2(){
  super.run(); // ลูกสามารถเรียกเมธอดของคลาสแม่ได้โดยตรง
 }
}

Default Access Modifier - การไม่ใช้ keyword ใดๆในการประกาศ Modifier (no modifier)

Default Access Modifier ก็คือการที่เราไม่กำหนดหรือไม่ประกาศ access modifier เอาไว้ข้างหน้า คลาส, ตัวแปร, เมธอด ฯลฯ ซึ่งเมื่อเราไม่ประกาศ access modifier เหล่านี้เอาไว้จะให้ คลาส, ตัวแปร, เมธอด ฯลฯ จะถูกเข้าถึงได้จากคลาสที่อยู่ภายใน package เดียวกันเท่านั้น

- ตัวอย่างการใช้ no modifier

package noModifierPackage;

public class NoModifier {
 // ตัวอย่างการประกาศตัวแปรแบบ no modifier
 String noModierString = "This is no modifier String";
 
 // ตัวอย่างการประกาศเมธอดแบบ no modifier
 String methodNoModifer(){
  return "This is method no modifier";
 }
}

class OtherClass{
 public void callNoModifierOtherClass(){
  NoModifier noModifier = new NoModifier();
  noModifier.noModierString = "Call no modifier by other class";// สามารถเรียก ตัวแปรที่ไม่ได้ทำการประกาศ modifier ผ่านทางคลาสอื่นๆ ได้เลย
  noModifier.methodNoModifer(); // เรียก method ที่ไม่ได้ทำการประกาศ modifier เอาไว้ได้เลย
 }
}

Private Access Modifier - private

การประกาศ access modifier เป็นแบบ private นั้นจะทำให้ เมธอด, ตัวแปร และคอนสตรัคเตอร์ นั้นสามารถถูกเรียกใช้ได้จากภายในคลาสเดียวกันเท่านั้น เรามักจะใช้ access modifier แบบ private เพื่อที่จะทำการห่อหุ้ม object (encapsulation) เพื่อที่จะทำการซ่อนข้อมูลบางอย่างเพื่อไม่ให้ภายนอกมองเห็น

- ตัวอย่างการใช้ private

public class PrivateModifierTest {
 private static String privateString = "This is private variable";
 
 private static void privateMethod(){
  System.out.println("This is private method");
 }
 
 public static void main(String[] args){
  System.out.println(privateString);
  privateMethod();
 }
}

อ่านต่อ »

วันพุธที่ 28 มกราคม พ.ศ. 2558

Java พื้นฐาน - Variable Types ชนิดของตัวแปร

ตัวแปรใน Java นั้นจะมีชนิดของตัวแปรอยู่ ซึ่งจะบ่งบอกถึงขนาดและขอบเขตที่สามารถใช้ตัวแปรนั้นได้ โดยชนิดของตัวแปรจะมีทั้งหมด 3 ชนิด

1. Local variables - ตัวแปรที่ถูกประกาศใน method, constructor, block

2. Instance variables - ตัวแปรของ object

3. Static variables - ตัวแปรของ Class

เราจะมาดูกันว่าชนิดของตัวแปรที่ประกาศเอาไว้นั้น แต่ละแบบมีความหมายอย่างไร

1. Local variables - ตัวแปรที่ถูกประกาศใน method, constructor หรือ block

Local variables เป็นตัวแปรที่ถูกประกาศใน method, constructors หรือ blocks โดยจะถูกสร้างขึ้นเมื่อ method, constructors หรือ block ถูกเรียกใช้ และจะถูกทำลายเมื่อสิ้นสุด method, constructors หรือ block โดยตัวแปรแบบ Local นั้นจะถูกมองเห็นเฉพาะขอบเขตที่ถูกประกาศเอาไว้เท่านั้น เช่น ถ้าประกาศตัวแปรเอาไว้ใน method ตัวแปรนั้นก็จะสามารถใช้งานได้ภายใน method นั้นเท่านั้น

ตัวแปรแบบ Local นั้นจะไม่มีค่า Default ดังนั้นเราจึงควรที่จะใส่ค่าให้กับตัวแปร Local ในตอนที่เราได้ทำการประกาศตัวแปร

ตัวอย่าง การประกาศตัวแปรแบบ Local

- ประกาศตัวแปรแบบ Local ไว้ใน method

public class Test {
 
 public static void main(String[] args) {

 }
 
 // Method ที่ทำการประกาศตัวแปร
 public static void declareVariableInMethod(){
  int i = 0; // ตัวแปรที่ถูกประกาศใน method
  System.out.println(i);
  // ตัวแปรจะถูกทำลายหลังจากจบ method
 }
 
}

- ประกาศตัวแปรแบบ Local ไว้ใน Constructor

public class Student {
 
 // ประกาศตัวแปร variableInConstructor ไว้ใน Constructor 
 public Student(){
  String variableInConstructor = "test"; // ตัวแปรที่ถูกประกาศไว้ใน Constructor
  
  // เมื้อสิ้นสุด Constructor ตัวแปรจะถูกทำลายไปด้วย
 }
 
}

- ประกาศตัวแปรแบบ Local ไว้ใน Block

block ใน Java นั้นก็เช่น If Else

public class Test {
 
 public static void main(String[] args) {
  
  // ตัวอย่างการประกาศตัวแปรแบบ Local ใน Block
  if(1 == 1){
   int i = 0; // ตัวแปรที่ถูกประกาศเอาไว้ใน Block
   
   // ตัวแปรจะสิ้นสุดเมื่อจบ block  
  }
 }
 
}

2. Instance variables - ตัวแปรของ object

ตัวแปรแบบ Instance นั้นจะถูกประกาศเอาไว้ในคลาส แต่จะอยู่ภายนอกของ method, constructor และ block ต่างๆ ซึ่งตัวแปรแบบ Instance นั้นจะถูกสร้างขึ้นก็ต่อเมื่อมีการสร้าง Object ขึ้นมา
การเรียกใช้ตัวแปรแบบ Instance นั้นสามารถเรียกใช้ภายใน method, constructor หรือใน block ได้

เรายังสามารถใส่ Access Modifiers ให้กับตัวแปรแบบ Instance ได้ซึ่งจะทำให้เราสามารถกำหนดระดับการเข้าถึงตัวแปรนั้นๆได้ เช่น กำหนดให้เห็นได้เฉพาะในคลาส หรือจะให้คลาสอื่นสามารถเห็นก็ได้ แต่โดยปกติแล้วตัวแปรแบบ Instance นั้นเราจะกำหนด Access Modifier ให้เป็น private เพื่อที่ตัวแปรนั้นๆจะถูกใช้ได้แค่ภายในคลาสที่ทำการประกาศตัวแปรเอาไว้เท่านั้น

หากเราไม่กำหนดค่าให้ตัวแปร Instance ตัวแปร Instance จะมีค่า Default ให้เองโดยอัตโนมัติ
ซึ่งขึ้นอยู่กับชนิดของตัวแปรข้อมูลที่เราได้ทำการประกาศไว้ เช่น ประกาศตัวแปรเอาไว้เป็น int i; ค่า default ของ i จะเท่ากับ 0 โดยอัตโนมัติ

ตัวอย่าง การประกาศตัวแปรแบบ Instance

public class Student {
 
 // ตัวแปรแบบ Instance โดยใช้ Access Modifier เป็น private เพื่อให้ตัวแปรเหล่านี้ถูกเห็นได้แค่ภายในคลาสนี้เท่านั้น
 private String instanceVariable; // ค่า Default ของ String จะเป็นค่า null
 private int i = 2; // เราสามารถทำการกำหนดค่าให้กับตัวแปรได้เลย
 
 // การเรียกใช้ตัวแปรใน Constructor
 public Student(){
  instanceVariable = "Test Instance Variable";
  i = 3;
 }

}

3. Static variables - ตัวแปรของ Class

ตัวแปรแบบ Static หรือตัวแปรของ Class นั้นจะมีการประกาศคล้ายๆ กับตัวแปรแบบ Instance โดยจะแตกต่างกันที่ ตัวแปรแบบ Static นั้นจะมีการประกาศคำว่า Static เอาไว้ข้างหน้าของตัวแปรเช่น static String testStatic; และข้อแตกต่างอีกอย่างหนึ่งก็คือ ตัวแปรแบบ Static จะเอาไว้ใช้กับคลาสเท่านั้น ซึ่งคลาสจะสามารถมีได้แค่ 1 คลาส ส่วนตัวแปรแบบ Instance นั้นจะเกิดขึ้นก็ต่อเมื่อมีการสร้าง Object ขึ้นมา ซึ่ง Object ต่างๆก็จะเกิดขึ้นมาจากคลาส แต่คลาส 1 คลาสสามารถสร้าง Object ได้ไม่จำกัด โดยที่ตัวแปรแบบ Instance นั้นจะใช้ได้แค่ใน Object เดียว ซึ่งถ้าหากเราทำการสร้าง Object ใหม่อีกเราก็จะได้ตัวแปรอันใหม่สำหรับ Object ที่เราสร้างใหม่ ซึ่งไม่เกี่ยวกับ Object เดิมที่เคยสร้างไว้

การประกาศตัวแปรแบบ Static นั้นใช้หลักการเดียวกับการประกาศตัวแปรแบบ Instance ได้เลย เพียงแต่เราจะต้องใส่คำว่า static เอาไว้ที่ข้างหน้าของตัวแปรนั้นๆ

ตัวแปรแบบ Static จะถูกสร้างขึ้นเมื่อโปรแกรมเริ่มทำงาน และจะถูกทำลายเมื่อโปรแกรมสิ้นสุดการทำงาน และเราสามารถกำหนด Access Modifier ได้เช่นเดียวกับ ตัวแปรแบบ Instance แต่ ตัวแปร Static ควรจะใช้ Access Modifier เป็น public เพื่อให้สามารถเรียกใช้ได้จากภายนอก Class

ค่า Default ของตัวแปรแบบ Static นั้นก็เหมือนกับ ตัวแปรแบบ Instance เลย แต่จะมีพิเศษกว่าก็ตรงที่สามารถกำหนดค่าของตัวแปรภายใน static block ได้ด้วย

หากเราประกาศโดยใช้ keyword public static final เราจะต้องตั้งชื่อตัวแปรให้เป็นตัวอักษรพิมพ์ใหญ่ให้หมดทุกตัวหากต้องการเว้นวรรคคำควรใช้เครื่องหมาย _

เช่น public static final THIS_IS_STATIC_FINAL_VARIABLE

ตัวอย่าง การประกาศตัวแปรแบบ Static

ตัวอย่างคลาสที่ทำการประกาศตัวแปรแบบ static

// ตัวอย่างคลาสที่ทำการประกาศตัวแปรแบบ static
public class TestStaticVariable {

 private static String privateStatic; // การประกาศตัวแปร static โดยไม่กำหนดค่าให้ โปรแกรมจะทำการใส่ค่า default ให้โดยอัตโนมัติ ซึ่งค่า default ของ String ก็คือค่า null 
 public static String publicStatic; // เราสามารถประกาศคัวแปร static โดยใช้ Access Modifier ได้ซึ่งในที่ี้นี้จะคำว่า public
 
 public static final String STATIC_FINAL_VARIABLE = "test";// การประกาศโดยใช้คำว่า final มาร่วมกับ static เราจะต้องตั้งชื่อตัวแปรให้เป็นตัวพิมพ์ใหญ่ให้หมด และเราจะต้องทำการกำหนดค่าให้ตัวแปรทุกครั้งที่ประกาศ เพราะเราไม่สามารถใช้ค่า Default ได้
 
}

ตัวอย่างคลาสที่การเรียกใช้งานตัวแปรแบบ static

// ตัวอย่างคลาสที่การเรียกใช้งานตัวแปรแบบ static 
public class CallStaticVariable {

 public static void main(String[] args) {
  // เราจะลองเรียกตัวแปร static หรือตัวแปรของ Class TestStaticVariable
  // วิธีเรียกจะเป็นดังนี้
  //String test = TestStaticVariable.privateStatic; // บรรทัดนี้จะ error เพราะตัวแปร static ของคลาส TestStaticVariable ถูกประกาศการเข้าถึงเป็นแบบ private จะทำให้ไม่สามารถเรียกใช้ตัวแปรนี้ผ่านคลาสอื่นๆได้ 
  String test2 = TestStaticVariable.publicStatic; // ตัวแปร static นี้ถูกประกาศการเข้าถึงเอาไว้เป็นแบบ public ทำให้สามารถเรียกใช้งานตัวแปรนี้ผ่านทางคลาส CallStaticVariable ได้
  String test3 = TestStaticVariable.STATIC_FINAL_VARIABLE; // ตัวอย่างการเรียกใช้ตัวแปร static ที่มีการประกาศเอาไว้แบบ final
 }

}

https://www.facebook.com/coachingcode

อ่านต่อ »

วันศุกร์ที่ 23 มกราคม พ.ศ. 2558

Java Basic Data Type - ชนิดข้อมูลพื้นฐาน (พร้อมวิดีโอ)

Java Basic Data Type - ชนิดข้อมูลพื้นฐาน

ตัวแปรคือสิ่งที่ใช้หน่วยความจำ(memory) เพื่อใช้ในการเก็บค่า นั่นก็หมายความว่าทุกๆครั้งที่เราทำการสร้างตัวแปรขึ้นมา 1 ตัว จะทำให้เกิดการจองพื้นที่ในหน่วยความจำขึ้นมาทันที โดยจะใช้พื้นที่ไปเท่าไรนั้น ขึ้นอยู่กับชนิดของตัวแปรที่เราได้ทำการประกาศเอาไว้นั่นเอง

ใน Java จะมีชนิดข้อมูลอยู่ 2 ชนิดด้วยกัน
1. Primitive Data Types
2. Reference Data Types

1. Primitive Data Types

ตัวแปรที่มีการประกาศแบบ Primitive จะเก็บค่าที่ถูกกำหนดเอาไว้ในหน่วยความจำเลย

Java มีชนิดข้อมูลพื้นฐาน (Primitive Data Types) 8 ประเภท

ชนิดข้อมูล	ขนาด	เก็บค่า	ค่าพื้นฐาน	ตัวอย่าง	ค่าต่ำสุด	ค่าสูงสุด
boolean	1 bit	true หรือ false	false	false	false	true
char	16 bits	ตัวอักษร Unicode	\u0000	A	\u0000 หรือ 0	\uffff หรือ 65,535
byte	8 bits	ตัวเลขที่มีค่าเป็น บวก หรือ ลบ	0	-60 หรือ 120	-128	127
short	16 bits	ตัวเลขที่มีค่าเป็น บวก หรือ ลบ	0	-15,000 หรือ 32,000	-32,768	32,767
int	32 bits	ตัวเลขที่มีค่าเป็น บวก หรือ ลบ	0	-100,000 หรือ 300,000	-2,147,483,648	2,147,483,647
long	64 bits	ตัวเลขที่มีค่าเป็น บวก หรือ ลบ	0L	-100,000L หรือ 300,000L	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
float	32 bits	ตัวเลขทศนิยม	0.0f	256.5f	ตามมาตรฐาน IEEE 754	ตามมาตรฐาน IEEE 754
double	64 bits	ตัวเลขทศนิยม	0.0	345.6	ตามมาตรฐาน IEEE 754	ตามมาตรฐาน IEEE 754

ตัวอย่างการประกาศตัวแปร เช่น
- boolean b = true;
- char c = 'A';
- byte bt = 10;
- short s = 20;
- int i = 30;
- long l = 40L;
- float f = 0.5f;
- double d = 345.4;
สังเกตได้ว่าการประกาศตัวแปรที่เป็นแบบ Primitive Data Type เราจะใช้ตัวอักษรพิมพ์เล็กหมดเลย

2. Reference Data Types

ตัวแปร Reference เป็นตัวแปรที่ใช้เข้าถึง Object โดยจะเก็บค่าที่เป็นที่อยู่ของ Object นั้นๆเอาไว้ ไม่ได้เก็บค่าของ object โดยตรง ซึ่งแตกต่างจากตัวแปรแบบ Primitive ซึ่ง Primitive จะทำการเก็บค่าที่ถูกกำหนดเอาไว้ในหน่วยความจำได้เลย
ตัวแปร Reference จะมีค่าพื้นฐานเป็นค่า null โดยที่ตัวแปร reference จะสามารถอ้างถึง object ใดๆก็ได้ตาม Type ของตัวแปรที่ถูกประกาศไว้
ตัวอย่างการประกาศตัวแปรแบบ reference เช่น
- String str = "Hello World";
- Student student = new Student();

Java Literals

Literal ก็คือ ค่าต่างๆที่เรากำหนดเอาไว้ในตัวแปร source code ที่เราเขียนเอาไว้โดยจะนำค่านั้นไปใช้ได้โดยตรงเลยโดยที่ไม่ต้องผ่านการประมวลผล
เช่น
- char d = 'D';
- byte b = 60;

ตัวแปรที่เป็นชนิด byte, short, int, long เราสามรถที่จะกำหนดค่าโดยจะใช้เป็น เลขฐานสิบ(decimal) เลขฐานแปด(octal) หรือเลขฐานสิบหก(hexadecimal) ได้ เช่น
- int decimal = 12; // เมื่อนำค่าไปแสดงจะได้ 12
- int octal = 0123; // เมื่อนำค่าไปแสดงจะได้ 83
- int hexa = 0x80; // เมื่อนำค่าไปแสดงจะได้ 128

String literals จะเป็นข้อความต่างๆ โดยเราจะใส้ข้อความเอาไว้ภายใน ""(double quotes) เช่น

- String hello = "Hello world";
- char c = 'A';

เราสามารถประกาศค่าที่เป็น unicode ลงในตัวแปร String และ char ได้เลย ตามนี้ครับ

- String unicodeString = "\u0E01"; // เมื่อนำไปแสดงผลจะได้ตัวอักษร ก
- char unicodeChar = "\u0E01"; // เมื่อนำไปแสดงผลจะได้ตัวอักษร ก

Java ยังสนับสนุนการใช้ อักขระพิเศษมาใช้ร่วมกับ String และ char ได้อีกด้วย

Notation	Character represented
\n	Newline (0x0a) ขึ้นบรรทัดใหม่
\r	Carriage return (0x0d) ขึ้นบรรทัดใหม่
\f	Formfeed (0x0c)
\b	Backspace (0x08)
\s	Space (0x20)
\t	tab
\"	Double quote
\'	Single quote
\\	backslash
\ddd	Octal character (ddd) เลขฐานแปด
\uxxxx	Hexadecimal UNICODE character (xxxx)

https://www.facebook.com/coachingcode

อ่านต่อ »

สอนติดตั้งโปรแกรมเพื่อใช้งาน Java บน Eclipse (พร้อมวิดีโอ)

สอนติดตั้งโปรแกรมเพื่อใช้งาน Java บน Eclipse

โปรแกรมที่ต้องลงก่อนเพื่อที่จะใช้งาน Java

1. JDK version 1.6.0_45 หรือจะโหลด version อื่นๆก็ได้นะครับแต่ขอให้เป็น version 6
2. โปรแกรม Eclipse เอาไว้เขียน Java นะครับ

https://www.facebook.com/coachingcode

อ่านต่อ »

สอน Java พื้นฐานอย่างง่าย - พื้นฐานไวยากรณ์ (Basic Syntax)

พื้นฐานไวยากรณ์ (Basic Syntax)

               ก่อนอื่นเรามารู้จักคำที่ใช้บ่อยในการเขียน JAVA กันก่อน ซึ่งคำที่จะอธิบายทั้งหมดนี้จะอธิบายเพื่อให้เข้าใจเกี่ยวกับคำเหล่านี้ เพื่อที่จะใช้ในการอ้างอิงในหากพบเจอในส่วนของบทอื่นๆ

Object - Object จะมี State และ Behaviors
               State หรือ สถานะ ก็จะคือพวกตัวแปรต่างๆที่เอาไว้เก็บค่า
               Behaviors หรือ พฤติกรรมหรือการปฏิบัติ ก็คือ method ที่เปรียบเสมือนการแสดงพฤติกรรมต่างๆ หรือการทำงานต่างๆ

ตัวอย่างเช่น Dog จะมี State คือ name, breed(สายพันธุ์) ที่คอยระบุลักษณะของ Object(วัตถุ) นั้นๆ
ส่วน Behavior หรือพฤติกรรมของ Dog นั้นคือ เห่า, กิน, นอน ฯลฯ

Class - Class ก็คือแบบแปลนหรือพิมพ์เขียว ที่ใช้อธิบาย State(สถานะ) และ Behavior(พฤติกรรม) ของ Object(วัตถุ)

Method - ก็คือ โดยทั่วไป method ก็คือ Behavior หรือ พฤติกรรม

Instance Variables - คือตัวแปรของ Object

Basic syntax - ไวยากรณ์พื้นฐานที่ควรรู้

Case Sensitivity - ก็คือถึงแม้ว่าจะเป็นตัวอักษรเดียวกัน แต่ต่างกันแค่ตัวพิมพ์เล็ก ตัวพิมพ์ใหญ่ Java ก็จะถือว่าเป็นคนละตัวกัน เช่น Hello กับ hello

Class Names - ชื่อคลาสควรขึ้นต้นด้วยตัว พิมพ์ใหญ่ เช่น MyClass โดยที่คำที่ต่อมาที่เป็นคำใหม่ก็ต้องขึ้นต้นด้วยตัวพิมพ์ใหญ่

Program File Name - ชื่อของไฟล์ Java ควรจะเหมือนกับชื่อของ Class

public static void main(String args[]) - Java จะเริ่มทำงานที่ main method

Java Identifiers - การตั้งชื่อคลาส, ตัวแปร, method เราจะเรียกว่า Identifier

ในการเขียน Java นั้นจะมีหลักของการตั้งชื่อพวกคลาส ตัวแปร method ที่เราควรจะรู้เอาไว้ เช่น

- ต้องตั้งชื่อเริ่มต้นด้วยตัว A-Z หรือ a-z หรือ $ หรือ _

- คำที่เป็น keyword หรือ reserved word จะไม่สามารถนำมาตั้งชือ่ได้

- การตั้งชื่อแม้เพียงอักษรตัวพิมพ์เล็กกับตัวพิมพ์ใหญ่ ก็ถือว่ามีความแตกต่างกัน เช่น A กับ a

https://www.facebook.com/coachingcode

อ่านต่อ »

วันอาทิตย์ที่ 18 มกราคม พ.ศ. 2558

JSF 2 - Managed Beans

Managed Beans คือ อะไร

Managed Beans ก็คือ java bean ที่ JSF จะนำมาใช้เป็นคลาสกลางที่เอาไว้เชื่อมต่อกับหน้าเว็บ

ซึ่งค่าจากตัวแปรใน Managed Beans ที่นำมาใช้กับหน้าเว็บ ก็คือ properties หรือตัวแปรที่ประกาศเอาไว้ในคลาส โดยจะต้องมี getter และ setter method เพื่อให้สามารถเรียกใช้ตัวแปรเหล่านี้ผ่านทางหน้าเว็บได้

ใน JSF 2 นี้ก่อนที่เราจะใช้งาน Managed Beans ได้เราจะต้องทำการตั้งค่าก่อน

โดยวิธีการที่เราจะทำได้นั้นมี 2 วิธี

1. ตั้งค่าผ่าน XML

2. ตั้งค่าโดยใช้ Annotation

ตัวอย่างการตั้งค่า

1. ตั้งค่าผ่าน XML

การตั้งค่าผ่าน XML นี้เราจะต้องไปตั้งค่าที่ไฟล์ที่ชื่อว่า faces-config.xml โดยตั้งค่าดังนี้

<managed-bean>
  <managed-bean-name>helloWorld</managed-bean-name>
  <managed-bean-class>com.learning.jsf2.HelloWorld</managed-bean-class>
  <managed-bean-scope>request</managed-bean-scope>
</managed-bean>

- <managed-bean-name>helloWorld</managed-bean-name> บรรทัดนี้จะบอกว่าชื่อที่เราใช้อ้างอิงคลาสเพื่อเรียกใช้จากหน้าเว็บของเราจะใช้ชื่ออะไร ซึ่งเราไม่จำเป็นต้องตั้งให้เหมือนชื่อคลาสก็ได้ แต่เราควรจะตั้งให้เหมือนชื่อคลาสโดยใช้อักษรตัวแรกเป็นตัวพิมพ์เล็ก เพื่อให้ง่ายต่อการใช้งานในการค้นหา
- <managed-bean-class>com.learning.jsf2.HelloWorld</managed-bean-class> บรรทัดนี้เอาไว้บอกที่อยู่ของคลาส Managed Bean ซึ่งจะประกาศแบบเต็มๆโดยขึ้นต้นด้วยชื่อ package ก่อนแล้วตามด้วยชื่อคลาส
- <managed-bean-scope>request</managed-bean-scope> บรรทัดนี้จะบอก scope ของ Managed Bean

ซึ่งมีทั้งหมด 5 Scope ดังนี้ครับ

1. Application Scope - มีการประกาศ Scope ดังนี้ครับ

<managed-bean-scope>application</managed-bean-scope>

managed bean ที่ทำการประกาศ Scope แบบ Application จะถูกสร้างครั้งแรกเมื่อมี HTTP request เข้ามาเกี่ยวกับ bean นั้นๆ และจะถูกทำลายเมื่อมีการ shut down Web Application

2. Session Scope - มีการประกาศ Scope ดังนี้ครับ

<managed-bean-scope>session</managed-bean-scope>

managed bean ที่ประกาศ Scope แบบ Session จะถูกสร้างขึ้นครั้งแรกเมื่อมี HTTP request ที่เกี่ยวข้องกับ bean นั้นๆใน Session และจะถูกทำลายเมื่อ session หมดเวลา หรือ session ถูกทำลาย หรือ session ไม่ถูกต้อง

3. Request Scope - มีการประกาศ Scope ดังนี้ครับ

<managed-bean-scope>request</managed-bean-scope>

managed bean ที่ประกาศ Scope แบบ Request จะถูกสร้างขึ้นครั้งแรกเมื่อมี HTTP request ที่เกี่ยวข้องกับ bean นั้นๆ และจะถูกทำลายเมื่อ HTTP response ของ HTTP request ที่สร้าง bean นั้นๆ สิ้นสุดลง

4. View Scope - มีการประกาศ Scope ดังนี้ครับ

<managed-bean-scope>view</managed-bean-scope>

managed bean ที่ประกาศ Scope แบบ View จะถูกสร้างขึ้นครั้งแรกเมื่อมี HTTP request ที่เกี่ยวข้องกับ bean นั้นๆ ซึ่งจะมีชีวิตอยู่ภายใน JSF ที่เป็น View เดียวกัน และจะถูกทำลายเมื่อเราใช้งาน View อื่นๆ

5. None Scope - มีการประกาศ Scope ดังนี้ครับ

<managed-bean-scope>none</managed-bean-scope>

managed bean ที่ประกาศ Scope แบบ None จะถูกสร้างขึ้นครั้งแรกเมื่อมีการเรียกใช้ EL Expression เช่น #{helloBean.message} และจะถูกทำลายเมื่อการประมวลผล EL Expression สิ้นสุดลง

2. การตั้งค่าโดยการใช้ Annotation

เราสามารถประกาศ Scope ของ Managed Bean แบบ Annotation ได้โดยการประกาศ

@ชื่อScope ประกาศไว้ที่หัวของ Class เช่น

@SessionScoped

public class testSessionScoped {

}

ซึ่งการประกาศแบบ Annotation นี้จะมีวิธีการประกาศอยู่ 6 วิธีด้วยกัน

1. @ApplicationScoped
2. @SessionScoped
3. @RequestScoped
4. @ViewScoped
5. @NoneScoped
6. @CustomScoped

โดยการประกาศ 5 แบบแรกนั้นก็เหมือนที่ผมอธิบายเรื่องการประกาศแบบ xml เลยครับ
แต่จะมีแตกต่างที่ข้อ 6 ที่เป็น @CustomScoped ซึ่ง Bean ที่ประกาศโดยใช้ Scope แบบ Custom นี้จะมีชีวิตขึ้นอยู่กับ Custom map ที่เราได้ทำการ set เอาไว้

อ่านต่อ »

วันเสาร์ที่ 17 มกราคม พ.ศ. 2558

สร้าง Application แรกด้วย JSF 2

ฝาก code ไว้ใน Blog

download jstl

code ที่ใช้ในวิดีโอ นะครับ

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
   "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
   <title>JSF Tutorial!</title>
</head>
<body>
test
<br/>
   #{helloWorld.message}
</body>
</html>

https://www.facebook.com/coachingcode

อ่านต่อ »

วันพุธที่ 14 มกราคม พ.ศ. 2558

สอน Java พื้นฐานอย่างง่าย - Java Virtual Machine (JVM)

Java Virtual Machine (JVM)

Java virtual machine คืออะไร

Java virtual machine หรือ JVM ก็คือโปรแกรมคอมพิวเตอร์ที่ประมวลโปรแกรมได้เสมือนเป็นเครื่องจริงๆ ซึ่งตัว JVM นี้จะถูกเขียนขึ้นมาอย่างแตกต่างๆ สำหรับแต่ละแพลตฟอร์ม เช่น Window, UNIX, หรือ Mac OS เพื่อให้รองรับการรันภาษา Java ได้ทุกๆแพลตฟอร์ม

โปรแกรม Java จะถูกคอมไพล์โดย Java คอมไพเลอร์ ให้อยู่ในรูปแบบ bytecode ซึ่ง JVM จะทำการแปล bytecode และจะทำการประมวลผลโปรแกรม Java

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

https://www.facebook.com/coachingcode

อ่านต่อ »

สอน Java พื้นฐานอย่างง่าย - Compilation and Interpretation

Compilation and Interpretation

ภาษาระดับสูง (high level language) เช่น C, C++, Java ถูกสร้างขึ้นมาเพื่อให้สามารถเขียนโปรแกรมได้ง่าย ทำให้เราไม่ต้องเข้าใจโครงสร้าง และชุดคำสั่งของหน่วยประมวลผลมากนัก ก็สามารถเขียนโปรแกรมได้

อย่างไรก็ตามหน่วยประมวลผลทั่วไปไม่สามารถทำงานกับโปรแกรมภาษาระดับสูงได้โดยตรงจึงต้องมีตัวแปลภาษาที่เปลี่ยนโปรแกรมต้นฉบับที่เราเขียนขึ้นมา (source code) ที่เขียนด้วยภาษาระดับสูง ให้เป็นชุดคำสั่งที่หน่วยประมวลผลสามารถเข้าใจได้ (executable code)

โดยมีวิธีแปลอยู่ 2 แบบ คือ

1. Interpretation ซึ่งเราจะเรียกตัวแปลภาษาแบบนี้ว่า Interpreter(อินเตอร์พรีเตอร์) ซึ่งทำการแปลง source code ให้เป็น executable code ทีละบรรทัดและทำงาน จากนั้นก็จะทำแบบเดิมไล่ลงไปทีละบรรทัด ซึ่งแบบนี้จะอธิบายง่ายๆว่า แปลไปประมวลผลไป

2. Compilation ซึ่งเราจะเรียกตัวแปลภาษาแบบนี้ว่า Compiler(คอมไพเลอร์) จะทำการวิเคราะห์ source code ก่อน แล้วจะได้ executable code เพื่อนำมาประมวลผลต่อไป ซึ่งแบบนี้จะอธิบายง่ายๆว่า แปลให้เสร็จทั้งหมดก่อน แล้วค่อยนำมาประมวลผล

ภาพด้านล่างจะบอกกระบวนการของการนำ code JAVA ที่เราเขียนไปใช้งานนะครับ

https://www.facebook.com/coachingcode

อ่านต่อ »

สอน Java พื้นฐานอย่างง่าย - Overview

สอน Java พื้นฐานอย่างง่าย

Java Technology

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

มาเริ่มกันเลยครับ

Java technology นั้นเป็นทั้งภาษาเขียนโปรแกรมและแพลตฟอร์ม

ภาษา Java ถูกออกแบบมาเพื่อการพัฒนา Application บนความแตกต่างกันทางระบบปฏิบัติการที่ต่างแพลตฟอร์มกัน ซึ่งเราสามารถเขียนครั้งเดียวและสามารถใช้ได้บนทุกแพลตฟอร์มไม่ว่าจะเป็น Window, UNIX, หรือ Mac OS

ภาษา Java นั้นมีต้นกำเนิดมาจากส่วนหนึ่งของโครงการวิจัยเพื่อพัฒนาซอฟท์แวร์สำหรับอุปกรณ์ network ที่หลากหลายและ embedded systems โดยมีเป้าหมายในการพัฒนาขนาดเล็ก มีความน่าเชื่อถือ เคลื่อนย้ายง่าย สามารถแจกจ่ายได้ และเป็นเป็นแพลตฟอร์มที่ทำงานแบบ real-time

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

อีกข้อได้เปรียบของภาษา Java ก็คือ มีชุดการทำงานของคลาสต่างๆ (เรียกว่า library) เป็นจำนวนมากมาให้เราใช้งานโดยที่ไม่ต้องเสียค่าใช้จ่ายใดๆ อีกทั้ง Java ยังถูกออกแบบมาเพื่อความปลอดภัยโดยไม่ยอมให้มีการอ้างอิง Address ของตัวแปรโดยการใช้ Pointer รวมทั้งยังมีกลไกจัดการหน่วยความจำที่ไม่ได้ใช้ เพื่อให้นำกลับมาใช้ใหม่ได้ โดยที่ไม่ต้องทำการคืนหน่วยความจำเหมือนภาษาอื่นๆ เช่น ภาษา C

Java ยังมีความน่าสนใจในเรื่องการจัดการกับข้อผิดพลาด หรือที่เรียกว่า Exception Handling ซึ่งกลไกนี้จะช่วยให้โปรแกรมสามารถทำงานต่อไปได้หากเกิด error

ทีนี้มาดูจุดเด่นของ Java เป็นเรื่องๆกันครับ

Object Oriented - Java นั้นมีกลไกการเขียนโปรแกรมเชิงวัตถุ

Platform independent - ไม่ขึ้นกับ Platform ใดๆ คือสามารถเขียนครั้งเดียว รันได้ทุกที่

Simple - Java ถูกออกแบบมาเพื่อให้ง่ายต่อการเรียนรู้

Secure - Java มีฟังก์ชันเกี่ยวกับความปลอดภัยให้ใช้งาน เช่นการเข้ารหัส

Architectural-neutral - Java คอมไพเลอร์จะทำการสร้าง architecture-neutral object file format ที่จะทำให้ code ที่ถูกคอมไพล์สามารถประมวลผลได้บนเครื่องใดก็ได้ที่มี Java virtual machine

Portable - เนื่อจากความที่เป็น Architectural-neutral ทำให้เราสามารถนำ code ที่เราเขียนเอาไว้ไปรันบนเครื่องไหนๆก็ได้ที่มี Java virtual machine

Robust - มีความแข็งแกร่ง เนื่องจาก Java จะเน้นการตรวจสอบ error ในช่วง compile time และ runtime

Multithreaded - เราสามารถที่จะเขียน Java ให้รันพร้อมๆกันได้ในเวลาเดียวกัน

Interpreted - Java byte code จะถูกแปลงให้เป็น ภาษา native ที่ทำให้เครื่องที่ทำการรันเข้าใจ

High Performance - ด้วย Just-In-Time compilers ทำให้ Java มีประสิทธิภาพที่สูง

Distributed - Java ถูกออกแบบมาเพื่อให้สามารถแบ่งปันบน Internet ได้

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

https://www.facebook.com/coachingcode

อ่านต่อ »

วันพุธที่ 7 มกราคม พ.ศ. 2558

JSF Life Cycle (วัฏจักรชีวิตของ JSF)

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

JSF application life cycle ประกอบด้วย 6 ส่วน

1. Restore view phase
2. Apply request values phase
3. Process validations phase
4. Update model value phase
5. Invoke application phase
6. render response phase

Phase 1 : Restore view

JSF จะเริ่ม Restore View Phase ในทันทีที่มีการกด link หรือ button

จากนั้น JSF จะรับ request ซึ่งใน Phase นี้ JSF จะทำการสร้าง view ซึ่งจะผูกตัวจัดการ event (event handler) และ validators กับ UI Components และทำการ save ลงใน view ซึ่งอยู่ใน FaceContext instance

Phase 2 : Apply request values

หลังจากที่ component tree ถูกสร้างหรือถูกเก็บใน view component tree แต่ละตัวจะทำการแปลงค่าเพื่อเก็บเป็น request parameter

ถ้าหากเกิด error ในการแปลงค่า จะมี error message ที่ถูกสร้างโดยอัตโนมัติเก็บไว้ใน FacesContext ในรูปแบบ queue ซึ่ง error message เหล่านี้จะถูกแสดงผลใน render response phase

Phase 3 : Process validation

ใน phase นี้ จะเป็น phase ที่ทำการตรวจสอบข้อมูลจากตัว validator ถ้าการ validate ผิดจะทำมี error message ออกมาและจะทำการกระโดดข้ามไปที่ render reponse phase ทันที

Phase 4 : Update model values

หลังจากที่ JSF ได้ทำการตรวจสอบข้อมูลใน phase validation เรียบร้อยแล้ว JSF จะทำการ update ค่าต่างๆลงที่ bean properties ซึ่งก็คือ field ของ java bean ที่ผูกกับ input component

Phase 5 : Invoke application

ใน phase นี้ JSF จะจัดการ event ในทุกๆ application-level เช่น การกด submit form หรือการ link ไปที่หน้าอื่นๆ

Phase 6 : Render response

ใน phase นี้ JSF จะทำการแสดงผลหน้าเพจ หลังจากที่ข้อมูลต่างๆถูกแสดงผลแล้ว จะมีการเก็บ reponse state เอาไว้เพื่อใช้ใน request ครั้งต่อๆไป

จบเรื่อง JSF Life Cycle กันแล้วนะครับ ซึ่งผมจะอธิบายส่วนเหล่านี้พร้อมกับการเขียน code ในส่วนต่อๆไปนะครับ ^ ^

https://www.facebook.com/coachingcode

อ่านต่อ »

Navigation Menu

วันอาทิตย์ที่ 22 กุมภาพันธ์ พ.ศ. 2558

Basic Operators

1. Arithmetic Operators

2. Relational Operators

3. Bitwise Operators

3.1 Logical Bitwise Operators ซึ่งจะได้แก่

3.2 Assignment bitwise operators ได้แก่

4. Logical Operators

5. Assignment Operators

6. Misc Operators

6.1 Conditional Operator ( ? : )

6.2 instanceof Operator

วันพฤหัสบดีที่ 5 กุมภาพันธ์ พ.ศ. 2558

Access Modifier

Java Access Modifier

Public Access Modifier - public

- ตัวอย่างการใช้ public

Protected Access Modifier - protected

- ตัวอย่างการใช้ protected

Default Access Modifier - การไม่ใช้ keyword ใดๆในการประกาศ Modifier (no modifier)

- ตัวอย่างการใช้ no modifier

Private Access Modifier - private

- ตัวอย่างการใช้ private

วันพุธที่ 28 มกราคม พ.ศ. 2558

Java พื้นฐาน - Variable Types ชนิดของตัวแปร

1. Local variables - ตัวแปรที่ถูกประกาศใน method, constructor, block

2. Instance variables - ตัวแปรของ object

3. Static variables - ตัวแปรของ Class

1. Local variables - ตัวแปรที่ถูกประกาศใน method, constructor หรือ block

ตัวอย่าง การประกาศตัวแปรแบบ Local

- ประกาศตัวแปรแบบ Local ไว้ใน method

- ประกาศตัวแปรแบบ Local ไว้ใน Constructor

- ประกาศตัวแปรแบบ Local ไว้ใน Block

2. Instance variables - ตัวแปรของ object

ตัวอย่าง การประกาศตัวแปรแบบ Instance

3. Static variables - ตัวแปรของ Class

ตัวอย่าง การประกาศตัวแปรแบบ Static

ตัวอย่างคลาสที่ทำการประกาศตัวแปรแบบ static

ตัวอย่างคลาสที่การเรียกใช้งานตัวแปรแบบ static

วันศุกร์ที่ 23 มกราคม พ.ศ. 2558

Java Basic Data Type - ชนิดข้อมูลพื้นฐาน

1. Primitive Data Types

Java มีชนิดข้อมูลพื้นฐาน (Primitive Data Types) 8 ประเภท

2. Reference Data Types

Java Literals

Java ยังสนับสนุนการใช้ อักขระพิเศษมาใช้ร่วมกับ String และ char ได้อีกด้วย

สอนติดตั้งโปรแกรมเพื่อใช้งาน Java บน Eclipse

โปรแกรมที่ต้องลงก่อนเพื่อที่จะใช้งาน Java

พื้นฐานไวยากรณ์ (Basic Syntax)

Basic syntax - ไวยากรณ์พื้นฐานที่ควรรู้

Java Identifiers - การตั้งชื่อคลาส, ตัวแปร, method เราจะเรียกว่า Identifier

วันอาทิตย์ที่ 18 มกราคม พ.ศ. 2558

Managed Beans คือ อะไร

ตัวอย่างการตั้งค่า

1. ตั้งค่าผ่าน XML

2. การตั้งค่าโดยการใช้ Annotation

ซึ่งการประกาศแบบ Annotation นี้จะมีวิธีการประกาศอยู่ 6 วิธีด้วยกัน

วันเสาร์ที่ 17 มกราคม พ.ศ. 2558

สร้าง Application แรกด้วย JSF 2

code ที่ใช้ในวิดีโอ นะครับ

วันพุธที่ 14 มกราคม พ.ศ. 2558

Java Virtual Machine (JVM)

Java virtual machine คืออะไร

Compilation and Interpretation

ภาพด้านล่างจะบอกกระบวนการของการนำ code JAVA ที่เราเขียนไปใช้งานนะครับ

สอน Java พื้นฐานอย่างง่าย

Java Technology

มาเริ่มกันเลยครับ

ทีนี้มาดูจุดเด่นของ Java เป็นเรื่องๆกันครับ

วันพุธที่ 7 มกราคม พ.ศ. 2558

JSF Life Cycle (วัฏจักรชีวิตของ JSF)

JSF application life cycle ประกอบด้วย 6 ส่วน

Phase 1 : Restore view

Phase 2 : Apply request values

Phase 3 : Process validation

Phase 4 : Update model values

Phase 5 : Invoke application

Phase 6 : Render response