Question

Fill in the blanks in each of the following statements: a) When compiling a class in a package, the javac command-line option_______ specifies where to store the package and causes the compiler to create the package's directories if they do not exist. b) \(\operatorname{sering}\) class static method ________ is similar to method System.out.printf, but returns a formatted String rather than displaying a String in a command window. c) If a method contains a local variable with the same name as one of its class's fields, the local variable _______ the field in that method's scope. d) The_______ method is called by the garbage collector just before it reclaims an object's memory. e) \(\mathrm{A}(\mathrm{n}) \)______ declaration specifies one class to import. f) If a class declares constructors, the compiler will not create a(n) ___________ . g) An object's ___________ method is called implicitly when an object appears in code where a String is needed. h) Get methods are commonly called___________ or __________. i) \(A(n)\)____________ method tests whether a condition is true or false. j) For every enum, the compiler generates a static method called ___________ that returns an array of the enum's constants in the order in which they were declared. k) Composition is sometimes referred to as a(n)_______ relationship. I) \(A(n)\) ___________ declaration contains a comma-separated list of constants. \(\mathrm{m}\) ) \(\mathrm{A}(\mathrm{n}) \) __________ variable represents classwide information that is shared by all the objects of the class. n) \(A(n) \) _______________declaration imports one static member. o) The ___________ states that code should be granted only the amount of privilege and access that the code needs to accomplish its designated task. p) Keyword __________ specifies that a variable is not modifiable. q) \(A(n)\)________ consists of a data representation and the operations that can be performed on the data. r) There can be only one __________ in a Java source-code file, and it must precede all other declarations and statements in the file. s) \(\mathrm{A}(\mathrm{n})\) _______ declaration imports only the classes that the program uses from a particular package. t) The compiler uses a(n) _____________ to locate the classes it needs in the classpath. u) The classpath for the compiler and \(\mathrm{JVM}\) can be specified with the__________ option to the javac or java command, or by setting the ___________ environment variable. v) Set methods are commonly called __________ because they typically change a value. w) \(A(n)\) _____________ imports all static members of a class. x) The public methods of a class are also known as the class's __________ or _________ . y) System class static method __________ indicates that the garbage collector should make best-cffort attempt to reclaim objects that are eligible for garbage collection. z) An object that contains ________ has data values that are always kept in range.

Short answer

Variables include `-d`, `format`, `shadows`, `finalize`, `import`, `default constructor`, `toString`, `accessors/getters`, `predicate`, `values`, `has-a`, `enum`, `static`, `static import`, `principle of least privilege`, `final`, `class`, `package declaration`, `single-type import`, `classpath`, `-classpath/CLASSPATH`, `mutators`, `import static`, `interface/API`, `gc`, and `invariants`. Each term corresponds to the statement's blank in alphabetical order.

Step-by-step solution

Fill in Blank (a)

The blank in statement (a) can be filled with `-d` as it specifies where to store the package and causes the compiler to create the package's directories if they don't exist when using `javac`.

Fill in Blank (b)

For blank (b), the answer is `format`. This is because `String.format` is similar to `System.out.printf`, but it returns a formatted String.

Fill in Blank (c)

In statement (c), `shadows` is the term that fills the blank as a local variable `shadows` the field in a method's scope.

Fill in Blank (d)

To fill the blank in statement (d), use the term `finalize`. The garbage collector calls the `finalize` method before reclaiming an object's memory.

Fill in Blank (e)

Blank (e) should be filled with `import`. An `import` declaration specifies one class to import.

Fill in Blank (f)

The term `default constructor` fills the blank in statement (f) because if a class declares constructors, the compiler will not create a default constructor.

Fill in Blank (g)

For statement (g), the answer is `toString`. An object's `toString` method is called implicitly when an object appears where a String is needed.

Fill in Blank (h)

In statement (h), fill the blanks with `accessors` or `getters`. Get methods are commonly called accessors or getters.

Fill in Blank (i)

For blank (i), use `predicate` as a predicate method tests whether a condition is true or false.

Fill in Blank (j)

Fill the blank in statement (j) with `values`. Every enum has a static `values` method that returns an array of the enum's constants.

Fill in Blank (k)

In statement (k), the blank should be filled with `has-a`. Composition is sometimes referred to as a `has-a` relationship.

Fill in Blank (l)

Blank (l) can be filled with `enum`. An `enum` declaration contains a comma-separated list of constants.

Fill in Blank (m)

The term `static` fills the blank in statement (m) because a static variable represents class-wide information shared by all objects of the class.

Fill in Blank (n)

For statement (n), use `static import`. A `static import` declaration imports one static member.

Fill in Blank (o)

Blank (o) should be filled with `principle of least privilege`. This principle states that code should only have the privileges it needs.

Fill in Blank (p)

Fill the blank in statement (p) with `final`. The keyword `final` specifies that a variable is not modifiable.

Fill in Blank (q)

For statement (q), the term `class` fills the blank as a class consists of a data representation and the operations that can be performed on that data.

Fill in Blank (r)

The blank in statement (r) should be filled with `package declaration`. There can only be one `package declaration` in a Java source-code file.

Fill in Blank (s)

In statement (s), the answer is `single-type import`. A `single-type import` declaration imports only the classes that are used.

Fill in Blank (t)

The blank in statement (t) should be filled with `classpath`. The compiler uses `classpath` to locate classes.

Fill in Blank (u)

For blank (u), the terms are `-classpath` and `CLASSPATH`. These are used to specify the classpath for the compiler and JVM.

Fill in Blank (v)

Fill the blank in statement (v) with `mutators`. Set methods are commonly called `mutators` because they change values.

Fill in Blank (w)

The term `import static` fills the blank in statement (w), as it imports all static members.

Fill in Blank (x)

In statement (x), use `interface` or `API`. The public methods of a class are also known as its `interface` or `API`.

Fill in Blank (y)

Fill blank (y) with `gc`. System class static method `gc` indicates that the garbage collector should make an attempt to reclaim objects.

Fill in Blank (z)

The answer for blank (z) is `invariants`. An object that contains `invariants` maintains values within a defined range.

Key concepts

Java Constructors

Java constructors play a critical role in the process of object creation. In Java, a constructor is a block of code that's called when an instance of an object is created. A constructor in Java must have the same name as the class it is defined in. Furthermore, constructors do not have a return type. The primary purpose of a constructor is to initialize the newly created object.

There are two main types of constructors:

• Default Constructor: This is automatically provided by the Java compiler if no other constructors are defined in the class. Since the compiler does not create a default constructor once a custom constructor is declared, it's crucial to explicitly define a no-arg constructor if one is needed.
• Parameterized Constructor: Unlike the default constructor, this type accepts arguments, which allows for customizable instance creation based on the passed parameters.

These constructors can be overloaded, meaning you can have multiple constructors in a class with different parameter lists. This technique provides versatility in creating objects with various initial settings. Utilizing constructors effectively ensures objects are instantiated with valid initial states.

Garbage Collection in Java

In Java, garbage collection is a form of automatic memory management. The garbage collector is a part of the Java Runtime Environment (JRE) that frees memory occupied by objects that are no longer in use, thereby preventing memory leaks and optimizing performance.

Garbage collection in Java relies on the concept of "objects being unreachable." This means when an object no longer has any references pointing to it, it becomes eligible for garbage collection. The garbage collector then reclaims the memory so it can be reused for future allocations.

Java provides the `finalize` method, which is invoked just before the garbage collector reclaims the memory of an object. However, since Java 9, the use of `finalize` is deprecated because it can lead to unpredictable behavior and performance issues. Instead, developers can use other techniques like try-with-resources or manual resource management.

Additionally, the `System.gc()` method suggests to the JVM that it might be a good time to perform garbage collection, although execution is not guaranteed as it ultimately relies on JVM's decision.

Java Access Modifiers

Access modifiers in Java control the visibility of classes, methods, and variables. They determine the scope of accessibility and are essential for encapsulation, which is one of the core concepts of Object-Oriented Programming (OOP). Java provides several access modifiers, which are:

• Public: Accessible from any other class in the Java application.
• Protected: Accessible within its own package and by subclasses. This is crucial when extending classes.
• Default (Package-private): If no access modifier is specified, the member is accessible only within its own package.
• Private: The most restrictive access level; members are accessible only within the class itself.

These access modifiers facilitate the principle of least privilege, which dictates that components should have the least amount of privilege necessary to complete their tasks. By properly using access modifiers, developers can secure data within a class and prevent unauthorized access.

Import Statements in Java

Import statements in Java are used to bring other classes or the entire framework into the application's namespace, making the classes and their methods readily accessible. The primary goal is to simplify coding by reducing the need for fully qualified class names.

There are primarily two types of import statements:

• Single-Type Import: This import statement is used to import a single class or interface. It is denoted by the syntax `import packageName.ClassName;` and ensures only specified classes are available.
• Wildcard Import: By using the asterisk (`*`), one can import all classes within a package. It is written as `import packageName.*;`. However, it is generally recommended to avoid such imports where possible to prevent namespace clashes and improve code clarity.

Java also allows for the `static import` of static members. This enables static methods and fields to be referenced without qualifying them with the class name. Note that while `import` simplifies code, an excess of unnecessary imports can affect performance and readability, so it's essential to use them judiciously.