Core

Question 1

Access Modifiers

Answer 1

*used for setting the access level to classes, variables, methods, and constructors.
1.public –>available to all other classes in all packages

2.protected –> we can access the member from the same package and in addition from all subclasses of its class, even if they lie in other packages

3.default (no keyword)–>package-private, which means that all members are visible within the same package but aren’t accessible from other packages

4.private –>accessible from the same class only

Modifier Class Package Subclass World
public Y Y Y Y
protected Y Y Y N
default Y Y N N
private Y N N N

The most restrictive:?????
private<default<protected<public

Question 2

Interfaces

Answer 2

ARE BEING IMPLEMENTED!!
Fields defined in an interface are ALWAYS considered as public, static, and final. Even if you don’t explicitly define them as such. In fact, you cannot even declare a field to be private or protected in an interface. Therefore, you cannot assign any value to ‘type’ outside the interface definition–> the program will not COMPILE

Question 3

Clases

Answer 3

ARE BEING EXTENDED!

Question 4

Access to static and instance fields and methods

Answer 4

Access to static and instance fields and static methods depends on –> reference
Access to instance methods depends on –> the class of the object

Access to static and instance fields and static methods depends on the class of reference variable and not the actual object to which the variable points to.
Observe that this is opposite of what happens in the case of instance methods. In case of instance methods the method of the actual class of the object is called.
https://www.youtube.com/watch?v=5kY35dkMOqY

*instance variables can be accessed only from a non-static blocks.
*static variables can be accessed from any block.

Question 5

Ordinea operatilor

Answer 5

From left to right: the variables are being evaluated, then the operands and afterwards the methods
EG:
String str1 = “one”;
String str2 = “two”;
System.out.println( str1.equals(str1=str2) );
First the value of ‘str1’ is evaluated (i.e. one). Now, before the method is called, the operands are evaluated, so str1 becomes “two”. so “one”.equals(“two”) is false.
* the embedded assignments occur before the method calls
getArray()[index=2]++;
*Note that boolean operators have more precedence than =. (In fact, = has least precedence of all operators.)

Question 6

Imports

Answer 6

• Package import does not use static keyword!–> WRONG: import static packge.*;
  If the package is imported then the static field can be accessed as Class.staticField:–> import package.;
  *Syntax for importing static fields is: import static <package>.<classname>.*; or import static <package>.<classname>.<fieldname>;--> can use the STATIC FIELD stand ALONE</fieldname></classname></package></classname></package>

Question 7

Object methods

Answer 7

*getClass is a public instance method in Object class. That means it is polymorphic. In other words, this method is bound at run time and so it returns the NAME of the class of the actual OBEJCT to which the reference points.

Question 8

All wrapper classes are final and so they cannot be extended.

Answer 8

Wrapper classes:
java.lang.Boolean, java.lang.Integer, java.lang.Long, java.lang.Short java.lang.String, StringBuilder, and StringBuffer,java.lang.System

*java.lang.Number, however, is not final. Integer, Long, Double etc. extend Number!!!

Question 9

JAVA OVERWRITING rules

Answer 9

***Overriding refers to the ability of a subclass to re-implement an instance method inherited from a superclass.
DO NOT CONFUSE with OVERLOADING

Rules from overriding:
#1:Only inherited methods can be overridden.
#2:Final and static methods cannot be overridden.
#3: The overriding method must have same argument list.
#4: The overriding method must have same return type (or subtype).
#5: The overriding method must not have more restrictive access modifier.
#6: The overriding method must not throw new or broader checked exceptions.
#7:Use the super keyword to invoke the overridden method from a subclass.
#8:Constructors cannot be overridden.
#9: Abstract methods must be overridden by the first concrete (non-abstract) subclass.
#10: A static method in a subclass may hide another static one in a superclass, and that’s called hiding.
#11: The synchronized modifier has no effect on the rules of overriding.
#12: The strictfp modifier has no effect on the rules of overriding.

***Overloading
#1. Method overloading can only be achieved if and only if two or more methods share the same method name but have different method signatures. If more than one method has the same name as well as signature within the same class, the program would not compile successfully.
#2. Return type is NOT relevant for overloading.

Question 9

JAVA OVERWRITING rules

Question 10

switch

Answer 10

Works with the:
*String, char si Character
*byte, short, int and their wrapper classes Byte, Short, and Integer
*enumerated types (discussed in Enum Types),

Does NOT work with BOOLEAN!!

Question 11

WRAPPER CLASSES

Answer 11

Methods:
Input String–> output Primitive!!!!!!!
parseXXX(String s)

Parses the string argument as a boolean. The boolean returned represents the value true if the string argument is not null and is equal, ignoring case, to the string “true”.

new Boolean(null) will return a Boolean wrapper object containing false!!!!!!!
**
new Boolean() == false
This will not compile because Boolean class does not have a no-args constructor.
**
new Boolean(“TrUe”) == new Boolean(true)
Even though both the sides have a Boolean wrapper containing true, the expression will yield false because they point to two different Boolean wrapper objects

new Boolean(“no”) == false
Any string other than “true” (ignoring case) will produce a Boolean containing false

1. Boolean class has two constructors - Boolean(String) and Boolean(boolean)
   The String constructor allocates a Boolean object representing the value true if the string argument is not null and is equal, ignoring case, to the string “true”. Otherwise, allocate a Boolean object representing the value false. Examples: new Boolean(“True”) produces a Boolean object that represents true. new Boolean(“yes”) produces a Boolean object that represents false.

The boolean constructor is self explanatory.

2. Boolean class has two static helper methods for creating booleans - parseBoolean and valueOf.
   Boolean.parseBoolean(String ) method returns a primitive boolean and not a Boolean object (Note - Same is with the case with other parseXXX methods such as Integer.parseInt - they return primitives and not objects). The boolean returned represents the value true if the string argument is not null and is equal, ignoring case, to the string “true”.

Boolean.valueOf(String ) and its overloaded Boolean.valueOf(boolean ) version, on the other hand, work similarly but return a reference to either Boolean.TRUE or Boolean.FALSE wrapper objects. Observe that they dont create a new Boolean object but just return the static constants TRUE or FALSE defined in Boolean class.

3. When you use the equality operator ( == ) with booleans, if exactly one of the operands is a Boolean wrapper, it is first unboxed into a boolean primitive and then the two are compared (JLS 15.21.2). If both are Boolean wrappers, then their references are compared just like in the case of other objects. Thus, new Boolean(“true”) == new Boolean(“true”) is false, but new Boolean(“true”) == Boolean.parseBoolean(“true”) is true.

Question 12

for each

Answer 12

Used to iterate over an array or a Collections class

Syntax:
for (type var : array)
{
statements using var;
}
*Instead of declaring and initializing a loop counter variable, you declare a variable that is the same type as the base type of the array, followed by a colon, which is then followed by the array name.
In the loop body, you can use the loop variable you created rather than using an indexed array element

Limitations of for-each loop

1.For-each loops are not appropriate when you want to modify the array
2. For-each loops do not keep track of index.
3. For-each only iterates forward over the array in single steps
4. For-each cannot process two decision making statements at once
5. For-each also has some performance overhead over simple iteration:

Question 13

The main methods

Answer 13

*execution of a class from command line requires the class to have the standard main method

public static void main (String[] args)
–> f the program is run without any arguments, args points to a String array of length 0 (args is NOT NULL!!!!)

Question 14

Package import

Answer 14

“A compilation unit that has no package declaration is part of an unnamed package.” Thus, if you omit the package statement, the class will belong to the unnamed package.

Remember that classes in the unnamed package are accessible only to other classes in the unnamed package. It is not possible to import this unnamed package in classes that belong to a named package.

Question 15

Increment&decrement

Answer 15

Watch out for Post Decrement
**the conditions are first evaluated and only afterwards the increment is being executed
int var = 20, i=21;
if (i<var–) –> 21<20

Question 16

BREAK and CONTINUE

Answer 16

Break - interupts the loop
Continue- interupts only the current interation
When used with a label, please make sure that the label is used inside the loop where the label was declared otherwise IT WONT COMPILE

Question 17

Garbage collection

Answer 17

1. An object can be made eligible for garbage collection by making sure there are no references pointing to that object.
2. You cannot directly invoke the garbage collector. You can suggest the JVM to perform garbage collection by calling System.gc();

Question 18

Imports and package declaration

Answer 18

import java.lang.*; –>this package is automatically imported, but it is not an error to import it explicitly.

*There can be only 1 “public” class within package scope in a file. You can have additional inner classes that are public though
*You can have more than one classes in a file but at most one of them can be public

Question 19

Boxing vs Widening!

Answer 19

AutoBoxing:Primitive to Wrapper(int to Integer)
Unboxing: Wrapper to primitive

Widening: from Integer to Double

!!!!!Java will only do a conversions in one go.??? It will do the auto-boxing but not the widening too in one step.
Eg:

Double a = 1; // error - incompatible types–> because it only does the autoboxing int–> Integer: Double a = Integer.valueOf(1);

Double b = 1.0; // OK–> Does the autoBoxing: Double b = Double.valueOf(1);
double c = 1; // OK–> Widening: int to double: double c = (double) 1;

Question 20

Static

Answer 20

*Non static methods can access static as well as non static methods of a class
*Non-static method (i.e. an instance method) can only be called on an instance of that class.

Question 21

Variable initialization

Answer 21

static and instance variables are automatically assigned a value even if you don’t initialize them explicitly but local variables must be initialized explicitly before they are used.
EG: public class Discounter {
static double percent; //1
int offset = 10, base= 50; //2
public static double calc(double value) {
int coupon, offset, base; //3
if(percent <10){ //4
coupon = 15;
offset = 20;
base = 10;
}
return couponoffsetbase*value/100; //5
}
public static void main(String[] args) {
System.out.println(calc(100));
}
}–> compilation error at //5

the calc method declares local variables coupon, offset, and base but does not assign them a value. Even though at run time, we know that since percent is 0 and is thus < 10, a value will be assigned to these variables, the compiler doesn’t know this because the compiler doesn’t take values of “variables” into consideration while determining the flow of control. It only considers the values of compile time constants. Therefore, as far as the compiler is concerned, coupon, offset, and base may remain uninitialized before they are used.

Having uninitialized variables itself is not a problem. So there is no compilation error at //3. However, using them before they are initialized is a problem and therefore the compiler flags an error at //5.

Had percent been defined as final ( static final double percent = 0; ), the code would work and print 3000.0.

Question 22

Passing arguments BY VALUE

Answer 22

1. Primitives are always passed by value.
2. Object “references” are passed by value. So it looks like the object is passed by reference but actually it is the value of the reference that is passed.
   n example:
   Object o1 = new Object();

Let us say, this object is stored at memory location 15000. Since o1 actually stores just the address of the memory location where the object is stored, it contains 15000.

Now, when you call someMethod(o1); the value 15000 is passed to the method. Therefore, this is what happens inside the method someMethod():

   someMethod( Object localVar) { localVar now contains 15000, which means localVar also points to the same memory location where the object is stored. Therefore, when you call a method on localVar, it will be executed on the same object.

However, when you change the value of localVar itself, for example, if you do localVar=null, then localVar starts pointing to a different memory location. But the original variable o1 still contains 15000 so it still points to the same object.
}

If you need even more detailed explanation, please check http://www.javaranch.com/campfire/StoryPassBy.jsp

Question 23

switch statement

Answer 23

Only String, byte, char, short, int, (and their wrapper classes Byte, Character, Short, and Integer), and enums can be used as types of a switch variable. String is allowed since Java 7.
The case constants must be assignable to the switch variable. For example, if your switch variable is of class String, your case labels must use Strings as well.
The switch variable must be big enough to hold all the case constants. For example, if the switch variable is of type char, then none of the case constants can be greater than 65535 because a char’s range is from 0 to 65535. For example, the following will not compile because 200 cannot be assigned to the variable b, which can only hold values from -128 to 127.
byte b = 10;
switch(b){
case 100 : System.out.print(100); //OK
case 200 : System.out.print(200); //will not compile
}
All case labels should be COMPILE TIME CONSTANTS. This means, you can have literals such as ‘a’, 5, 10, or a final variable, the value of which is computed at compile time such as int I = 23; For example, the following is valid:
int x = 10;
final int I = 23;
switch(x){
case I : System.out.println(x); //this is valid because I is a compile time constant
}
No two of the case constant expressions associated with a switch statement may have the same value.
The default label is optional and at most one default label may be associated with the same switch statement.