Introduction to Programming Basics

This chapter provides a foundational understanding of computer programming, covering the core concepts of languages, output, variables, and data types, using the Java programming language.

1. The Computer, Language, and Execution

A computer is often described as a “super dumb” machine—it cannot perform any task without being given explicit, step-by-step instructions.

Key Rule: Java is a case sensitive language, meaning that Variable is different from variable.

The environment used for writing, compiling, and running code is called an IDE (Integrated Development Environment).

Code Comments

Comments are notes within the code that are ignored by the compiler. They are used solely by developers for documentation or temporary code exclusion.

2. Output and the + Operator

The most basic function in any program is displaying output to the user.

The Concatenation Rule

The + operator has two behaviors based on its operands:

1. Arithmetic: If both operands are numbers, it performs standard addition.
2. Concatenation: If one or both operands are strings (text enclosed in quotes), it joins them together.

Important: Expressions are evaluated strictly from left to right.

3. Data Types and Variables

Variables are named containers in memory used to store data. Before using a variable, you must declare its Data Type to tell the compiler how much memory to reserve and what kind of data it will hold.

Core Primitive Data Types

3.5. Understanding Data Storage and Range

The Fundamental Unit: The Bit

A computer stores all information using electricity, which can only be in one of two states: on or off. This is represented by a Bit (Binary Digit), which holds a value of either 0 or 1.

• 1 Bit is the minimum storage unit.
• The size of a data type (e.g., 32 bits for an int) determines the range of possible unique values it can store.

Integer Range (32-bit int)

The standard Java int type uses 32 bits of memory. One bit is reserved to indicate the sign (positive or negative).

The Range Approximation for int

The large range is derived from the fundamental relationship that 2¹⁰ is approximately 10³ (since 2¹⁰ = 1024).

1. We start with the closest power of 2: 2¹⁰ ≈ 10³
2. Take the cube of both sides: (2¹⁰)³ ≈ (10³)³.
3. This gives: 2³⁰ ≈ 10⁹.
4. Multiply by 2 on both sides to reach 2³¹ : 2³¹ ≈ 2 × 10⁹.

This confirms that the maximum positive value for an int is 2³¹ – 1, or approximately 2 × 10⁹.

Extended Range (long)

The long data type uses 64 bits to store whole numbers, offering a significantly larger range.

The Range Approximation for long

Using the same approximation rule (2¹⁰ ≈ 10³):

1. We start with the closest power of 2: 2¹⁰ ≈ 10³.
2. Take the 6th power of both sides: (2¹⁰)⁶ ≈ (10³)⁶.
3. This gives: 2⁶⁰ ≈ 10¹⁸.
4. Multiply by 8 (or 2³) on both sides to reach 2⁶⁰ × 2³ ≈ 8 × 10¹⁸
5. This will give 2⁶³ ≈ 8 × 10¹⁸

This confirms that the maximum positive value for a long is 2⁶³ – 1, or approximately 8 × 10¹⁸ – 1.

Floating-Point Precision

For decimal numbers, the focus shifts from a maximum range to precision (how many digits after the decimal point can be accurately represented).

• float: Has low precision.
• double: Has high precision, making it the preferred choice for most decimal calculations.

4. Advanced Concepts and Input

Typecasting and Overflow

Typecasting is the process of converting a value from one data type to another.

• Safe Casting: Converting a value from a smaller type (e.g., int) to a larger type (e.g., long) is safe, like pouring water from a small cup into a large mug.
• Unsafe Casting: Converting a value from a larger type to a smaller type (e.g., long to int) can lead to data loss.

Overflow: This occurs when a value exceeds the maximum capacity of its container (data type). For example, trying to store a number larger than the int limit will cause the value to “wrap around,” resulting in a random negative number.

Taking User Input

To read input from the console in Java, the Scanner class is used. It must be imported before use.

Input Code Structure:

import java.util.Scanner; // Must be imported at the top

class Main {
	public static void main(String args[]) {
        // 1. Create a Scanner object to handle input
        Scanner sc = new Scanner(System.in);

        // 2. Use appropriate methods to read data:
        
        // Reads an integer
        int x = sc.nextInt();
        System.out.println(x);
		
        // Reads a long integer
        long y = sc.nextLong();
        System.out.println(y);
		
        // Reads a float
        float f = sc.nextFloat();
        System.out.println(f);
		
        // Reads a double
        double d = sc.nextDouble();
        System.out.println(d);
	}
}