Chapter 4 - Methods and Encapsulation

Question 1

Access Modifiers

(4)

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. You’ll learn about subclasses in Chapter 5.
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 modi er.

Question 2

Optional Specifiers

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++.

strictfp Not on the OCA or OCP exam. Used for making oating-point calcu- lations portable.

Question 3

Varargs in Methods

(2)

Answer 3

A vararg parameter must be the last element in a method’s parameter list. This implies you are only allowed to have one vararg parameter per method.

public static void walk(int start, int… nums) { System.out.println(nums.length);
}

–> walk(3) will output 0
(Java creates an array of lenghth 0 for int… nums)

Question 4

Applying Access Modifiers

(4)

Answer 4

1. Private Access: Only code in the same class can call private methods or access private fields.
2. Default (Package Private) Access: When there is no access modi er, Java uses the default, which is package private access. This means that the member is “private” to classes in the same package. In other words, only classes in the package may access it.
3. Protected Access: allows everything that default (package private) access allows and more. The protected access modifier adds the ability to access members of a parent class.
   
   • If a member is used without referring to a variable, we are taking advantage of inheritance and protected access is allowed.
   • If a member is used through a variable, the rules for the reference type of the variable are what matter. If it is a subclass, protected access is allowed.
     * Public Access: public means anyone can access the member from anywhere.

Question 5

Reasons for static Methods

(2)

Answer 5

• For utility or helper methods that don’t require any object state. Since there is no need to access instance variables, having static methods eliminates the need for the caller to instantiate the object just to call the method.
• For state that is shared by all instances of a class, like a counter. All instances must share the same state. Methods that merely use that state should be static as well.

Question 6

Static vs. Instance

(2)

Answer 6

* Koala k = new Koala();
 System.out.println(k.count); // outputs count
 k = null;
 System.out.println(k.count); //still outputs count
* A static member cannot call an instance member.

Question 7

Static Imports

Answer 7

import static package.class.methodName;

import static package.class.variableName;

Question 8

Overloading Methods

(2)

Answer 8

• Method overloading occurs when there are different method signatures with the same name but different type parameters.
• This means there can be different access modifiers, specifiers (like static), return types, and exception lists.

Question 9

Order for Overloaded Methods

(4)

Answer 9

1. Exact match by type: public String glide(int i, int j) {}
2. Larger primitive type: public String glide(long i, long j) {}
3. Autoboxed type: public String glide(Integer i, Integer j) {}
4. Varargs: public String glide(int… nums) {}

Question 10

Order of Initialization

Answer 10

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 11

Encapsulation

(5)

Answer 11

1. Properties are private: private int numEggs;
2. Getter methods begin with is if the property is a boolean.public boolean isHappy() { return happy;}
3. Getter methods begin with get if the property is not a boolean. public int getNumEggs() { return numEggs;}
4. Setter methods begin with set. public void setHappy(boolean happy) { this.happy = happy;}
5. The method name must have a prefix of set/get/is, followed by the first letter of the property in uppercase, fol- lowed by the rest of the property name.public void setNumEggs(int num) { numEggs = num;}

Question 12

Immutable Classes

(3)

Answer 12

• private Variables
• no Setters
• Initialization e.g. in Constructors

Question 13

Lambda Syntax

Answer 13

• a -> a.canHop()
• (Animal a) -> { return a.canHop(); }

Question 14

Accessing Variables in Lamdas

Answer 14

• Instance and static variables are okay.
• Method parameters and local variables are fine if they are not assigned new values.

Question 15

Predicates

Answer 15

public interface Predicate<t> {<br></br> boolean test(T t);<br></br>} </t>