Choose Reference or Object below.

Java determines which methods and variables are accessible to a program based on the reference/object.

1. redeclare

2. hidden

3. separate

4. independent

If a Child class hides a Parent's private instance method, and the reference to the Child object is via a Child reference, which method is invoked, the Parent or the Child?

Child c = new Child();

If a child class hides a private parent instance method what happens when a Parent is used as a reference to a child - which method gets executed, the parent method or the child method?

Parent p = new Child();

1. The first statement in every constructor is a call to another constructor in the class with the use of this(), OR

A call to a direct parent class using super().

2. The use of super() is not allowed after the first statement in a constructor.

3. If no super() is declared in a constructor, the compiler will insert a default no-arg super() call as the first statement.

4. If the parent doesn't have a no-arg constructor and the child does not define any constructors, the compiler with throw an error, and will try to insert a default no-arg constructor in the child class.

5. If the parent doesn't have a no-arg constructor, the compiler requires an explicit call to a parent constructor in each child constructor.

1. this()

2. parent

3. super()

1. an abstract class cannot be instantiated directly

2. can have zero or more abstract and non-abstract methods

3. Cannot be marked as private, protected or final

4. an abstract class that extends another abstract class inherit all abstract methods as it own

5. The first concrete class must provide an implementation for all inherited abstract methods.

1.abstract methods can only be in abstract classes 2.abstract methods cannot be declared private or final 3.abstract methods can't provide a method body

4. when you implement abstract methods;

A. Name and signature must be the same

B. Visibility must be at least as or more accessible

1. interfaces cannot be instantiated directly.

2. An interface is not required to have any methods.

3. An interface may not be marked as private, protected or final (can only be public or pkg-private (default), assumed to be abstract)

4. Interfaces that extend other interfaces inherit all abstract interface methods as their own.

5. First concrete class that implements an interface OR the first concrete class that extends an abstract class that implements an interface, must implement all inherited abstract methods.

1.abstract interface methods are assumed public abstract.

2.abstract methods cannot be declared private, protected or final, non-default are assumed public abstract.

3.abstract interface methods can't provide a method body

4. when you implement abstract interface methods;

A. Name and signature must be the same

B. Visibility must be at least as or more accessible

1. A default method may only be declared in an interface and not a class or an abstract class.

2. A default method must be marked with the default key word. If a method is marked as default, it MUST provide a method body.

3. A default method is not assumed to be static or final or abstract, as it may be used or overridden in the class that implements the interface.

4. Like all methods in an interface, a default method is assumed to be public, and will not compile if marked private or protected.

1. Like all methods in an interface, static methods are assumed to be public and will not compile if marked as private or protected.

2. To reference a static interface method, a reference to the interface must be used.

1. Has the same signature as the parent method.

2. Overriding method must have at least the same or more accessibility as the parent method.

3. Does not have new or broader exception(s) than any exception in the parent class method.

4. Return value must be same as or a subclass (covariant) of the return type in the parent class.

hiding a static method

1. Child must have same signature.

2. Child must be at least as or more accessible.

3. Child method can't throw a new or broader exception.

4. Child return type must be same or subclass (covariant).

5. MUST be marked as static in child if it is marked as static in parent!

Static method hiding has the same check rules as non-private, non-static method, except for the 5th one;

1. Has the same signature as the parent method.

2. Overriding method must have at least the same or more accessibility as the parent method.

3. Does not have new or broader exception(s) than any exception in the parent class method.

4. Return value must be same as or a subclass (covariant) of the return type in the parent class.

5. If marked as static in the parent, it MUST be marked as static in the child class (method hiding).Likewise, if parent method is NOT static, the child method CANNOT BE static (method overriding).

1. signature

2. method name

3. input parameters

4. return type or covariant return type

super() to call a/the constructor in the super class, or

this() to call a constructor in the class itself

public MyClass(int i){

System.out.println(i); this();

}

Be careful.

True or false - if you have a class that implements multiple interfaces, you can not only cast the object to those interfaces, but if you cast to one of the implemented interfaces, java is smart enough to know that the underlying object has implemented them, and you can then cast the interface reference to another one, as long as you do an EXPLICIT cast and the object is not final;

i.e.

interface CanSwim{

}

interface HasFins{

}

public class Shark implements CanSwim, HasFins {

Object shark = new Shark();

CanSwim canSwim = (CanSwim) shark;

HasFins hasFins = (HasFins) canSwim;

}

True - here are the rules for casting to interfaces;

Lets say on the right side you have;

(DestinationType)sourceTypeReference (and DestinationType is an interface)

1) the type of sourceTypeReference is also an interface => cast is always allowed

2) the type of sourceTypeReference is a non-final class => cast is always allowed

3) the type of sourceTypeReference is a final class => cast is ONLY allowed allowed if the type of sourceTypeReference implements DestinationType; otherwise u get a compiler error

Keep in mind that 1) and 2) can throw ClassCastExceptions at runtime

True or false - in a method you can return the result of a call to a constructor;

i.e.

public in setTar(int z, int y, double d){

return this(z, y, d);

}

True

i.e.

class A{

    A(){

        print();

    }

    Void print(){

        System.out.println("Hello");

    }

}

class B extends A{

    Int i = 4;

    Void print(){

        System.out.println(i);

    }

    public static void main(String[] args){

        A a = new B();

    }

}

In this case even though the print call exists in the parent constructor, because the method is an overriden non-static instance method, polymorphism takes over and calls the objects method from the particular class its instantiated from. The result would print 0, because we are still in A's constructor, and the int i variable in class B has not had a chance to be instantiated yet.

True or false -  a constructor can take the same type as a parameter.

Test(Test t){

}

True or false - You can call a static member in an Interface, from a reference variable.

public interface ITest {

public static void testMethod(){}

}

public class TestClass implements ITest{

public static void main(String[] args){

TestClass tc = new TestClass();

tc.testMethod();

}

}

False - you cannot call a static member in an Interface, you must call it via the Interface name.

ITest.testMethod();

True or false - since member variables are hidden and not overridden, you can't access a member variable two levels up unless you cast it.

class c1 {

public static int i = 10;

}

class c2 extends c1 {

private static int i = 20;

}

class c3 extends c2 {

public static void main(String[] args){

c3 ceeThree = new c3();

System.out.println("int i="+ceeThree.i); // won't compile because c2's variable is private

System.out.println("int i="+((A)ceeThree).i); // will compile because c1's variable is public

}

}