Chapter Overview

• Introduction to program design and data structures

• Focus on data and expressions in Java

Key Concepts

Character Strings

• Defined by the String class; represented as string literals with double quotes.

• Examples: "This is a string literal."

Output Methods

println Method

• Prints character strings with a line break.

• Prints to the System.out object (monitor).

print Method

• Similar to println but does not add a line break.

String Concatenation

• Operator + appends one string to another.

• Can append numbers to strings.

• Example: "Peanut butter " + "and jelly".

Escape Sequences

• Begins with a backslash \, used for special characters.

• Common escape sequences: \n (newline), \t (tab), \" (double quote).

Variables

• Name for a memory location, must be declared with a type.

• Can be assigned an initial value.

• Example of variable declaration: int total;.

Assignment Operator

• = changes the value of a variable.

• Can assign the result of expressions to variables.

• Example: total = 55;

Constants

• Identifiers with fixed values, declared with final.

• Example: final int MIN_HEIGHT = 69;

Primitive Data Types

• Eight basic types: byte, short, int, long, float, double, char, boolean.

Expressions

• Combination of operators and operands that evaluates to a value.

• Arithmetic operators include +, -, *, /, %.

Operator Precedence

• Determines the order of evaluation in expressions.

• Multiplication, division take precedence over addition.

Data Conversions

• Converting types safely (widening vs narrowing).

• Conversions in Java can involve assignment, promotion, or casting.

The Scanner Class

• Facilitates reading input, e.g., from the keyboard.

• Example usage: Scanner scan = new Scanner(System.in);.

• Methods include nextLine(), nextInt(), nextDouble(), etc.

Primitive Data Types

In Java, there are eight basic primitive data types, each serving a specific purpose and having its own size and range:

1. byte:

   • Size: 8 bits

   • Range: -128 to 127

   • Use: Ideal for saving memory in large arrays when memory savings are necessary.

2. short:

   • Size: 16 bits

   • Range: -32,768 to 32,767

   • Use: Also useful for saving memory when you know the values will be within this range.

3. int:

   • Size: 32 bits

   • Range: -2,147,483,648 to 2,147,483,647

   • Use: Commonly used for integer values.

4. long:

   • Size: 64 bits

   • Range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

   • Use: Used when a wider range of values is needed.

5. float:

   • Size: 32 bits

   • Use: Used for single-precision floating-point numbers (decimal values).

   • Note: Less precision than double.

6. double:

   • Size: 64 bits

   • Use: Used for double-precision floating-point numbers. Preferred for decimal values requiring high precision.

7. char:

   • Size: 16 bits

   • Use: Used to represent a single 16-bit Unicode character (e.g., 'A', '1').

8. boolean:

   • Size: Depends on the JVM (Java Virtual Machine)

   • Use: Represents a truth value (true or false).

Expressions

Expressions in Java are combinations of operators and operands that evaluate to a value. They can be simple or complex, involving multiple operations. Here are some key points about expressions:

• Operators: The symbols that indicate what operation to perform (e.g., + for addition, - for subtraction).

• Operands: The values or variables on which the operators act (e.g., 5 and 3 in the expression 5 + 3).

• Types of Operations: Arithmetic operations include addition (+), subtraction (-), multiplication (*), division (/), and modulus (%).

• Operator Precedence: Determines the order in which expressions are evaluated. For example, multiplication and division have higher precedence than addition and subtraction, meaning they are processed first.

• Complex Expressions: Expressions can be combined, for example: (a + b) * c will first evaluate a + b and then multiply the result by c.

• Use in Programming: Expressions are fundamental in controlling program flow, calculations, and data manipulation.