BudiBaduQuiziBadu

Java Packages & Import Statements Quiz

Java
0 Passed
0% acceptance

40 deep, practical, and often overlooked questions about Java packages — from directory structure enforcement and classpath mechanics to import rules, static imports, naming conventions, and the subtle ways packages affect accessibility, compilation, and runtime behavior.

40 Questions
~80 minutes
1

Question 1

What is the primary purpose of packages in Java beyond mere code organization?

A
To provide a namespace and enforce access control at the package level
B
To improve runtime performance
C
To enable multiple inheritance
D
To allow dynamic class loading
2

Question 2

Why does this perfectly valid class fail to compile when placed in the file src/com/example/MyClass.java?

java
class MyClass {
    public void hello() {}
}
A
Missing package declaration — file is in com/example but class has no package
B
Class name must match file name exactly
C
Missing public modifier
D
No main method
3

Question 3

Which of these package names is explicitly forbidden by the Java Language Specification?

A
java.utils
B
com.mycompany.app
C
myapp.internal
D
_private.api
4

Question 4

What happens when two jars on the classpath both contain the same fully qualified class?

A
The class loaded first (classpath order) wins — others are ignored
B
Compilation error
C
LinkageError at runtime
D
The newest version is chosen
5

Question 5

Why is the default (package-private) access modifier extremely useful when combined with packages?

A
Members are visible only within the same package — perfect for internal APIs
B
It makes members public
C
It hides members from subclasses
D
It prevents serialization
6

Question 6

Which import statement correctly allows use of Arrays.asList without qualifying the class?

A
import java.util.Arrays;
B
import java.util.*;
C
import java.util.Arrays.asList;
D
Both A and B
7

Question 7

Why does this static import allow calling asList() directly?

javascript
import static java.util.Arrays.asList;
// List<String> list = asList("a", "b");
A
Static import brings the method into the current namespace
B
It imports the entire Arrays class
C
It only works for fields
D
Compilation error
8

Question 8

What is the recommended package naming convention for open-source or commercial Java projects?

A
Reverse domain name (e.g., com.github.username.project)
B
All lowercase single word
C
Same as class name
D
Uppercase to match class
9

Question 9

Why does this import cause a compilation error?

java
import java.util.*;
import java.awt.*;
// List colors;
A
Both packages contain a List type — ambiguous reference
B
import statements must be first
C
Too many imports
D
No error
10

Question 10

What is the fully qualified name of this class?

java
package com.mycompany.app.service;

public class UserService {
}
A
com.mycompany.app.service.UserService
B
UserService
C
com/mycompany/app/service/UserService
D
service.UserService
11

Question 11

Which of these is NOT a valid package name according to the language specification?

A
com.example._internal
B
com.example.my-project
C
com.example.2utils
D
com.example.utils
12

Question 12

Can a public class be placed in the default (unnamed) package?

A
Yes, but strongly discouraged and forbidden in modular JARs
B
No — public classes must have a package
C
Only in Java 8 and earlier
D
Only for testing
13

Question 13

Why does this static import on-demand compile successfully?

javascript
import static java.lang.Math.*;
// double r = sqrt(16);
A
It brings all static members of Math into scope
B
Only works for constants
C
Causes conflict with local methods
D
Compilation error
14

Question 14

What happens if you declare two classes with the same simple name in different packages and try to use both without qualification?

A
Compilation error — ambiguous reference
B
Runtime exception
C
The one imported first wins
D
Always picks java.lang
15

Question 15

Which package name would be most appropriate for internal utility classes of a library called AcmeTools?

A
com.acme.tools.internal
B
com.acme.tools
C
internal.com.acme.tools
D
acme.tools.hidden
16

Question 16

Why is it considered a bad practice to use wildcard imports (import package.*) in production code?

A
It obscures which classes are actually used and can cause conflicts
B
It slows down compilation
C
It increases bytecode size
D
It prevents modularization
17

Question 17

What is the only package that is automatically imported into every Java source file?

A
java.lang
B
java.util
C
java.io
D
None — all must be imported
18

Question 18

Can a file contain more than one package declaration?

A
No — exactly one package statement (or none) per compilation unit
B
Yes — multiple are allowed
C
Only in module-info.java
D
Only for inner classes
19

Question 19

Why does this compilation unit compile successfully even though no import is present?

javascript
class Test {
    String name;
    System system;
}
A
java.lang types (String, System) are automatically available
B
Implicit import of current package
C
Default import of java.util
D
IDE adds imports silently
20

Question 20

Which of these package names is technically legal but universally considered terrible practice?

A
com.sun.internal.util
B
org.mycompany.app
C
myapp
D
utils
21

Question 21

What is the correct directory structure for the class com.example.service.UserService?

A
src/com/example/service/UserService.java
B
src/com.example/service/UserService.java
C
src/com/example/UserService.java
D
src/UserService.java
22

Question 22

Why does this static import fail with a compiler error?

javascript
import static java.util.Collections.EMPTY_LIST;
// List list = EMPTY_LIST;
A
EMPTY_LIST was renamed to List.of() — field no longer exists
B
Static imports don’t work on fields
C
Missing public modifier
D
Conflicts with java.awt.List
23

Question 23

Which classes from the same package can access a package-private member?

A
Any class in the exact same package, regardless of inheritance
B
Only subclasses
C
Only classes in subpackages
D
Only the declaring class
24

Question 24

What is the most important reason to avoid placing any code in the default package?

A
It cannot be used from named packages and is forbidden in modules
B
It runs slower
C
It prevents garbage collection
D
It disables generics
25

Question 25

Which of these import statements is illegal?

A
import static java.lang.System.out;
B
import java.util.*;
C
import static java.lang.Math.*;
D
import java.lang.*;
26

Question 26

Why do many large codebases forbid wildcard imports entirely?

A
They make it impossible to see at a glance which classes are actually used
B
They cause runtime overhead
C
They prevent tree-shaking
D
They increase JAR size
27

Question 27

What is the correct way to refer to a class that has the same simple name as another imported class?

A
Use its fully qualified name
B
Remove one of the imports
C
Use this.ClassName
D
Cast it
28

Question 28

Why is the package name org.example recommended for example code instead of com.example?

A
org is reserved for non-commercial and open-source organizations
B
com is only for companies
C
No difference
D
org prevents deployment
29

Question 29

Can a package declaration contain comments or annotations?

A
No — it must be the very first non-whitespace statement in the file
B
Yes — comments are allowed before
C
Only Javadoc comments
D
Only @Deprecated
30

Question 30

What is the most common real-world consequence of choosing a bad package name?

A
Naming conflicts when publishing to public repositories or merging code
B
Slower execution
C
Larger bytecode
D
GC pauses
31

Question 31

Why are subpackages not automatically visible to their parent packages?

A
There is no hierarchical relationship — com.example and com.example.utils are unrelated
B
Security restriction
C
Performance optimization
D
Only in modules
32

Question 32

Which of these is considered the cleanest way to import multiple constants from an enum?

A
import static com.example.Color.*;
B
import com.example.Color;
C
No import — use Color.RED directly
D
import com.example.*;
33

Question 33

What is the purpose of the package-info.java file?

A
To hold package-level Javadoc and annotations (e.g., @Deprecated)
B
To define package-private classes
C
To declare module exports
D
To store configuration
34

Question 34

Why does the Java platform itself use packages like jdk.internal.*?

A
To clearly signal that these APIs are not supported for external use
B
For performance
C
To reduce JAR size
D
To enable encapsulation
35

Question 35

After completing this quiz, what is the single most important lesson about packages?

A
Packages are Java’s primary mechanism for namespace management and encapsulation
B
Packages are optional
C
Wildcard imports are best practice
D
Package structure doesn’t affect compilation
36

Question 36

Which classes automatically belong to the same package as the current class without any import?

A
Other classes in the exact same package
B
Classes in subpackages
C
Classes in java.util
D
Inner classes only
37

Question 37

Why should you never name a package 'test' at the top level?

A
It conflicts with common test source roots and build tools
B
It’s reserved by the JVM
C
It prevents testing
D
It disables assertions
38

Question 38

What is the only valid position for the package declaration in a Java source file?

A
The very first line (before any comments or blank lines)
B
After imports
C
After the class declaration
D
Anywhere before the class
39

Question 39

Which of these is considered the gold standard for package naming in enterprise applications?

A
Reverse internet domain + project + logical layers (e.g., com.acme.banking.service)
B
Single word lowercase
C
All uppercase
D
Same as module name
40

Question 40

You now fully understand that:

A
Packages are not just folders — they are Java’s core namespace and access control mechanism
B
Package structure is optional
C
java.* packages are safe to use
D
Imports affect runtime performance

Other Quiz Categories

JavaScript
47 quizzes
Basics
Variables & Data Types
Operators & Expressions
Rust
30 quizzes
Cargo and Project Setup
Variables and Mutability
Data Types
Python
29 quizzes
Introduction & Core Fundamentals
Data Types Overview
Type Casting
Golang
29 quizzes
Basics & Syntax
Data Types & Zero Values
Operators & Expressions
C++
26 quizzes
Basics
Variables & Data Types
Operators & Expression
Matlab
21 quizzes
Basics & Environment
Variables and Data Type
Arrays and Matric
TypeScript
19 quizzes
Introduction and Overview
Installation and Configuration
Basic Types and Type Annotations
SQL Database
15 quizzes
Foundations and Basics
Basic Query Selection
Filter, Sort, and Alias Essentials
PHP
15 quizzes
Syntax Building Blocks
Variable Naming
Data Types Overview
Linked List
11 quizzes
Introduction
Node Structure and Pointer Fundamentals
Singly Linked List

QUIZZES IN Java

1

Java Basics & JVM Fundamentals

50

50 in-depth questions (30 with code) covering Java platform independence, JVM architecture, compilation, bytecode, class loading, memory areas, garbage collection, and your first real Java program.

2

Variables, Data Types & Type Casting

40

40 focused questions Java primitive and reference types, variable declaration rules, widening/narrowing conversions, the final keyword, and the most common type-casting pitfalls.

3

Operators & Expressions

40

40 medium-to-advanced questions Java operators & expressions that force deep thinking about arithmetic, relational, logical, assignment, and ternary operators — including precedence traps, short-circuit behavior, compound assignment quirks, and real-world expression bugs.

4

Strings & String Methods

35

35 in-depth questions covering String immutability, object creation, comparison behavior, common methods, StringBuilder/StringBuffer usage, and performance implications in real-world Java code.

5

Numbers & Math Class

35

35 deep-dive questions on Java's numerical capabilities, from Math utilities and rounding behavior to BigInteger/BigDecimal precision, number formatting, and the subtle dangers of primitive overflow.

6

Arrays & Multi-Dimensional Arrays

35

35 deep and practical questions on Java arrays — from declaration and initialization to advanced 2D/3D usage, Arrays utility methods, common pitfalls, and performance gotchas that trip even senior developers.

7

Classes, Objects & Constructors

40

40 deep and challenging questions that explore every corner of object creation, constructor behavior, the true meaning of this, the subtle differences between instance and static members, and the complete lifecycle of objects in Java.

8

Methods, Parameters & Overloading

35

35 challenging and insight-revealing questions that dive deep into how Java really handles method invocation, parameter passing, overloading resolution, varargs behavior, return type rules, and the subtle edge cases that surprise even experienced developers.

9

Packages & Import Statements

40

40 deep, practical, and often overlooked questions about Java packages — from directory structure enforcement and classpath mechanics to import rules, static imports, naming conventions, and the subtle ways packages affect accessibility, compilation, and runtime behavior.

10

Control Flow (if, else, switch)

35

35 deep, real-world, and frequently misunderstood questions about Java control flow — covering if-else pitfalls, dangling else, fall-through dangers, modern switch expressions, pattern matching, exhaustive checking, and the best practices that prevent bugs in production code.

11

Loops (for, while, do-while)

35

35 deep, practical, and often misunderstood questions about Java loops — from subtle break/continue label behavior and enhanced for-loop limitations to infinite loop detection, do-while quirks, loop unrolling myths, and the performance & safety best practices used in real production systems.

12

Encapsulation & Abstraction in OOP

35

35 in-depth questions (15 with code) covering encapsulation principles, getters/setters implementation, abstraction concepts, abstracting behavior, and design benefits in object-oriented programming.

13

Polymorphism (Compile-Time & Runtime)

35

35 in-depth questions (15 with code) covering method overloading as compile-time polymorphism, overriding as runtime polymorphism, dynamic method dispatch, upcasting/downcasting, and why polymorphism matters in object-oriented design.

14

Interfaces, Abstract Classes & Multiple Inheritance

35

35 in-depth questions (15 with code) covering interface basics, abstract class fundamentals, default/static methods in interfaces, functional interfaces, and multiple inheritance resolution in Java.

15

Exception Handling (try, catch, finally)

40

40 in-depth questions (20 with code) covering types of exceptions, try/catch syntax, finally block purpose, stack traces, and best practices in Java exception handling.

16

Custom Exceptions & Exception Hierarchy

30

30 in-depth questions (15 with code) covering creating custom exceptions, throw vs throws, checked vs unchecked exceptions, chained exceptions, and designing exception structures in Java.

17

Collections Framework (List, Set, Map)

35

35 in-depth questions (18 with code) covering List types (ArrayList, LinkedList), Set types (HashSet, TreeSet), Map types (HashMap, TreeMap), Collections utility class, and choosing the right collection for different use cases in Java.

18

Generics Deep Dive

35

35 in-depth questions (18 with code) covering why generics exist, generic methods, bounded type parameters, wildcards (? extends, ? super), and raw types pitfalls in Java.

19

Java I/O (Files, Streams, Readers/Writers)

35

35 in-depth questions (18 with code) covering Input/Output streams, Readers vs Writers, File operations, Buffered I/O, and handling I/O exceptions in Java.

20

Date & Time API (java.time)

35

35 in-depth questions (18 with code) covering LocalDate & LocalTime, LocalDateTime & ZonedDateTime, formatting dates, parsing dates, and Duration & Period in Java's modern date-time API.

21

Streams API (map, filter, reduce)

35

Master the Java Streams API for functional-style operations on collections. Learn to create streams, use intermediate operations like map and filter, apply terminal operations, perform reductions, and follow best practices for efficient stream processing.

22

JVM Memory Model (Heap, Stack, GC)

40

Understand the JVM memory architecture including heap and stack management, garbage collection mechanisms, classloader hierarchy, memory leak prevention, and JVM optimization techniques.