ตัวดำเนินการตัวเลขในภาษาจาวา

สวัสดี! วัน นี้ เราจะพิจารณาหัวข้อที่สำคัญมาก นั่นคือตัวดำเนินการตัวเลขใน Java ในการเขียนโปรแกรม ตัวเลขมีอยู่ทุกที่ หากคุณเจาะลึกและจำโรงเรียนมัธยมได้ คุณอาจจำได้ว่าคอมพิวเตอร์แสดงข้อมูลทั้งหมดในรูปแบบตัวเลข: การรวมกันของศูนย์และหนึ่งหรือที่เรียกว่ารหัสไบนารี มีตัวดำเนินการตัวเลขมากมายในการ เขียน โปรแกรม ดังนั้นเราจะใช้ตัวอย่างเพื่อสำรวจตัวดำเนินการที่สำคัญที่สุด :) เริ่มจากตัวดำเนินการที่ง่ายที่สุด: ตัวดำเนินการทางคณิตศาสตร์ +เหล่านี้คือตัวดำเนินการการบวก ( ) การลบ ( -) การคูณ ( *) และการหาร ( /) ที่รู้จักกันดี

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       System.out.println(x+y);
       System.out.println(x-y);
       System.out.println(x*y);
       System.out.println(x/y);
   }
}

เอาต์พุตคอนโซล: 1032 966 32967 30 คุณใช้ทั้งหมดนี้แล้ว สำหรับกลุ่มนี้ คุณสามารถเพิ่ม%ตัวดำเนินการที่เหลือหรือโมดูโล ( )

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 33%2;
       System.out.println(y);
   }
}

เอาต์พุตคอนโซล: 1 ในตัวอย่างนี้ เราหาร 33 ด้วย 2 ซึ่งได้ 16 โดยมี "ส่วนท้าย" พิเศษ (หนึ่ง) ที่หารด้วย 2 ไม่ได้ "ส่วนท้าย" นี้เป็นผลลัพธ์ของการดำเนินการ "ส่วนที่เหลือจากการหาร" Java ยังใช้การเปรียบเทียบ/ตัวดำเนินการเชิงสัมพันธ์ (เช่นเดียวกับในวิชาคณิตศาสตร์) พวกเขาอาจคุ้นเคยกับคุณจากโรงเรียนเช่นกัน:

• เท่ากับ ( ==)
• มากกว่า ( >)
• น้อยกว่า ( <)
• มากกว่าหรือเท่ากับ ( >=)
• น้อยกว่าหรือเท่ากับ ( <=)
• ไม่เท่ากัน ( !=)

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

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x=y);// We expect false to be displayed
   }
}

เอาต์พุตคอนโซล: 999 อ๊ะ! เห็นได้ชัดว่านี่ไม่ใช่ผลลัพธ์ที่เราคาดไว้ เป็นประเภทข้อมูลที่แตกต่างไปจากเดิมอย่างสิ้นเชิง เราคาดว่าจะเห็นบูลีนแต่เราได้ตัวเลขมา ทั้งหมดเป็นเพราะเราใช้ ตัวดำเนิน การกำหนดในวงเล็บแทนการ เปรียบเทียบ x=y ค่าของy(999) ถูกกำหนดให้กับตัวแปรxจากนั้นเราจึงแสดงค่าxของ นี่คือวิธีที่ถูกต้อง:

public class Main {

   public static void main(String[] args) {

       int x = 33;
       int y = 999;
       System.out.println(x==y);
   }
}

เอาต์พุตคอนโซล: เท็จ ตอนนี้เราได้เปรียบเทียบตัวเลขทั้งสองอย่างถูกต้องแล้ว! :) ต่อไปนี้เป็นคุณลักษณะอื่นของโอเปอเรเตอร์การกำหนด ( =): สามารถ "เชื่อมโยง" เข้าด้วยกันได้:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;
       int z = 256;

       x = y = z;
       System.out.println(x);
   }
}

เอาต์พุตของคอนโซล: 256 โปรดจำไว้ว่าการมอบหมายนั้นมาจากขวาไปซ้าย นิพจน์นี้ ( x = y = z) จะถูกดำเนินการตามขั้นตอน:

• y = z, นั่นคือ,y = 256
• x = y, นั่นคือ,x = 256

ตัวดำเนินการยูนารี

พวกเขาเรียกว่า " unary " จากคำว่า " uno " ซึ่งแปลว่า " หนึ่ง " พวกเขาได้ชื่อนี้เพราะไม่เหมือนกับโอเปอเรเตอร์รุ่นก่อนหน้า พวกเขาใช้หมายเลขเดียว ไม่ใช่หลายตัว เหล่านี้รวมถึง:

• ยูนารี ลบ. มันพลิกเครื่องหมายของตัวเลข

public class Main {

   public static void main(String[] args) {

       int x = 999;

       // Change the sign for the first time
       x = -x;
       System.out.println(x);

       // Change the sign for the second time
       x= -x;
       System.out.println(x);
   }
}

เอาต์พุตคอนโซล: -999 999 เราใช้ตัวดำเนินการลบเลขคู่สองครั้ง เป็นผลให้จำนวนของเราติดลบก่อนแล้วจึงกลับมาเป็นบวกอีกครั้ง!

• เพิ่มขึ้น (++) และลด (--)

ตัว++ดำเนินการเพิ่มจำนวนทีละหนึ่ง และ--ตัวดำเนินการลดจำนวนด้วยจำนวนที่เท่ากัน

public class Main {

   public static void main(String[] args) {

       int x = 999;
       x++;
       System.out.println(x);

       x--;
       System.out.println(x);
   }
}

เอาต์พุตของคอนโซล: 1,000 999 สัญลักษณ์นี้อาจคุ้นเคยกับคุณหากคุณเคยได้ยินเกี่ยวกับภาษา C++ ผู้สร้างใช้ชื่อที่น่าสนใจนี้เพื่อสื่อถึงแนวคิดที่ว่า "C++ เป็นส่วนขยายของภาษา C" Notepad รุ่นปรับปรุงที่ได้รับความนิยมเรียกว่า Notepad++ นี่คือประเด็นสำคัญ ตัวดำเนิน การ เพิ่มและลดมีสองประเภท ได้แก่postfixและprefix x++- postfix ++x- prefix อะไรคือความแตกต่างพื้นฐานระหว่างการใส่ pluses/minuses ก่อนหรือหลังตัวเลข? เราจะเห็นในตัวอย่างต่อไปนี้:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
   }
}

เอาต์พุตคอนโซล: 999 มีบางอย่างผิดปกติ! เราต้องการเพิ่มxทีละ 1 และกำหนดค่าใหม่ให้กับตัวแปร y กล่าวอีกนัยหนึ่ง y ควรเป็น 1,000 แต่เราได้อย่างอื่นแทน: 999 ดูเหมือนว่า x ไม่เพิ่มขึ้นและตัวดำเนินการเพิ่มไม่ทำงาน แต่มันได้ผล เพื่อโน้มน้าวใจตัวเอง ลองแสดงxในตอนท้าย :)

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = x++;
       System.out.println(y);
       System.out.println(x);
   }
}

เอาต์พุตของคอนโซล: 999 1,000 อัน ที่จริง นี่คือเหตุผลว่าทำไมการดำเนินการนี้จึงเรียกว่า postfix: ดำเนินการหลังจากนิพจน์หลัก ในกรณีของเรา หมายความว่า int y = x++; y = xดำเนินการก่อน (และตัวแปรyจะเริ่มต้นเป็นค่าของx) และจากนั้นจึงจะ x++ดำเนินการ ถ้านี่ไม่ใช่พฤติกรรมที่เราต้องการ จากนั้นเราจำเป็นต้องใช้ สัญกรณ์ นำหน้า :

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = ++x;
       System.out.println(y);
   }
}

ในกรณีนี้++xจะดำเนินการก่อนและหลังจากนั้นคือy = x; ดำเนินการ คุณควรมอบความแตกต่างนี้ให้กับหน่วยความจำทันทีเพื่อหลีกเลี่ยงความผิดพลาดในโปรแกรมจริง ซึ่งการใช้ postfix แทนคำนำหน้าอาจทำให้ทุกอย่างกลับหัวกลับหางได้ :)

ตัวดำเนินการผสม

นอกจากนี้ใน Java ยังมีตัวดำเนินการผสมที่เรียกว่า พวกเขารวมตัวดำเนินการสองตัว:

• งานที่มอบหมาย
• ตัวดำเนินการทางคณิตศาสตร์

เหล่านี้รวมถึง:

• +=
• -=
• *=
• /=
• %=

ลองพิจารณาตัวอย่าง:

public class Main {

   public static void main(String[] args) {

       int x = 999;
       int y = 33;

       x += y;
       System.out.println(x);
   }
}

เอาต์พุตคอนโซล: 1032 x += yหมายถึงx = x + y. สัญลักษณ์ทั้งสองนี้ใช้ติดต่อกันเพื่อความกระชับ ชุดค่าผสม-=, *=และ/=ทำงาน%=ในลักษณะเดียวกัน

ตัวดำเนินการเชิงตรรกะ

นอกจากตัวดำเนินการตัวเลขแล้ว Java ยังมีการดำเนินการที่เกี่ยวข้องกับค่าบูลีน ( จริงและเท็จ ) การดำเนินการเหล่านี้ดำเนินการโดยใช้ตัวดำเนินการเชิงตรรกะ

• !- ตรรกะไม่ . มันพลิกค่าของบูลีน

public class Main {

   public static void main(String[] args) {

       boolean x = true;
       System.out.println(!x);
   }
}

เอาต์พุตคอนโซล: เท็จ

• &&- ตรรกะและ . มันจะคืนค่าจริงก็ต่อเมื่อ ตัวถูกดำเนินการ ทั้งสองเป็นจริง เท่านั้น

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 && 100 > 200);
       System.out.println(100 > 50 && 100 >= 100);
   }
}

เอาต์พุตคอนโซล: เท็จ จริง ผลลัพธ์ของการดำเนินการแรกเป็นเท็จ เนื่องจากหนึ่งในตัวถูกดำเนินการเป็นเท็จ กล่าว100 > 200คือ ในการคืนค่าจริง&&ตัวดำเนินการต้องการให้ตัวถูกดำเนินการทั้งสองเป็นจริง (เช่นกรณีในบรรทัดที่สอง)

• ||- ตรรกะหรือ . มันจะคืนค่าจริงเมื่อ ตัวถูกดำเนินการ อย่างน้อยหนึ่งตัวเป็นจริง

เมื่อเราใช้โอเปอเรเตอร์นี้ ตัวอย่างก่อนหน้านี้ให้ผลลัพธ์ที่แตกต่างออกไป:

public class Main {

   public static void main(String[] args) {

       System.out.println(100 > 10 || 100 > 200);
   }
}

เอาต์พุตคอนโซล: จริง นิพจน์100 > 200ยังคงเป็นเท็จ แต่สำหรับ ตัวดำเนินการ ORนั้นเพียงพอแล้วที่ส่วนแรก ( 100 > 10) เป็นจริง