Java I/O, Variables & Operators — Beginner-
friendly guide
Overview
This note expands your original content and turns it into a beginner-friendly
reference. It covers:
Basic input/output using the IO helper methods mentioned in your note
How to read strings and convert them to other types (int, boolean,
double, etc.)
Primitive vs reference types, with simple definitions
Variable declaration and var type inference
Common operators (arithmetic, comparison, logical, concatenation)
Multiple examples, commented Java code, ASCII diagrams, analogies,
and step-by-step explanations
1. Input / Output (I/O)
Short idea: I/O lets your program talk to the outside world — print
messages to the screen and read what the user types.
The IO helper in your note
Your original note uses [Link], [Link], and [Link]():
[Link](Object) — prints [Link]() followed by a newline
(like pressing Enter after the text).
[Link](Object) — prints without adding a newline.
[Link]() — waits for the user to type a line and press Enter; it
returns a String.
Important: IO is often provided in learning environments (a helper class).
The exact behavior depends on that helper’s implementation. If your
environment doesn’t have IO, the standard Java equivalents are
[Link], [Link], and reading from Scanner or
BufferedReader.
Real-world analogy: Think of [Link] like speaking out loud and
then pressing ‘Enter’ on a microphone; [Link]() is like listening
and writing down whatever was said until the person presses Enter.
Basic example (your original, clarified)
void main() {
[Link]("What's your name?"); // Ask the user for their
name
String name = [Link](); // Read one line of
input, always returns a String
[Link]("Hello, " + name + "!"); // Print greeting using the
typed name
}
Reading non-string values: convert after reading
[Link]() returns a String. To get other types (int, boolean, double, long),
you first read the text then convert it using the relevant parse method.
int: [Link](String)
long: [Link](String)
double: [Link](String)
boolean: [Link](String)
Example with many types:
void main() {
[Link]("Enter your name:");
String name = [Link](); // Always a String
[Link]("Enter your favorite number:");
String numberStr = [Link](); // "42"
int number = [Link](numberStr); // Convert String →
int
[Link]("Do you like programming? (true/false)");
String boolStr = [Link]();
boolean likesProgramming = [Link](boolStr);
[Link]("Name: " + name + ", Favorite number: " + number + ",
Likes programming? " + likesProgramming);
}
Handling invalid input (safe parsing)
If the user types abc and you try [Link]("abc"), Java throws a
NumberFormatException. You should catch it and ask the user again.
void main() {
[Link]("Enter an integer: ");
String s = [Link]();
try {
int value = [Link](s); // may throw
NumberFormatException
[Link]("You entered: " + value);
} catch (NumberFormatException e) {
[Link]("That's not a valid integer. Please run the program
again and enter digits only.");
}
}
Step-by-step I/O flow (ASCII diagram)
Program -> print question ([Link])
User types a line and presses Enter
User input -> program receives a String from [Link]()
If you need a number: parse the String -> int/double/etc
Program -> print output based on the parsed value
2. Primitive types vs Reference types
Primitives (basic values)
These store simple values directly.
Type Example value Size (bits) Short description
byte 10 8 Very small whole
numbers
short 1000 16 Larger than byte, rarely
used
int 123 32 Commonly used for whole
numbers
long 1_000_000_000L 64 For very large integers
(note the L suffix)
float 3.14f 32 Single-precision floating
point (needs f suffix)
double 3.14 64 Default for decimal
numbers
char 'A' 16 Single UTF-16 character
(written with single
quotes)
boolea true / false - True or false
n
Simple explanation: primitives are like values written directly on a
sticky note — small, simple, and fast to access.
Reference types
These are more complex and store a reference (like a pointer) to an object
created somewhere else in memory.
Examples: String, arrays like int[], objects from classes (e.g., Person),
records, List<String>, etc.
Analogy: a reference type is like a label on a shelf that points to a
much bigger box containing the data. The variable holds the label,
not the entire box.
3. Declaring variables and var (type inference)
int i = 10; // explicit type
long big = 1_000_000L; // long literal ends with L
double d = 3.14; // decimal literal is double by default
boolean ok = true; // boolean literal
char c = 'A'; // single character, single quotes
var name = "Wasi"; // type inferred as String (only for local
variables)
Notes on var: - var can be used only for local variables (inside methods),
not for fields (class-level variables) or method return types. - The compiler
determines the variable’s type from the right-hand side.
4. Operators
Arithmetic operators
+ addition
- subtraction
* multiplication
/ division
% remainder (modulus)
Important detail — integer vs floating point division: - 5 / 2 using ints
→ 2 (fractional part dropped) - 5.0 / 2 using double → 2.5
Example:
int a = 7;
int b = 3;
[Link](a + b); // 10
[Link](a - b); // 4
[Link](a * b); // 21
[Link](a / b); // 2 (integer division)
[Link](a % b); // 1 (remainder)
Comparison operators (produce a boolean)
== equal
!= not equal
<, >, <=, >=
Example:
int x = 5;
[Link](x == 5); // true
[Link](x != 3); // true
[Link](x < 10); // true
Logical operators
&& logical AND (both true → true)
|| logical OR (either true → true)
! logical NOT (negates the boolean)
Truth table (ASCII):
A B A && B A || B
true true true true
true false false true
false true false true
false false false false
Example:
boolean A = true;
boolean B = false;
[Link](A && B); // false
[Link](A || B); // true
[Link](!A); // false
String concatenation with +
When + is used with at least one String, Java concatenates (joins) them.
String name = "Wasi";
int i = 10;
[Link](name + " -> i=" + i); // Wasi -> i=10
Order matters: Java evaluates left to right. If the left side is a String,
everything after will be appended as text.
5. if statements (simple control flow)
void main() {
int x = 5;
if (x > 0) [Link]("positive");
else if (x < 0) [Link]("negative");
else [Link]("zero");
}
Step-by-step: 1. Evaluate x > 0 — if true, run the first block and skip the
rest. 2. If false, evaluate x < 0 — if true run that block. 3. If neither condition
is true, run the else block.
6. Multiple examples (short, focused)
Example A — read two numbers and print their sum (with parsing)
void main() {
[Link]("First number:");
String s1 = [Link]();
[Link]("Second number:");
String s2 = [Link]();
// Convert to int (could throw NumberFormatException)
try {
int n1 = [Link](s1);
int n2 = [Link](s2);
[Link]("Sum = " + (n1 + n2));
} catch (NumberFormatException e) {
[Link]("Please enter valid integers.");
}
}
Example B — using booleans and logical operators
void main() {
[Link]("Are you a student? (true/false)");
boolean isStudent = [Link]([Link]());
[Link]("Do you like coding? (true/false)");
boolean likesCoding = [Link]([Link]());
if (isStudent && likesCoding) {
[Link]("Great! Keep learning.");
} else if (isStudent && !likesCoding) {
[Link]("Try a small project — you might enjoy it.");
} else {
[Link]("Coding is for everyone — try a short tutorial!");
}
}
Example C — char and String differences
void main() {
char letter = 'A'; // single character
String name = "Alice"; // sequence of characters
[Link](letter); // prints: A
[Link](name); // prints: Alice
// Note: single quotes vs double quotes
}
7. Code examples section (detailed, with
inline comments)
7.1 Read integer safely with loop (robust input)
void main() {
int value = 0;
boolean ok = false;
// Keep asking until user enters a valid integer
while (!ok) {
[Link]("Please enter an integer:");
String s = [Link](); // user types something and hits Enter
try {
value = [Link](s); // try converting to int
ok = true; // success — break the loop next iteration
} catch (NumberFormatException e) {
// Conversion failed — inform the user and continue the
loop
[Link]("Invalid input. Digits only, e.g. 42.");
}
}
[Link]("Thanks! You entered: " + value);
}
How and why this works: - while (!ok) will repeat until ok becomes true.
- [Link](s) throws an exception if s is not a valid integer string. -
The catch block prevents the program from crashing and gives the user
another chance.
7.2 Demonstrate integer division vs double division
void main() {
int a = 5;
int b = 2;
[Link]("int division 5 / 2 = " + (a / b)); // 2 (fraction
dropped)
double x = 5;
double y = 2;
[Link]("double division 5.0 / 2.0 = " + (x / y)); // 2.5
// Mixing types promotes to double
[Link]("mixed division 5 / 2.0 = " + (a / 2.0)); // 2.5
}
7.3 Show operator precedence with parentheses
void main() {
int result1 = 2 + 3 * 4; // multiplication first -> 2 + 12 =
14
int result2 = (2 + 3) * 4; // parentheses first -> 5 * 4 = 20
[Link]("result1 = " + result1);
[Link]("result2 = " + result2);
}
8. Common pitfalls and tips
Parsing errors: When converting strings to numbers, handle
NumberFormatException.
Integer division surprises: Use decimal literals (e.g., 2.0) or cast to
double when you want fractional results.
var limitations: var can’t be used for class fields or method
signatures — only local variables with an initializer.
[Link]() returns String — always remember to convert when you
need other types.
String concatenation order: When mixing numbers and strings,
parentheses help control what is calculated first.
Summary
Use [Link]/[Link]/[Link]() (or [Link] / Scanner in
standard Java) to interact with users.
[Link]() always returns String; convert to other types with
[Link](...), [Link](...), etc.
Java has primitive types (fast, simple) and reference types (objects,
arrays, Strings).
Operators include arithmetic, comparison, logical, and the + operator
for string concatenation.
Always validate user input and be aware of integer vs floating-point
arithmetic.
Key takeaways
[Link]() → String. To get numbers or booleans, parse that string.
Wrap parse calls in try/catch or validate input first.
Use var for local type inference but know its limits.
Remember operator precedence and difference between int and
double arithmetic.
If you want, I can also: - Convert these examples to use Scanner and
[Link] (standard Java), - Add short exercises and solutions, or -
Turn this into a printable cheat-sheet.
Which would you like next?