นิพจน์ (Expression ) ประกอบไปด้วยข้อมูลหรือตัวถูกดำเนินการ (operand) และตัวดำเนินการ (operator) โดยข้อมูลอาจจะเป็นข้อมูลจริงๆ เช่น เป็นตัวเลข หรือ ข้อความ หรืออาจจะเป็นตัวแปรก็ได้ ส่วนตัวดำเนินการก็คืออักขระที่ถูกกำหนดให้เป็นตัวดำเนินการ เช่น + – * / % = < > = <= && ||  เป็นต้น ขึ้นอยู่กับว่านิพจน์ของเราเป็นนิพจน์แบบใด ตัวอย่างเช่น

     ตัวดำเนินการคือเครื่องหมาย + ส่วนข้อมูลคือผลลัพธ์ที่ได้จากการคำนวนนิพจน์ 7+3 แล้วกำหนดให้กับตัวแปร result ด้วยเครื่องหมาย =  และทั้งบรรทัดตั้งแต่คีย์เวิร์ด int ถึงอักขระ ; รวมเรียกว่าประโยคคำสั่งในการดำเนินการ ( Expression Statement)

     สำหรับตัวอย่างด้านบนส่วนที่เป็นนิพจน์คือ “resultValue1 = ” + resultValue1 และทั้งบรรทัดคือประโยคคำสั่งในการดำเนินการ ( Expression  Statement)

     สำหรับตัวอย่างด้านบนส่วนที่เป็นนิพจน์คือ firstValue <= 50 และทั้งบรรทัดคือประโยคคำสั่งแบบมีเงื่อนไข (Control FLow Statement)

     ผลลัพธ์ของนิพจน์จะต้องมีที่ไปเสมอ ตัวอย่างเช่น 

result = 2 + 5; เป็นการกำหนดผลลัพธ์ที่ได้จากการบวก 2 ด้วย 5 ให้กับตัวแปร result

return 2 + 5; เป็นการใช้คำสั่ง return เพื่อส่งค่าที่ได้จากการบวก 2 ด้วย 5 กลับไปยังโปรแกรมที่เรียกใช้เมธอด

System.out.println(2 + 5); เป็นการส่งค่าที่ได้จากการบวก 2 ด้วย 5 ไปยังเมธอด ptintln เพื่อพิมพ์ผลลัพธ์ออกมา

if ((2+5) == 7) เป็นการนำผลลัพธ์ที่ได้จากการบวก 2 ด้วย 5 ไปเปรียบเทียบว่าเท่ากับ 7 หรือไม่ เพื่อดูว่าผลลัพธ์ทางตรรกะเป็นค่าจริงหรือเป็นค่าเท็จ 

    สำหรับตัวดำเนินการที่มีให้ใช้ทั้งหมดสามารถดูได้จาก https://docs.oracle.com/javase/tutorial/java/nutsandbolts/opsummary.html&nbsp;

ตัวดำเนินการทางคณิตศาสตร์

     คือการคำนวนทางคณิตศาตร์โดยมีตัวดำเนินการคือ   + (บวก)   – (ลบ)      * (คูณ)   / (หาร)   % (เศษเหลือจากการหาร) ข้อควรระวังในการใช้งานตัวดำเนินการทางคณิตศาสตร์คือชนิดข้อมูลที่ใช้เพราะภาษาจาวาฉลาดพอที่จะจัดการเรื่องชนิดข้อมูลให้เรา ดังนั้นโปรแกรมอาจจะไม่พบข้อผิดพลาดตอนแปรภาษา (syntax error) แต่ผลลัพธ์จากการประมวลผลข้อมูลอาจจะไม่เป็นตามที่ต้องการ (run time error) จากตัวอย่างด้านล่างจะเห็นผลลัพธ์ที่แตกต่างกันจากการใช้ชนิดข้อมูลที่ต่างกัน โดยตัวเลข 3 ในบรรทัดที่ 6 เป็นชนิดข้อมูล int ส่วนตัวเลข 3.0 ในบรรทัดที่ 8 เป็นชนิดข้อมูล double ซึ่งจะให้ผลลัพธ์ที่ต่างกัน และประโยคคำสั่งในบรรทัดที่  10 เป็นการหารด้วยชนิดข้อมูล int ซึ่งผลลัพธ์จะเอามาแต่ผลหารที่เป็นเลขจำนวนเต็ม ส่วนบรรทัดที่ 12 เป็นการหาผลลัพธ์ที่เป็นเศษของการหาร

     สำหรับการคำนวนที่ต้องการเก็บผลลัพธ์ไว้ที่ตัวแปรเดิมเราสามารถเขียนในแบบย่อได้ดังตัวอย่างต่อไปนี้

result = result + 1;     เขียนแบบย่อคือ    result ++;

result = result – 1;     เขียนแบบย่อคือ    result –;

result = result + 5;     เขียนแบบย่อคือ    result += 5;

result = result – 5;     เขียนแบบย่อคือ    result -= 5;

result = result * 5;     เขียนแบบย่อคือ    result *= 5;

result = result / 5;     เขียนแบบย่อคือ    result /= 5;

     การเขียนแบบย่อสามารถใช้กับกรณีที่ดำเนินการกับตัวแปรได้ด้วยเช่น

result = result + adder; เขียนแบบย่อคือ result += adder;

     สำหรับการใช้ ++ และ — สามารถใช้ได้ 2 รูปแบบคือเอาไปนำหน้าหรือเอาไปต่อท้ายตัวแปรซึ่งจะให้ผลแตกต่างกันคือ ถ้าเอาไปนำหน้าจะเป็นการเพิ่มค่าหรือลดค่าให้กับตัวแปรก่อนแล้วจึงนำไปใช้งาน จากตัวอย่างเช่น

 ถ้าเอาไปต่อท้ายจะเป็นเอาค่าจากตัวแปรไปใช้ก่อนแล้วจึงเพิ่มค่าหรือลดค่าตัวแปรในภายหลัง ตัวอย่างเช่น

     สำหรับการดำเนินการที่ซับซ้อนให้ครอบด้วยวงเล็บในทุกคู่ของตัวดำเนินการตามลำดับที่เราต้องการเสมอ ทั้งนี้เพื่อเป็นการยืนยันว่าลำดับของการคำนวนจะเป็นไปตามที่เราต้องการและเพื่อให้ง่ายต่อการอ่านโปรแกรมในภายหลัง ตัวอย่างเช่น  int result = ((a+b) * (c+d)) / e; 

ตัวดำเนินการทางตรรกศาสตร์

     คือการดำเนินการทางตรรกศาสตร์โดยมีตัวดำเนินการพื้นฐานคือ   && (and – แอนด์)   || (or – ออ)   ! (not –  นอต) ตัวดำเนินการทางตรรกศาสตร์จะถูกใช้ในการดำเนินการกับค่าหรือผลลัพธ์ที่เป็นค่าทางตรรกศาสตร์คือ ค่าจริง (true) หรือค่าเท็จ (false) ผลลัพธ์จากการดำเนินการทางตรรกศาสตร์เป็นดังนี้

     สำหรับตัวดำเนินการ && ผลลัพธ์ที่ได้จะเป็นจริงก็ต่อเมื่อค่าที่นำมาดำเนินการเป็นจริงทั้งคู่ (true && true = true) กรณีอื่นจะได้ผลลัพธ์เป็นเท็จ

     สำหรับตัวดำเนินการ || ผลลัพธ์ที่ได้จะเป็นเท็จก็ต่อเมื่อค่าที่นำมาดำเนินการเป็นเท็จทั้งคู่ (false || false = false) กรณีอื่นจะได้ผลลัพธ์เป็นจริง

     สำหรับตัวดำเนินการ ! จะเป็นการกลับค่าของผลลัพธ์คือ !true จะได้ค่า false และ !false จะได้ค่า true

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

If ((A && B) || (C && D)){

}

     ตัวอย่างด้านล่างเป็นการเขียนโปรแกรมเพื่อแสดงค่าที่ได้จากตัวดำเนินการแบบต่างๆในแต่ละกรณี

ตัวดำเนินการเปรียบเทียบ

     เราใช้ตัวดำเนินการเปรียบเทียบเพื่อหาผลลัพธ์ว่าเป็นจริง (true) หรือเป็นเท็จ (false) ตัวดำเนินการเปรียบเทียบมีดังนี้   == (เท่ากับ)   != (ไม่เท่ากับ)   > (มากกว่า)   >= (มากกว่าหรือเท่ากับ)   < (น้อยกว่า)   <= (น้อยกว่าหรือเท่ากับ)

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

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

If ((A < B) || (A<C)) {

}

     ตัวดำเนินการเปรียบเทียบสามารถใช้ได้กับชนิดข้อมูลแบบ primitive data type เท่านั้น เช่น ในกรณีที่เราต้องการเปรียบชนิดข้อมูลแบบ reference data type ว่าเท่ากันหรือไม่ เราจะไม่สามารถใช้ตัวดำเนินการเปรียบเทียบ ==  ได้ แต่จะต้องใช้เมธอด equals() 

     ตัวอย่างด้านล่างเป็นการเปรียบเทียบข้อความของคลาส String ว่าเหมือนกันหรือไม่ซึ่งมักจะทำให้สับสนว่าทำไมคลาส String ซึ่งเป็น reference data type ถึงสามารถใช้การเปรียบเทียบได้ด้วยตัวดำเนินการเปรียบเทียบ == ได้

     จากตัวอย่างจะเห็นว่าการเปรียบเทียบตัวแปร a และ b ด้วยตัวดำเนินการเปรียบเทียบ == ให้ผลลัพธ์เป็น true ในขณะที่การเปรียบเทียบตัวแปร a และ c ด้วยตัวดำเนินการเปรียบเทียบ == ให้ผลลัพธ์เป็น false ทั้งนี้เป็นเพราะข้อมูลแบบ reference data type สิ่งที่เก็บในตัวแปรคือตำแหน่งของหน่วยความจำที่เก็บข้อมูลจริงๆอีกทีหนึ่ง ซึ่งในการกำหนดค่าให้กับตัวแปร String หากภาษาจาวาเห็นว่ามีข้อความนี้อยู่แล้วในหน่วยความจำจะจัดการให้ตัวแปรเก็บตำแหน่งของหน่วยความจำที่มีข้อความนี้อยู่แล้วหรือเรียกว่าให้ตัวแปรชี้ไปที่ออบเจกต์ที่มีอยู่แล้ว ดังนั้นการเปรียบเทียบตัวแปร a และ b ด้วยตัวดำเนินการเปรียบเทียบ == จึงเป็นการเปรียบเทียบค่าตำแหน่งของหน่วยความจำเท่านั้น ไม่ใช่การเปรียบเทียบเนื้อหาของข้อความจริงๆ แต่เมื่อเรากำหนดค่าให้ตัวแปร c ด้วยคีย์เวิร์ด new ซึ่งเป็นการบอกภาษาจาวาให้สร้างออบเจกต์ขึ้นมาใหม่ ถึงแม้จะเก็บข้อความเดียวกัน แต่เก็บอยู่คนละตำแหน่งในหน่วยความจำ ดังนั้นเมื่อเราเปรียบเทียบด้วย a == c จึงได้ผลลัพธ์เป็น false หากต้องการเปรียบเทียบข้อความจริงๆเราต้องใช้เมธอด equals() เช่น a.equasl(c) ซึ่งให้ผลลัพธ์เป็น true

ลำดับของตัวดำเนินการ

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

     ตัวอย่างด้านล่างแสดงให้เห็นว่าลำดับการดำเนินการที่แตกต่างกันจะทำให้ได้ผลลัพธ์ที่แตกต่างกัน

     ลำดับของตัวดำเนินการดังแสดงในตารางด้านล่าง โดยลำดับที่ 15 เป็นลำดับสูงสุดคือจะถูกดำเนินการก่อน และในลำดับเดียวกันจะทำจากซ้ายไปขวาหรือขวาไปซ้ายแล้วแต่กรณี จะเห็นว่าตัวดำเนินการที่เป็น  ( ) จะอยู่ลำดับสูงสุดและถูกดำเนินการก่อน