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?\n\n/* Options to judge: \n1) f1 == f2\n2) f1 == f3\n3) f2 == f1[1]\n4) x == f1[0]\n5) f == f1[0]\n*/\n\nimport java.awt.Button;\nclass CompareReference \n{\n public static void main(String [] args) \n {\n float f = 42.0f;\n float[] f1 = new float[2];\n float[] f2 = new float[2];\n float[] f3 = f1;\n long x = 42;\n f1[0] = 42.0f;\n }\n}\n\nSelect the set that lists all and only the true statements.
• Java (instanceof legality) — which two statements could be legally inserted where indicated?\n\n/* Candidate lines: \n1) boolean test = (Component instanceof t);\n2) boolean test = (t instanceof Ticker);\n3) boolean test = t.instanceof(Ticker);\n4) boolean test = (t instanceof Component);\n*/\n\nimport java.awt.;\nclass Ticker extends Component \n{\n public static void main (String [] args) \n {\n Ticker t = new Ticker();\n / Missing Statements? */\n }\n}\n\nPick the pair that is syntactically valid in Java.
• Java operators — which two expressions are equivalent for the integer value 16?\n\nCandidates:\n1) 164\n2) 16>>2\n3) 16/2^2\n4) 16>>>2\n\nAssume 32-bit signed ints and Java operator precedence.
• Java bit operations — which two expressions evaluate to the same result?\n\nExpressions:\n1) 32/4\n2) (8 >> 2) << 4\n3) 2^5\n4) 128 >>> 2\n5) 2 >> 5\n\nAssume int arithmetic and default operator precedence.
• Java casts and narrowing — which of the following lines are legal (compile successfully)?\n\n1) int w = (int)888.8;\n2) byte x = (byte)1000L;\n3) long y = (byte)100;\n4) byte z = (byte)100L;\n\nAssume standard Java primitive conversion rules.