Chapter 4 Methods and Encapsulation

Question 1

What access modifiers Java offers for methods ?

Answer 1

1. public - The method can be called from any class.
2. private - The method can only be called from within the same class.
3. protected - The method can only be called from classes in the same package or subclasses.
4. Default (Package Private) Access - The method can only be called from classes in the same package. This one is tricky because there is no keyword for default access. You simply omit the access modifier.

Question 2

What optional specifiers Java offers (six) ?

Answer 2

1. static - Used for class methods.
2. abstract - Used when not providing a method body.
3. final - Used when a method is not allowed to be overridden by a subclass.
4. synchronized - On the OCP but not the OCA exam.
5. native - Not on the OCA or OCP exam. Used when interacting with code written in another language such as C++.
6. strictfp - Not on the OCA or OCP exam. Used for making floating-point calculations portable.

Question 3

What is the difference between default and protected access modifiers from methods point of view ?

Answer 3

• Protected - The method can only be called from classes in the same package or subclasses.
• Default - The method can only be called from classes in the same package.

Question 4

Can instance members call static members and vice versa ?

Answer 4

When referenced from outside the class, methods are called using the classname—for example, StaticClass.method(). Instance members are allowed to call static members, but static members are not allowed to call instance members.

Question 5

What is pass-by-value ?

Answer 5

It means that calls to methods create a copy of the parameters. Assigning new values to those parameters in the method doesn’t affect the caller’s variables.

Question 6

What means overloaded methods ?

Answer 6

Overloaded methods are methods with the same name but a different parameter list. Java calls the most specific method it can find. Exact matches are preferred, followed by wider primitives. After that comes autoboxing and finally varargs.

Question 7

When the default no-argument constructor is called ?

Answer 7

The default no-argument constructor is called when no constructor is coded.

Question 8

Can multiple constructors call each other ?

Answer 8

Multiple constructors are allowed and can call each other by writing this(). If this() is present, it must be the first statement in the constructor.

Question 9

Do you know the order of initialization ?

Answer 9

1. If there is a superclass, initialize it first.
2. Static variable declarations and static initializers in the order they appear in the file.
3. Instance variable declarations and instance initializers in the order they appear in the file.
4. The constructor.

Question 10

What rules for JavaBeans naming conventions do you know ?

Answer 10

• Properties are private;
• Getter methods begin with is if the property is a boolean;
• Getter methods begin with get if the property is not a boolean;
• Setter methods begin with set;
• The method name must have a prefix of set/get/is, followed by the first
  letter of the property in uppercase, followed by the rest of the property name;

Question 11

Are parentheses around parameter list required in lamda expressions ?

Answer 11

The parentheses are only optional when there is one parameter and it doesn’t have a type declared.

print(() -> true); // 0 parameters
print(a -> a.startsWith(“test”)); // 1 parameter
print((String a) -> a.startsWith(“test”)); // 1 parameter
print((a, b) -> a.startsWith(“test”)); // 2 parameters
print((String a, String b) -> a.startsWith(“test”)); // 2 parameters

Question 12

Will this compile:

public void methodA () { return; }
public void methodB () { return null; }

Answer 12

public void methodA () { return; } // YES
public void methodB () { return null; } // NO - Void methods cannot return a value

Question 13

What is encapsulation and what is immutability ? How they differ ?

Answer 13

Encapsulation requires using methods to get and set instance variables so other classes are not directly using them. Instance variables must be private for this to work. Immutability takes this a step further, allowing only getters, so the instance variables do not change state.

Question 14

Will this compile and if not why:

public class TestClass { public testClass() {} }

Answer 14

It won’t compile. The compiler will say “Return type for the method is missing”. It looks like default constructor but it isn’t because its name should match the name of the class (case-sensitive).

Question 15

True or False: Both instance and static initializers are able to access static variables ?

Answer 15

True

Question 16

Which is valid:

s -> s.isEmpty()

s -> { s.isEmpty() }

s -> { s.isEmpty(); }

s -> { return s.isEmpty(); }

String s -> s.isEmpty()

(String s) -> s.isEmpty()

Answer 16

s -> s.isEmpty() - OK

s -> { s.isEmpty() } - return keywork is required inside braces for lambda bodies

s -> { s.isEmpty(); } - return keywork is required inside braces for lambda bodies

s -> { return s.isEmpty(); } - OK

String s -> s.isEmpty() - it is missing the parentheses around the parameter list

(String s) -> s.isEmpty() - OK