Operators and Assignments Questions

Java programming — Predict the console output for the following program (string concatenation and evaluation order): class SC2 { public static void main(String [] args) { SC2 s = new SC2(); s.start(); } void start() { int a = 3; int b = 4; System.out.print(" " + 7 + 2 + " "); System.out.print(a + b); System.out.print(" " + a + b + " "); System.out.print(foo() + a + b + " "); System.out.println(a + b + foo()); } String foo() { return "foo"; } }

Java programming — Evaluate bitwise operators step by step: class Bitwise { public static void main(String [] args) { int x = 11 & 9; int y = x ^ 3; System.out.println( y | 12 ); } }

Java programming — Objects and references with methods returning the same instance: class Two { byte x; } class PassO { public static void main(String [] args) { PassO p = new PassO(); p.start(); } void start() { Two t = new Two(); System.out.print(t.x + " "); Two t2 = fix(t); System.out.println(t.x + " " + t2.x); } Two fix(Two tt) { tt.x = 42; return tt; } }

Java programming — Type compatibility in assignments inside boolean expressions: class Equals { public static void main(String [] args) { int x = 100; double y = 100.1; boolean b = (x = y); // Line 7 System.out.println(b); } }

Java programming — Nested conditional (ternary) operator evaluation: class Test { public static void main(String [] args) { int x=20; String sup = (x < 15)? "small" : (x < 22)? "tiny" : "huge"; System.out.println(sup); } }

Java programming — Primitives are passed by value; confirm behavior with boolean: class Test { public static void main(String [] args) { Test p = new Test(); p.start(); } void start() { boolean b1 = false; boolean b2 = fix(b1); System.out.println(b1 + " " + b2); } boolean fix(boolean b1) { b1 = true; return b1; } }

Java programming — Unsigned right shift (>>>) of Integer.MIN_VALUE and printing before/after: class BitShift { public static void main(String [] args) { int x = 0x80000000; System.out.print(x + " and "); x = x >>> 31; System.out.println(x); } }

Java programming — Effect of passing primitives and updating a static field: class Test { static int s; public static void main(String [] args) { Test p = new Test(); p.start(); System.out.println(s); } void start() { int x = 7; twice(x); System.out.print(x + " "); } void twice(int x) { x = x*2; s = x; } }

Java programming — Boolean operators with single ampersand/pipe (non–short-circuit) and overall truth evaluation: class SSBool { public static void main(String [] args) { boolean b1 = true; boolean b2 = false; boolean b3 = true; if ( b1 & b2 | b2 & b3 | b2 ) System.out.print("ok "); if ( b1 & b2 | b2 & b3 | b2 | b1 ) System.out.println("dokey"); } }

Java programming — Boolean arrays, operator precedence (| vs &&), and short-circuit effects: class BoolArray { boolean [] b = new boolean[3]; int count = 0; void set(boolean [] x, int i) { x[i] = true; ++count; } public static void main(String [] args) { BoolArray ba = new BoolArray(); ba.set(ba.b, 0); ba.set(ba.b, 2); ba.test(); } void test() { if ( b[0] && b[1] | b[2] ) count++; if ( b[1] && b[(++count - 2)] ) count += 7; System.out.println("count = " + count); } }

In Java, what will be the output of the following program (note the use of pre-increment and short-circuit AND)? class Test { public static void main(String [] args) { int x = 0; int y = 0; for (int z = 0; z < 5; z++) { if ((++x > 2) && (++y > 2)) { x++; } } System.out.println(x + " " + y); } }

In Java, what will be the output of the following program (note the use of pre-increment and short-circuit OR)? class Test { public static void main(String [] args) { int x = 0; int y = 0; for (int z = 0; z < 5; z++) { if ((++x > 2) || (++y > 2)) { x++; } } System.out.println(x + " " + y); } }

In Java, what will be the output of the following program using a left shift inside a method (note pass-by-value of primitives)? public class Test { public static void leftshift(int i, int j) { i <<= j; } public static void main(String args[]) { int i = 4, j = 2; leftshift(i, j); System.out.println(i); } }

In Java, what will be the output of this program demonstrating String immutability and parameter passing? class PassS { public static void main(String [] args) { PassS p = new PassS(); p.start(); } void start() { String s1 = "slip"; String s2 = fix(s1); System.out.println(s1 + " " + s2); } String fix(String s1) { s1 = s1 + "stream"; System.out.print(s1 + " "); return "stream"; } }

In Java, what is the output of this program showing array reference semantics (method modifies the same array)? class PassA { public static void main(String [] args) { PassA p = new PassA(); p.start(); } void start() { long[] a1 = {3, 4, 5}; long[] a2 = fix(a1); System.out.print(a1[0] + a1[1] + a1[2] + " "); System.out.println(a2[0] + a2[1] + a2[2]); } long[] fix(long[] a3) { a3[1] = 7; return a3; } }

Java (reference vs value equality) — which three comparisons evaluate to true for the given arrays and primitives? /* Options to judge: 1) f1 == f2 2) f1 == f3 3) f2 == f1[1] 4) x == f1[0] 5) f == f1[0] */ import java.awt.Button; class CompareReference { public static void main(String [] args) { float f = 42.0f; float[] f1 = new float[2]; float[] f2 = new float[2]; float[] f3 = f1; long x = 42; f1[0] = 42.0f; } } Select the set that lists all and only the true statements.

Java (instanceof legality) — which two statements could be legally inserted where indicated? /* Candidate lines: 1) boolean test = (Component instanceof t); 2) boolean test = (t instanceof Ticker); 3) boolean test = t.instanceof(Ticker); 4) boolean test = (t instanceof Component); */ import java.awt.; class Ticker extends Component { public static void main (String [] args) { Ticker t = new Ticker(); / Missing Statements? */ } } Pick the pair that is syntactically valid in Java.

Java operators — which two expressions are equivalent for the integer value 16? Candidates: 1) 164 2) 16>>2 3) 16/2^2 4) 16>>>2 Assume 32-bit signed ints and Java operator precedence.

Java bit operations — which two expressions evaluate to the same result? Expressions: 1) 32/4 2) (8 >> 2) << 4 3) 2^5 4) 128 >>> 2 5) 2 >> 5 Assume int arithmetic and default operator precedence.

Java casts and narrowing — which of the following lines are legal (compile successfully)? 1) int w = (int)888.8; 2) byte x = (byte)1000L; 3) long y = (byte)100; 4) byte z = (byte)100L; Assume standard Java primitive conversion rules.