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

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;


OperatorDescriptionExample
&&จะเป็นค่า 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

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


อ่านต่อ »
เขียนโดย ที่ ไม่มีความคิดเห็น:
สมัครสมาชิก: บทความ (Atom)