Writing Classes in AP Computer Science A

Supercalsses expose helper methods to reduce code duplication whereas composed objects might lead to the same functionality being reimplemented.

Subclasses can modify inherited fields directly if public or protected which isn't possible when using separate composed objects requiring mutator calls.

Both design choices equally support loose coupling between components since accesor metods prevent direct field manipulation regardless of inheretance or composition use.

Encapsulation is maintained when accessing superclass fields indirectly through accessor methods rather than directly exposing them even in related subclasses via inheritance or unrelated ones through composition.

public double setBalance()

public void getBalance()

private double getBalance()

public double getBalance()

Favoring composition over inheritance in order to increase modularity and flexibility.

Attempting to implement all methods defined in Class A as static, for ease of access without instantiation.

Seeking to override all methods from Class A in Class B, ensuring distinct behaviors across both classes.

Preferring polymorphism so that Class B can assume multiple forms through various subclass implementations.

Retrieving the balance of a bank account without allowing direct modification.

Calculating the total after applying tax to a product's price.

Changing the password associated with a user account.

Adding a new item to an inventory list in a shopping application.

Future requirements might need read-only access without altering the state.

It guarantees that subclass instances will automatically override these method implementations.

The Java Virtual Machine optimizes execution time when both types of methods are present.

All classes must have both accessor and mutator methods by convention only.

To create a new instance of an class.

To return the values of an object's variables.

To modify the values of an object's variables.

To turn an instance variable into a static variable.

public

protected

private

static

Providing direct access via getter methods to cloneable objects' fields without cloning first.

Adhering to the Open/Closed Principle by disallowing any changes made to fields after instantiation unless absolutely necessary for secure maintenance purposes.

Utilizing defensive copying techniques for both getting and setting composite mutable objects, avoiding exposure of internals.

Encapsulating all field mutable types by wrapping them with Immutable counterparts and providing only getters for those versions.

No impact since object retrieval is independent of initialization process

Performance varies randomly with each request

Faster as it avoids unnecessary instantiation until needed

Slower due to additional checks and possible instance creation

public Date getBirthdate() { return (Date)birthdate.clone(); }

public long getBirthdateInMillis() { return birthdate.getTime(); }

public Date getBirthdate() { return birthdate; }

private Date exposeBirthdate() { return birthdate; }