First Java Program - Input/Output, Debugging and Datatypes

Main ideas / lessons

• Getting started with Java programs (hands-on):

  • The session introduces how to write and run your first Java program using a terminal/text editor workflow.
  • Later, it shows what the same process looks like in IntelliJ IDEA.

• Java program structure:

  • Java source files use the .java extension.
  • Every .java file represents a class.
  • A file typically contains a public class whose name must match the file name.
  • All executable code is placed inside a class, and the program starts from the main method.

• Compilation and bytecode:

  • javac compiles .java into .class bytecode (not directly into machine code).
  • The program runs via the java command using the bytecode.
  • Java is platform independent because it runs bytecode on the JVM.

• Key keywords in public static void main(String[] args):

  • public: accessible from anywhere.
  • static: allows running without creating an object of the class.
  • void: the method returns no value.
  • String[] args: command-line arguments (an array of strings).
  • main: the required entry point; without it the program won’t run.

• Input/Output basics:

  • Output: System.out.println(...)
  • Input: Scanner (from java.util) using System.in (keyboard by default)

• Primitive data types:

  • Core primitives covered: int, long, char, float, double, boolean.
  • Numeric literal conventions:
    • add f for float
    • add L for long
  • Primitives vs wrapper classes:
    • primitives can’t be used like objects with methods
    • wrapper classes (e.g., Integer) provide methods (conversions, comparisons, etc.)

• Debugging:

  • Demonstrates IntelliJ’s Debug to step through code line-by-line.

• Type conversion, casting, and promotion rules:

  • Automatic widening conversion when the destination type is “greater/compatible.”
  • Automatic conversion does not work for narrowing.
  • Explicit casting is used to convert between incompatible types (e.g., double → int/byte).
  • Type promotion in expressions:
    • byte/short/char promote to int
    • presence of long promotes to long
    • presence of float promotes to float
    • presence of double promotes to double

• Control flow basics:

  • Conceptual use of if, while, and for loops.
  • Typical guidance:
    • use while if you don’t know the iteration count ahead of time
    • use for if you know the iteration count ahead of time

• Mini example application: Celsius → Fahrenheit:

  • Reads a Celsius temperature (float), then calculates:
    • fahrenheit = celsius * 9/5 + 32
  • Prints the result.

• Course direction / future topics:

  • Deeper explanations of OOP concepts (classes/objects, constructors, access modifiers, inheritance).
  • Arrays, wrapper classes, and improved input/output and debugging later.

---

Methodology / instructions presented (detailed)

1) Creating and running a Java program via terminal (conceptual steps)

• Create a source file named something like main.java (class/file matching rules still apply).
• Inside the file:
  • Define a class (typically public class Main { ... }) where class name matches the file name.
  • Implement public static void main(String[] args).
  • Put all executable statements inside main.
• Compile:
  • Run: javac Main.java (example used: javac main.java)
  • This generates Main.class (bytecode).
• Execute:
  • Run: java Main
  • The JVM runs the compiled bytecode.

2) Understanding compilation output location (with javac -d)

• By default, compiled .class files appear alongside where the compilation happens.
• Use the -d flag to control output directory:
  • javac -d <targetFolder> <sourceFile>
• Best practice mentioned:
  • keep source in a src/ folder
  • keep compiled bytecode in an out/ folder (common project layout)

3) Writing the main method (structure + meaning)

• Required entry signature:
  • public static void main(String[] args) { ... }
• Place code inside { }.
• Meaning of signature parts:
  • main = required entry point name
  • public = accessible from anywhere
  • static = runs without object creation
  • void = returns nothing
  • String[] args = command-line arguments

4) Output in Java

• Use:
  • System.out.println("Hello World");
• Notes:
  • println appends a newline after printing.
  • System.out.print(...) prints without a newline.

5) Input in Java using Scanner

• Import Scanner:
  • import java.util.Scanner;
• Create a scanner on keyboard input:
  • Scanner input = new Scanner(System.in);
• Read values:
  • integers: input.nextInt()
  • floats: input.nextFloat()
  • strings:
    • word-only: input.next()
    • whole line: input.nextLine()
• Print results using System.out....

6) Debugging (IntelliJ)

• Set a debug point (a red marker) on a line.
• Click Debug to step through execution line-by-line.
• Observe variable values in the console/debugger panes.

7) Type conversion/casting logic taught

• Automatic conversion (widening) happens when:
  • types are compatible
  • destination type is “greater than” source type (e.g., int → float)
• Casting (explicit conversion) is used for narrowing cases, such as:
  • double → int (loses fractional part)
  • float → int
  • numeric value fits differently into smaller types (e.g., byte)
• Casting behavior described:
  • narrowing to byte can produce modulo-like “remainder” results when value exceeds byte range.

8) Type promotion rules in expressions

During evaluation, Java promotes smaller primitives in a specific order:

• byte, short, char → promoted to int
• if any operand is long → expression becomes long
• if any operand is float → expression becomes float
• if any operand is double → expression becomes double

9) Loop / condition templates (conceptual)

• if:
  • if the condition is true, execute the block; otherwise skip.
• while:
  • repeat while a condition remains true; increment inside the loop.
• for:
  • initialization, condition, and increment are provided in the loop header.

10) Celsius to Fahrenheit formula example

• Read Celsius as float.
• Compute:
  • fahrenheit = (celsius * 9 / 5) + 32
• Print the Fahrenheit result.

---

Speakers / sources featured

• Speaker: Kunal (repeatedly referenced as the instructor; also addressed as “Hey Kunal”).