You wrap it in quotes "".

java Zoo "Bronx Zoo" Zebra (has two arguments)

use wildcard

java.util.*;

java.lang

java.lang.System

The wildcard must be the last character in a package that has classes.

There must only be one wildcard char in the import statement.

You cannot use wildcards to import members (except when using static import).

True or false - If you explicitly import a class name, that one takes precedence over another found in an import statement using a wildcard.

Import java.util.Date;

import java.sql.*;

If you run a java program with the -cp instruction argument, and the path has a wildcard char in it, what does this do?

java -cp "C:\temp\directoryWithJars\*" myPackage.MyClass

Must have the exact same name as the class.

Cannot have a return value.

Static initializer or Static block

Static {

}

Instance Initializer or Instance block

{

}

Non-decimal

byte = 8 bit

short = 16 bit

int = 32 bit

long = 64

decimal

float = 32 bit

double = 64 bit

character = 16 bit unicode

Cannot be a the beginning or the end.

Can be anywhere in the middle of non decimal numbers.

In numbers with decimals, cannot be next to on the left or next to on the right of the decimal.

What happens in the following statement?

int i1, i2, i3, i4 = 4;

True or false - The following declaration statement is legal;

String s1, int num;

Which of the following are valid in Java?

1. boolean b1, b2;

2. String s1 = "1", s2;

3. double d1, double d2;  

4. int i1; int i2; int i3; i4;

1. Legal

2. Legal

3. Not legal, Java does not allow you to declare more than 1 type in a declaration

4. I1, i2, i3 are legal. I4 is not legal.

1. A name must begin with a letter, $ or _.

2. Subsequent characters may also be numbers.

3. You cannot use the same name as a Java keyword.

1. The object no longer has an references pointing to it.

2. All references to the object have gone out of scope.

True or false - for byte, short, char you can assign numeric non-decimal literals and it will compile.

i.e.

short s = 5;

byte b = 4;

char ch = 3;

What happens in the bytecode when this scenario happens and what is the final value in x?

int x = 7;

x = x++;

So, what happens is, the JVM has an area called the operand stack that holds the values of reference variables during the course of the reference variable values having some operation done to them, namely incrementing, decerementing, adding, subtracting, etc. Here, the JVM will take the initial value of x or 7 and push it in to the Operand stack. It will then pop it out of the stack back the variable. X = 7.

Then it will push the value of x or 7 back to the operand stack. Then, it tells the reference variable x, which currently has a value of 7 to increment it by 1. The reference variable value is now 8.  But, the next instruction pops the top of the stack back into the reference variable x, which overwrites the 8 back to a 7 and hence has returned 7 as the value of x. Keep in mind if the operation were instead x = ++x; the instruction to increment the value of x would have happened first, and the result of that would have been pushed to the stack and then popped or stored back into x at the end of the operation.

So for x =x++; the answer here is 7.

True or false - the following will compile;

StringBuilder sb = "hello";

True or false - when using static imports, you must use the parameters as well as the name for methods.

i.e.

import static java.util.Collections.sort(ArrayList<String>);

What will happen in the following scenarios? For these examples, a parent class has a private method called runMe(), that is hidden in a subclass.

p = parent class

s = subclass

1. P p = new P();

p.runMe(); // is called from a main method in P

2. P p = new S();

p.runMe(); // is called from a main method in P

3. P p = new S();

p.runMe(); // is called from a main method in S

4. S s = new S();

s.runMe(); // is called from a main method in S

5. S s = new S();

s.runMe(); // is called from a main method in P

Invoking hidden (private) methods is dependent on where the call is invoked from.  If the Parent reference invokes the call from the Parent class, then it invokes the parent method p.runMe().

If the Parent reference invokes the call from lets say the subclass, this will not compile because this is a private method.

The Child reference can invoke the hidden method in the child object when its run from the parent main or child main.

If the subclass reference invokes

1. Calls private method in P

2. Calls private method in P

3. Generates an exception because p.runMe() is private

4. Calls hidden method in S

5. Calls hidden method in S

^{True or false - it is legal to have division of int variable say 3/5 and store the result in an int ;}

^i.e.

^{int d = 3/5;}

even though the answer is .6, because its less than zero its rounded down to zero as an int.

also even if you assign the result to a double, the answer is still zero. The  expression is evaluated as two ints dividing so the resultant data type on the right is int, when cast to double gives 0.0.

to make the result 0.6, you must make the 3 and the 5 doubles;

double d = 3.0/5.0; // = 0.6

True or false - when using a compound operator, the left hand side variable must have already been initialized before the expression on the right is evaluated, and will not compile;

i.e.

int x = 1;

int y += 4*x+2;

For(int index = 0;index < array.length; index++)

System.out.println(array[index]);

System.out.println(index); // this one is outside the loop and out of scope.

Watch out, the exam will try to trick you by switching the psvm syntax - instead of

Public static void main (String[] args)

static void public main (String[] args)

Return type must be next to Method name!!

Watch out the exam will try to trick you with local variable initialization in a method, that does not initialize all the variables;

int x, y = 0;

True or false - Autoboxing is the automatic conversion the Java compiler makes between primitive types and their object wrapper classes. Autoboxing is when

1) a primitive value is passed as a parameter to a method that expects an object of the corresponding wrapper class

2) Assigned to a variable of the corresponding wrapper class.

Unboxing is the other way.  Unboxing occurs when an object of a wrapper class is

1) passed as a parameter to a method that expects a value of the corresponding primitive type.

2) Assigned to a variable of the corresponding primitive type.

True

int x = new Integer(2);

Integer y = x;

True or false - the static keyword cannot be used for top-level class declarations.

i.e.

public static class MyClass{ // static not legal here

} 

True or false - importing redundant classes is allowed.

package a.b;

import a.b.C;

public class C{

}

True or false - if you have multiple instances of a class, the finalize method can be called more than once for the class (once per each instance).

True or false - Primitives can only be autoboxed to their respective Wrapper types regarding method conversion.

short s = 1;

public void m(int i); // will compile

public void(Short S); // will compile 

public void(Integer I); // will NOT compile

True or false - for most of the primitive wrappers, there is a constructor that takes in a String param.  There is also a type.typeValue() instance method that is non-static and returns the primitive value of the instance. Also type.parseType is a static method that takes in a String. And when you pass in a String, you do not need to add "L" to the string for these methods.

i.e.

String l = "123";

Long long1 = new("123");

1) new Long(l);

2) long1.longValue();

3) Long.parseLong(l);

True or false - as long as the primitive variables are declared before the "=" operator chaining is legal.

i.e.

int a, b, c;

a = b = c = 9;

In fact if only b an c are declared beforehand, then the following is also valid;

int a = b = c = 9;

Remember when you pass a primitive or reference into a method and you reassign its value, the original value of the parameter passed in does not change.

But, when you call a method on the reference, and something changes in the object its refering to, then those changes will take affect.

I.e.

public static void processStacks(Stack X1, Stack x2){

X1.push(new Integer(100));// the method called here WILL change the underlying, original object

x2=x1; // this reassignment will NOT affect the original X2

}

True

public class A{

}

public class AA extends A{

}

public class TestClass{

public static void main(String[] args){

A a = new A();

AA aa = new AA();

a=aa;

// this is where things get weird

System.out.println("a="+a.getClass()); // this references to the class of the object

System.out.println("aa="+aa.getClass()); // this also references the class of the object

}

}

True or false - when comparing booleans using == referential equality, the rules are as follows,

1) get both sides to be either wrappers or primitives.

2) if both sides are wrappers, do the compare.

3) if ONLY one side is a wrapper, unbox the wrapper, do the compare.

True or false - if you have any lower primitive expression on the right hand side, and assign the result to a higher primitive type no matter which one, it will compile.

i.e.

byte b = 1;

shor s = 2;

s = b * b;

True or false - chars get automatically promoted to ints, and since 0 = is the same thing as '0' represented as a char, if we do;

int i = 0;

char c = '0';

Boolean b = (i == c);

b will be true.

True or false - if you cast a floating point primitive to an int, it will round the value up to the next int if the decimal is .5 or higher.

float f = 5.5f;

int i = (int)f;

Boolean b = (i == 6);

b  is true

False - it will just give you what's on the left side of the decimal, in this case 

int i = (int)f;

would be equal to 5.

<class declaration...>

int k = 5;

public Boolean checkIt(int k){ // shadow method param passed in NOT instance var

    Return k-->0?true:false;

}

public void printThem(){

    While(checkIt(k)){ // this is the instance var, and is not affected by shadow above, any changes need to instance var must be done here

        System.out.println(k);

    }

}

True or false - if you Call the String replace method on a literal, and the replace original value is the same as the replacement value it creates a new String and points to the a new String object.

i.e.

"String".replace('g', 'g') == "String" (is false)

Which of the following are legal instantiation expressions and why?

1) int a = b = c = 100;

2) int a,b,c; a = b = c = 100;

3) int a = 100, b, c;

4) int a = 100 = b = c;

5) int a, b, c = 100;

1) Illegal - chaining on declaration is illegal.  If the variables b, c had already been declared, this would be ok.

2) Legal - all variables were previously declared.

3) Legal - a set to 100, b and c with default separated by commas.

4) Illegal - b and c not previously declared.

5) Legal - a, b, declared with default, c declared and set to 100.

True or false - when calling valueOf on a Float wrapper, you can pass in either a string float with no F or one with an F

Float f = Float.valueOf("12.3");

f = Float.valueOf("12.3f");

Will this code fragment print the last arg from the command line, and exit without any exception or stack trace if no args are given?

public static void main (String args[]){

    Int i = args.length -1;

    if(i > 0) System.out.println(args[i]);

}

1) Test with 0 args - args.length = 0 - 1 = -1. -1 > 0 = false so this test will pass if there are zero args.

2) Test with 1 argument - args.length = 1 - 1 = 0. 0 > 0 = false - This test fails because there is only one argument, and hence it is the last argument and it will not be printed.

3) Test with 2 arguments - args.length = 2 -1 = 1. 1 > 0 = true - This test passes because it does get the last argument, and prints it.

Overall, this statement does not meet the requirements because if there is only 1 argument it will not get printed, even though it is the last argument.

Assess the following code and discuss why the value if each variable is calculated.

1) Int X1= -4;

2) Int x2 = X1--;

3) Int x3 = ++x2;

4) if (x2 > x3){ --x3;}else{ X1++;}

5) return X1 + x2 + x3;

1) x1 is assigned -4.

2) x2 is first assigned -4, then after x2 has been assigned, the X1 variable has -1 added to it, so x1 becomes -5.

3) x3 is assigned the increment of x2, or -3 (-4+1), and x2 becomes -3.

4) -3 is not greater than -3 so x1 is incrememted to (-5 + 1) = -4

5) -4 + (-3) + (-3) = -10.

True or false - if you have an ArrayList<Double> l, you can add an int to it.

i.e.

l.add(111);

True or false - since ArrayList contains method takes in an Object, you can pass in a String even though the ArrayList may be typed to Double.

i.e.

ArrayList<Double> l = new ArrayList();

l.add(1.2);

l.contains("string");