Chapter 1 Welcome to Java Flashcards

Question

**CLASSES VS. FILES**

Answer 1

1. **Most of the time, each Java class is defined in its own .java file.** 2. Java does **not require** that the **class be public.** 3. You can even put two classes in the same file. 4. **Only one** of the classes in the file is **allowed to be public.** 5. If you do have a **public class**, it **needs to match the filename.**

Answer 2

* Most of the time, each Java class is defined in its own .java file. * It is usually public, which means any code can call it. * Interestingly, Java does not require that the class be public. For example, this class is just fine: ``` 1: class Animal { 2: String name; 3: } ``` * You can even put two classes in the same file. * When you do so, at most one of the classes in the file is allowed to be public. That means a file containing the following is also fine: ``` 1: public class Animal { 2: private String name; 3: } 4: class Animal2 { 5: } ``` * If you do have a public class, it needs to match the filename. * The declaration public class Animal2 would not compile in a file named Animal.java. * In Chapter 7, we will discuss what access options are available other than public.

Answer 3

* A Java program begins execution with its main() method. * A main() method is the gateway between the startup of a Java process, which is managed by the Java Virtual Machine (JVM), and the beginning of the programmer’s code. * The JVM calls on the underlying system to allocate memory and CPU time, access files, and so on.

Answer 4

``` public static void main(String []args) { } public static void main(String args[]) { } public static void main(String...args) { } public strictfp static void main(String[] args) { } public static void main(final String[] args) { } final static synchronized strictfp void main(final String[] args) { } ```

Answer 5

``` public class Zoo { public static void main(String[] args) { System.out.println("Welcome!"); } } ```

Answer 6

* Each file can contain only one public class. * The filename must match the class name, including case, and have a .java extension.

Answer 7

1. To **compile** Java code, the file must have the extension **.java.** 2. The **name** of the **file** must match the name of the **class**. 3. The result is a file of **bytecode** by the same name, but with a **.class** filename extension. 4. Remember that bytecode consists of instructions that the JVM knows how to execute. 5. Notice that we must **omit the .class** extension to run Zoo.java. 6. Each file can contain only one public class. 7. The **filename must match the class name,** including case, and have a **.java extension.** 8. **If the Java class is an entry point for the program, it must contain a valid main() method.**

Answer 8

1. main() method is required, will throw an error if we try execute the class. 2. public access modifier is required, will throw an error if we try execute the class. 3. static is required, will throw an error if we try execute the class. 4. void return type is required, will throw an error if we try execute the class. 5. main() method’s parameter list, represented as an array of java.lang.String objects. In practice, you can write any of the following: ``` String[] args String args[] String... args; String[] options String options [] String... options; ```

Answer 9

``` public final static void main(final String[] args) {} ```

Answer 10

1. array indexes begin with 0 ``` public class Zoo { public static void main(String[] args) { System.out.println(args[0]); System.out.println(args[1]); } } ``` 2. If you want spaces inside an argument, you need to use quotes ``` javac Zoo.java java Zoo "San Diego" Zoo San Diego Zoo ``` 3. output as String values ``` javac Zoo.java java Zoo Zoo 2 Zoo 2 ``` 4. Will throw exception if did not pass enough arguments ``` Zoo Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 1 out of bounds for length 1 at Zoo.main(Zoo.java:4) ```

Answer 11

1. Starting in **Java 11**, you can run a program without compiling it first 2. This feature is called **launching single-file source-code programs.** 2. if your program has two .java files, you still need to use javac. ex: ``` public class SingleFileZoo { public static void main(String[] args) { System.out.println("Single file: " + args[0]); } } java SingleFileZoo.java Cleveland ```

Answer 12

Full command * ex: ``` javac HelloWorld.java java HelloWorld ``` * Produces a **class** file * For **any program** * **Can import code in any available Java library** **Single-file source-code command** * ex: ``` java HelloWorld.java ``` * Fully in **memory** * For programs with **one** file * **Can only import code that came with the JDK**

Answer 13

``` import java.util.Random; // import tells us where to find Random public class ImportExample { public static void main(String[] args) { Random r = new Random(); System.out.println(r.nextInt(10)); // print a number 0-9 } } ```

Answer 14

1. **Java classes are grouped into packages** 2. The import statement tells the compiler which package to look in to find a class. 3. Java only looks for class names in the package. 4. If package name begins with **java** or **javax**, this means it came with the **JDK**. 5. package name ex: com.amazon.javabook 6. Java calls more detailed packages **child packages.**

Answer 15

Random cannot be resolved to a type ``` import java.util.Random; // import tells us where to find Random public class ImportExample { public static void main(String[] args) { Random r = new Random(); System.out.println(r.nextInt(10)); // print a number 0-9 } } ```

Answer 16

1. Classes in the same package are often imported together. 2. You can use a shortcut to import all the classes in a package. 3. The * is a wildcard that matches all classes in the package. 4. The compiler figures out what’s actually needed. 5. Which approach you choose is personal preference—or team preference if you are working with others on a team. * Listing the classes used makes the code easier to read, especially for new programmers. * Using the wildcard can shorten the import list.

Answer 17

``` import java.util.*; // imports java.util.Random among other things public class ImportExample { public static void main(String[] args) { Random r = new Random(); System.out.println(r.nextInt(10)); } } ```

Answer 18

The `*` is a wildcard that matches all classes in the package. It doesn’t import child packages, fields, or methods; it imports only classes.

Answer 19

**java.lang** There’s one special package in the Java world called java.lang. This package is special in that it is automatically imported.

Answer 20

The answer is that three of the imports are redundant. Lines 1 and 2 are redundant because everything in java.lang is automatically considered to be imported. Line 4 is also redundant in this example because Random is already imported from java.util.Random. If line 3 wasn’t present, java.util.`*` wouldn’t be redundant, though, since it would cover importing Random.

Answer 21

There are two possible answers. The shorter one is to use a wildcard to import both at the same time. ``` import java.nio.file.*; ``` The other answer is to import both classes explicitly. ``` import java.nio.file.Files; import java.nio.file.Paths; ```

Answer 22

Now let’s consider some imports that don’t work. ``` import java.nio.*; // NO GOOD - a wildcard only matches // class names, not "file.Files" import java.nio.*.*; // NO GOOD - you can only have one wildcard // and it must be at the end import java.nio.file.Paths.*; // NO GOOD - you cannot import methods // only class names ```

Answer 23

``` import java.nio.*; // NO GOOD - a wildcard only matches // class names, not "file.Files" import java.nio.*.*; // NO GOOD - you can only have one wildcard // and it must be at the end import java.nio.file.Paths.*; // NO GOOD - you cannot import methods // only class names ```

Answer 24

If you **explicitly import a class name, it takes precedence over any wildcards present.**

Answer 25

common example of this is the Date class. Java provides implementations of java.util.Date and java.sql.Date.

Answer 26

The answer should be easy by now. You can write either import `java.util.*; or import java.util.Date;.`

Answer 27

If you explicitly import a class name, it takes precedence over any wildcards present.

Answer 28

Java is smart enough to detect that this code is no good. As a programmer, you’ve claimed to explicitly want the default to be both the java.util.Date and java.sql.Date implementations. Because there can’t be two defaults, the compiler tells you the following: ``` error: reference to Date is ambiguous Date date; ^ ``` both class java.util.Date in java.util and class java.sql.Date in java.sql match

Answer 29

you can pick one to use in the import and use the other’s fully qualified class name [the package name, a period (.), and the class name] to specify that it’s special. Here’s an example: ``` import java.util.Date; public class Conflicts { Date date; java.sql.Date sqlDate; } ``` ``` public class Conflicts { java.util.Date date; java.sql.Date sqlDate; } ```

Answer 30

special unnamed package that you should use only for throwaway code.

Answer 31

When you run a Java program, Java knows where to look for those package names. In this case, running from C:\temp works because both packagea and packageb are underneath it. What do you think happens if you run java packageb/ClassB.java? This does not work. Remember that you can use the java command to run a file directly only when that program is contained within a single file. Here, ClassB.java relies on ClassA.

Answer 32

You can use an asterisk to specify that you’d like to include all Java files in a directory. ``` javac packagea/*.java packageb/*.java ```

Answer 33

1. The **-d** option specifies this **target directory**. 2. **Java options are case sensitive.** ``` javac -d classes packagea/ClassA.java packageb/ClassB.java ```

Answer 34

**1. -cp option is the short form. 2. -classpath 3. --class-path**

Answer 35

Windows: ``` java -cp ".;C:\temp\someOtherLocation;c:\temp\myJar.jar" myPackage.MyClass ``` macOS/Linux: ``` java -cp ".:/tmp/someOtherLocation:/tmp/myJar.jar" myPackage.MyClass ```

Answer 36

``` jar -cvf myNewFile.jar . jar --create --verbose --file myNewFile.jar . jar -cvf myNewFile.jar -C dir . ```

Answer 37

``` package singleFile; import java.util.*; public class Learning { private ArrayList list; public static void main(String[] args) { System.out.println("This works!"); } } java Learning.java // from within the singleFile directory java singleFile/Learning.java // from the directory above singleFile ```

Answer 38

1. **Package** declaration, optional 2. **Import** statements, optional 3. **Class** declaration, required 4. **Field** declarations, optional 5. **Method** declarations, optional

Answer 39

Setup procedure by operating system

Answer 40

* Create first class. Windows: C:\temp\packagea\ClassA.java Mac/Linux: /tmp/packagea/ClassA.java * Create second class. Windows: C:\temp\packageb\ClassB.java Mac/Linux: /tmp/packageb/ClassB.java * Go to directory. Windows: cd C:\temp Mac/Linux: cd /tmp

Answer 41

**Java calls a word with special meaning a keyword.**

Chapter 1 Welcome to Java Flashcards

(70 cards)