Java Programming Basics Quiz

Java Fundamentals Chapter 2 Topics

• Chapter 2 covers various key topics in Java programming, including the parts of a Java program, the print and println methods, variables and literals, primitive data types, arithmetic operators, combined assignment operators, creating named constants, the String class, scope, comments, programming style, the Scanner class for input, and dialog boxes.

Parts of a Java Program

• A Java source code file can contain one or more Java classes.
• If a file has multiple classes, only one can be public.
• The public class name must match the filename (e.g., a class named Simple must be in a file named Simple.java).
• Java classes are made up of parts.

Compiling and Running a Java Program

• To compile a Java program (e.g., Simple.java), use the command javac Simple.java. This creates a .class file.
• To run the compiled program, use the command java Simple.

Analyzing the Example Program

• Comments in Java code begin with // for single-line comments and /* */ for multi-line comments; they are ignored by the compiler.
• The public class Simple line defines the class and its name.
• The body of the class is enclosed in curly braces {}.
• The public static void main(String[] args) method is the entry point of a Java program; it is where the program's actions begin when executed.
• System.out.println() is used to display output on the console.

Parts of a Java Program (Detailed)

• Comments: Ignored by the compiler; used for documentation. Single-line comments begin with //. Multi-line comments begin with /* and end with */.
• Class Header: Specifies the class name and other characteristics. The keywords public and class are essential, along with the class name.
• Curly Braces: Define the scope of the class or method.
• Main Method: The main method is the entry point to a Java program. The program begins executing instructions from within this method. It takes a parameter, String[] args. Every java application must have a main method.
• Java Statements: Lines of executable code; ended with semicolons.

Java Statements (Detailed)

• Comments ( // or /* */ ) do not require semicolons.
• Class headers and method headers do not require semicolons.
• Curly braces are not Java statements.

Special Characters

• //: Marks the beginning of a single-line comment.
• (...): Used in method headers to mark the parameter list.
• {}: Encloses a group of statements (e.g., a class).
• "": Encloses a string of characters.
• ;: Marks the end of a complete Java statement.

Console Output

• Java programs often run in console windows.
• System.out.println() sends output to the console.
• System.out.print() sends output to the console. No new line.
• The output device is called the standard output.
• The input device (typically to get input) is the keyboard.
• The standard java library is the Java API, and specific classes, like System, are accessed using it.

Java Escape Sequences

• Escape sequences let you include special characters in strings.
• \n: Newline (starts a new line).
• \t: Tab.
• \b: Backspace.
• \r: Carriage Return. (moves the cursor to the beginning of the line.)
• \\: Backslash.
• \': Single quote.
• \": Double quote.

Variables and Literals

• A variable is a named storage location in memory.
• A literal is a fixed value in the code.
• Programmers determine the required variables and their types.

The + Operator

• The + operator can be used for both addition and string concatenation (joining strings). If one side is a string, the '+' operator concatenates.

String Concatenation

• Java strings cannot span multiple lines.
• Use the concatenation operator + to join strings (and other data types to strings).

Identifiers

• Identifiers are programmer-defined names for classes, variables, and methods.
• They must follow naming rules (e.g.: letters, numbers, underscores, $ signs).
• Identifiers are case-sensitive.

Java Reserved Keywords

• A list of Java keywords are provided. These keywords have specific meanings in Java.

Variable Names

• Use descriptive variable names for better code readability and maintainability.

Java Naming Conventions

• Variable names usually begin with a lowercase letter and are in title case afterwards
• Class names are all in title case.
• Variables and classes are often nouns.

Primitive Data Types

• There are 8 built-in primitive data types in Java.

Numeric Data Types (byte, short, int, long, float, double)

• Each data type has a defined size and range of values.

Variable Declarations

• The general format of declaring variables in Java (DataType VariableName;).

Integer Data Types

• Integer data types represent whole numbers without decimal points.

Floating-Point Data Types

• Floating-point types (float and double) store decimal values.
• Precision differs between float and double.
• float literals need to be marked with an F or f.

Floating-Point Literals

• Floating-point literals in Java default to double type.
• To make a literal a float type, append F
• Floating-point numbers can be represented in scientific notation (e.g., 4.728197 x 104 or 4.728197E4)

The boolean Data Type

• Boolean variables hold only the values true or false.

The char Data Type

• char data type represents single characters.
• Unicode characters are used. Each character takes up 2 bytes.

Unicode

• Characters in Java programs are stored as Unicode characters. The first 256 characters are compatible with ASCII.

Variable Assignment and Initialization

• Variables usually have to be declared (int month) and then assigned a value (month = 2).
• Local variables do not automatically take on default values.
• Initialization is required before use of the variable.

Arithmetic Operators

• Java has five arithmetic operators (+, -, *, /, %).
• Integer division truncates any decimal remainder.

Operator Precedence

• Java has rules for the order in which arithmetic operators are executed (precedence). Parenthesis change the order.

Grouping with Parentheses

• Innermost parentheses are evaluated first, then left to right.

Combined Assignment Operators

• Shorthand methods for adding (or subtracting, multiplying or dividing) by another variable (+=, -=, *=, /=, %=).

Creating Constants with final

• Use final to declare constants (variables whose values cannot be changed).
• Constants are conventionally written in all upper case letters.

The String Class

• The String class is used to manipulate sequences of characters.
• Strings are immutable objects.

Primitive vs. Reference Variables

• Primitive variables directly store their values in memory.
• Reference variables store a memory address that points to an object.

String Objects

• String literals are assigned to variables directly.
• The new keyword is necessary to create instances of other object types from the String class

String Methods

• The String class provides methods to manipulate string objects; length, etc.

Scope

• The scope of a variable defines the part of the program where it's accessible.
• Local variables are accessible only within the method where they are declared.

Commenting Code

• Java has single-line, multi-line, and Javadoc comments.
• Javadoc comments can generate HTML documentation.

Programming Style

• Whitespace is generally ignored by the Java compiler but affects readability.

Indentation

• Programs should use consistent indentation to improve code readability and structure.

The Scanner Class

• Reads input from the console (keyboard).

The System.exit Method

• System.exit(0); terminates the program; 0 is a standard for successful exit code.

Converting a String to a Number

• The showInputDialog method retrieves input as a string, not as a number. Parse methods are needed to convert strings into numbers.

Parse Methods

• The parse methods convert strings to other numeric types. Methods for each type are available (e.g., Integer.parseInt(), Double.parseDouble() etc).