Basic Operators

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);
  }

อ่านต่อ »

Access Modifier

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();
 }
}

อ่านต่อ »

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

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
 }

}

Tweet

https://www.facebook.com/coachingcode

อ่านต่อ »

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)

Tweet

https://www.facebook.com/coachingcode

อ่านต่อ »

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

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

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

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

Tweet

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

Tweet

https://www.facebook.com/coachingcode

อ่านต่อ »

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 เอาไว้

อ่านต่อ »