Java Programming and Computing Fundamentals — Comprehensive Study Notes
Introduction to Computing and Programming
Computers enable a wide range of tasks beyond single-purpose machines; they run different programs to perform diverse tasks.
A computer stores data (numbers, words, pictures), interacts with peripheral devices (monitor, sound system, printer), and executes programs.
A computer program is a sequence of instructions that directs the computer to perform a task.
Hardware vs Software:
Hardware: the physical equipment of a computer.
Software: the intangible instructions and data that operate the computer.
The act of designing and implementing computer programs is called programming.
Simple machine examples show narrow task ranges (car, toaster) vs computers’ flexibility due to programs.
Basic terms:
Definition of computer program: A sequence of instructions that is executed by a computer.
Definition of hardware: The physical equipment for a computer or another device.
Definition of software: The intangible instructions and data that are necessary for operating a computer or another device.
Hardware, Software, and the Building Blocks of a Computer
The central processing unit (CPU) is the heart of the computer.
The inside wiring of the CPU is extremely complex; e.g., a modern popular CPU contains hundreds of millions of transistors.
Definition: Central Processing Unit (CPU) – The part of a computer that executes the machine instructions.
The CPU performs program control and data processing: locating and executing instructions, carrying out arithmetic operations, and fetching data from memory or devices to store processed data.
Storage comes in two kinds:
Primary storage (memory): electronic circuits that store data as long as power is supplied.
Secondary storage: slower, cheaper storage that persists without power (e.g., hard disks, solid-state drives).
Definitions:
Definition of primary storage (memory): memory that loses data when power is removed.
Definition of secondary storage: Storage that persists without electricity, e.g., a hard disk.
Hard disk vs SSD:
Hard disk: rotating platters coated with magnetic material.
Solid-state drive (SSD): uses electronic components with no moving parts, retains information without power.
Peripherals, Networks, and Data Flow
Peripheral devices provide input and output for humans:
Output: display screen, speakers, printers.
Input: keyboard, mouse, touch sensor, microphone.
Some computers are self-contained; others are networked.
In a networked computer, data and programs can reside on central storage or be transmitted over a network; it may be hard to tell which data are local vs networked.
A schematic view of a PC architecture includes: program instructions and data reside in secondary storage or network locations; the CPU fetches and executes one instruction at a time; data are read, modified, and written back to memory or storage.
Historical Context and Ubiquitous Computing
Early computers (e.g., ENIAC, 1946) filled an entire room and were used for military trajectory computations.
Today, computing facilities (data centers) power search engines, online shops, and social networks.
Ubiquitous computing: computers are embedded in phones, credit cards, transit cards, cars, and many devices, transforming work and daily life.
As computers become more embedded, understanding how they work and how to program them becomes essential for many careers (engineers, scientists, activists, etc.).
High-Level Programming Languages and Compilers
High-level languages allow programmers to describe tasks abstractly rather than detailing CPU instructions.
A compiler translates high-level language instructions into machine code that the CPU can execute.
Definitions:
Definition of high-level programming language: A programming language that provides an abstract view of a computer and allows programmers to focus on their problem domain.
Definition of compiler: A program that translates code in a high-level language (such as Java) to machine instructions (such as bytecode for the Java virtual machine).
Definition of machine code: Instructions that can be executed directly by the CPU.
Java: History, Design Goals, and Applets
In 1991, James Gosling and Patrick Naughton at Sun Microsystems led a group to design a language for consumer devices; code-named “Green.”
In 1994–1995, the team pivoted to create a browser-based environment; Java introduced to the world with applets running in a browser.
Definition: Applet – A graphical Java program that executes inside a web browser or applet viewer.
Java gained popularity because it is easier than C++ and has a rich library that enables portable programs across platforms.
Editions of the Java library include a micro edition (for small devices) and an enterprise edition (for servers).
Java’s two key attributes for beginners:
Safety: programs terminate if attempting unsafe actions, providing reliable error reports.
Portability: same Java program runs on Windows, UNIX, Linux, or Macintosh.
Portability mechanism:
Java programs are compiled to bytecode for the Java Virtual Machine (JVM), not directly to CPU instructions.
Definition: Virtual machine – A program that simulates a CPU and enables efficient implementation across diverse hardware.
The Java library approach enables platform independence because Java bytecode can be executed by any JVM.
Getting Started with Java in this Book
Java has a large library; focus on the parts needed for your projects.
Becoming familiar with your programming environment is essential because environments vary widely.
The book provides guidance to set up, write, and run Java programs, including typical environments like Integrated Development Environments (IDEs).
Step-by-step outline typical in learning Java:
Step 1: Start the Java development environment (IDE with editor, compiler, debugger) or use an editor plus console.
Step 2: Write a simple program; tradition uses Hello, World! example. Example program structure:
Code snippet (as given in the transcript):
public class HelloPrinter { public static void main(String[] args) { System.out.println("Hello, World!"); } }
Important: Java is case sensitive; enter identifiers with exact case.
Step 3: Run the program; in IDEs, compilation and execution are often automatic; otherwise you run the compiler and the JVM explicitly.
Step 4: Organize your work into folders/directories; create a separate folder for coursework and a subfolder for each program.
Key terminology:
Integrated development environment (IDE): A programming environment that includes an editor, compiler, and debugger.
Editor: A program for writing and modifying text files (code).
Source file: A file containing instructions in a programming language (e.g., HelloPrinter.java).
Source code: Instructions in a language that need translation before execution.
Case sensitivity: Java distinguishes upper and lower case in identifiers.
Anatomy of a Java Program: HelloPrinter
A Java program typically consists of one or more classes.
The example demonstrates a class named HelloPrinter defined as public.
The public keyword means the class is usable by the public; later contexts will discuss private access.
Java source file naming convention: the public class name must match the file name. Example: HelloPrinter.java.
The main method declaration: public static void main(String[] args) { … }
A method is a sequence of statements with a name, optional parameters, and a return type.
Every Java application must have a main method; many programs include other methods as well.
Java Statements, Strings, and Printing
A Java program’s main method contains statements that are executed in order.
Each statement ends with a semicolon; this is essential because the compiler uses semicolons to delimit statements, not line breaks.
Examples:
System.out.println("Hello, World!"); prints a string and ends with a newline.
System.out.print("00"); System.out.println(3 + 4); prints 007 on a single line.
Strings:
A sequence of characters enclosed in quotation marks. Example: "Hello, World!".
The compiler treats quotes as string literals, not as code.
Expressions: System.out.println(3 + 4); prints the result of the expression, here 7.
The println method prints a value (string or number) and starts a new line; print does not start a new line.
A key example shows multiple println calls printing on separate lines.
Common Java Syntax and Errors
A single semicolon ends each statement; missing semicolons are a common error.
Some issues to be aware of:
System.out.println("Hello") System.out.println("World!"); is invalid because there is no delimiter between statements.
Typing errors like System.ou.println(…) will trigger a compile-time or symbol-not-found error (e.g., Cannot find symbol ou).
Compile-time errors (syntax errors) are detected by the compiler and prevent translation to the JVM until fixed.
Run-time errors occur when a program is syntactically correct but behaves incorrectly or raises an exception (e.g., Division by zero).
Exceptions are a special runtime condition signal used by the JVM.
If the wrong main method name is used (e.g., Main with uppercase M), the JVM will report missing main method at run time, highlighting case-sensitivity issues.
Debugging tips:
The compiler reports many errors in one go, allowing you to fix multiple issues at once.
Case sensitivity and spelling mistakes are common causes of errors; read error messages carefully to identify the root cause.
Algorithmic Thinking and Pseudocode
An algorithm is a recipe for solving a problem that must be:
Unambiguous: precise instructions with no guesswork.
Executable: can be performed in practice.
Terminating: must eventually end.
Pseudocode is a high-level description of an algorithm using informal language and simple programming constructs.
Example: Algorithm to determine how long it takes money to double with a fixed interest rate.
Pseudocode conventions used in this book:
Use assignments like totalcost = purchaseprice + operating_cost.
Use constructs for decisions and loops: If, While, For, etc.
Use indentation to indicate blocks of statements.
Indicate results with explicit output statements like Choose car1. Report year as the answer.
Worked Algorithm Examples
Investment problem (doubling money):
Problem: You put $10,000 in a bank account earning 5% per year. How many years until the balance doubles?
Pseudocode steps:
Set year = 0, balance = 10000.
While balance < 20000:
year = year + 1
balance = balance + balance × 0.05
Report year as the answer.
This demonstrates a terminating, executable loop that computes the solution.
Note: This uses a fixed rate to ensure executability; real rates may vary.
Pseudocode to tile a floor in an alternating color pattern (black and white tiles 4x4 inches):
Problem statement: Tile a floor with alternating 4x4 inch tiles; floor dimensions are multiples of 4 inches.
Steps:
Step 1: Determine inputs and outputs (length × width in inches; output is a tiled floor).
Step 2: Break down into subtasks (lay one row, then repeat for subsequent rows).
Step 3: Describe subtasks in pseudocode, including the placement rules and color alternation.
Step 4: Test with a sample (e.g., 20 × 12 inches) to ensure the pattern fills the space correctly.
The example demonstrates how to describe repeating tiling tasks algorithmically.
From Algorithms to Programs and the Software Development Process
Before writing a program, you must develop an algorithm described in pseudocode.
The existence of an algorithm is an essential prerequisite for programming.
The Software Development Process (conceptual figure in the book) outlines steps from problem understanding to algorithm design to implementation.
Example problem used in the book:
Problem: Choose between two cars based on purchase price, fuel efficiency, and fixed gas price over ten years.
Inputs: purchaseprice1, fuelefficiency1; purchaseprice2, fuelefficiency2; constants: gasprice, milesper_year, years.
Step 1: Determine inputs and outputs (the outputs are which car is the better deal).
Step 2: Break down into subtasks (compute annual fuel consumed, annual fuel cost, operating cost, total cost for each car).
Step 3: Describe subtasks in pseudocode using formulas:
annualfuelconsumed = annualmilesdriven / fuel_efficiency
annualfuelcost = pricepergallon × annualfuelconsumed
operatingcost = 10 × annualfuel_cost
totalcost = purchaseprice + operating_cost
Step 4: Test with sample values (Car 1: 25000, 50 mpg; Car 2: 20000, 30 mpg; gas price = 4).
Conclusion: The algorithm determines which car is cheaper over the 10-year horizon.
Java in Practice: Environment, Syntax, and Common Pitfalls
Step 1: Start the Java development environment.
IDEs often combine an editor, compiler, and debugger.
If not using an IDE, you may use a text editor and a separate console to run commands.
Definitions:
Integrated development environment: A programming environment that includes an editor, compiler, and debugger.
Editor: A program for writing and modifying text files.
Step 2: Write a simple program. The traditional first program is Hello, World! in Java.
Example: public class HelloPrinter { public static void main(String[] args) { System.out.println("Hello, World!"); } }
Important: Java is case sensitive; enter identifiers exactly as shown.
File naming: The public class must match the file name (HelloPrinter.java).
Step 3: Run the program.
The Java compiler translates source files to class files; the JVM executes the class files.
The runtime may require you to load libraries such as System and PrintStream when printing output.
Some environments hide the compiler/JVM; others require explicit invocation.
Step 4: Organize your work.
Use folders/directories to organize programs; create a folder for coursework and a subfolder per program.
Definitions:
File: A sequence of bytes stored on disk.
Folder/Directory: A structure on disk that holds files or other folders.
Backups and file management:
Always back up work; methods include memory sticks and online storage.
Back up often (e.g., every 30 minutes).
Rotate backups across multiple directories to guard against data loss.
Check backups periodically and keep calm during restore.
Be mindful of backup direction to avoid overwriting newer files with older versions.
Java Language Fundamentals: Classes, Methods, and the Print API
The HelloPrinter class demonstrates core Java concepts:
public class HelloPrinter – defines a class named HelloPrinter.
A Java program consists of one or more classes. Each public Java file typically contains exactly one public class whose name matches the file.
The public keyword indicates the class is accessible publicly; other access modifiers like private will be discussed later.
The main method signature: public static void main(String[] args) { … }
A method is a named sequence of statements; main is the entry point of a Java application.
The public static void main(String[] args) method is the standard entry point for Java applications.
Statement: A single instruction ending with a semicolon.
System.out.println: A call to a method in the Java library that prints a value and starts a new line.
Arguments: Values passed to a method; enclosed in parentheses and separated by commas.
A string is a sequence of characters enclosed in quotation marks.
Printing numbers is also possible via System.out.println(
3 + 4
); which evaluates the expression and prints the result.
Printing mechanisms:
System.out.println prints value then a newline.
System.out.print prints without adding a newline.
Statements and blocks:
Each Java statement ends with a semicolon.
Curly braces { … } denote blocks; the main method’s body is a block containing statements.
Common errors and debugging:
Misspelling a symbol (e.g., ou instead of out) leads to errors like Cannot find symbol ou.
Missing main method or incorrect case in Main vs main leads to runtime errors.
Compile-time errors are syntax-related and detected by the compiler; run-time errors occur when the program executes in an unintended way and may throw exceptions.
The Java Runtime Stack: Compilation, Bytecode, and Execution
Steps to run a Java program:
Write source file (e.g., HelloPrinter.java).
Compile: javac HelloPrinter.java – produces HelloPrinter.class.
Run: java HelloPrinter – runs the Java Virtual Machine (JVM) which executes the class file.
The JVM uses a library (e.g., java.lang.System and PrintStream) to implement printing and other functionality.
Key concepts:
Source file: A file containing instructions in a programming language such as Java.
Source code: Instructions in a language that need to be translated before execution on a computer.
Class file: Bytecode that the JVM can load and interpret.
Bytecode is executed by the JVM rather than directly by the CPU, enabling cross-platform portability.
Principles of Software Organization and File Management
Files and folders form a hierarchical structure (directory tree).
Best practices for organizing projects:
Create a dedicated project folder.
Create a separate subfolder for each program.
Important terms:
File: A sequence of bytes stored on disk.
Folder/Directory: A structure that can hold files or other directories.
The location of files matters for submission, backup, and maintenance.
Error Types, Troubleshooting, and Debugging Tips
Compile-time error: Detected by the compiler; prevents translation to class files.
Syntax error: A specific kind of compile-time error where language rules are violated.
Run-time error: Detected while the program runs; can produce exceptions or incorrect results.
Exceptions: Objects signaling an abnormal condition; e.g., division by zero may generate an exception.
Typical run-time error scenarios include incorrect logic producing wrong outputs even though syntax is correct.
Practical debugging tips:
When unsure, check error messages; they often indicate the exact symbol or line causing trouble.
Verify capitalization and spelling of identifiers (Java is case sensitive).
Algorithms, Pseudocode, and Problem Solving
An algorithm is a precise, unambiguous, executable, and terminating sequence of steps to solve a problem.
Pseudocode is a human-readable description of an algorithm blending natural language with simple programming constructs.
Guidelines for pseudocode in this book:
Use assignment-style statements to set or change values (e.g., totalcost = purchaseprice + operating_cost).
Describe decisions and repetitions with If, While, For.
Use indentation to indicate blocks and sequencing.
Indicate results with explicit output statements.
Example problems illustrate how to convert natural-language problems into algorithms:
Investment doubling problem demonstrates loop-based accumulation until a condition is met.
Tiling a floor problem demonstrates a row-based approach and color alternation logic.
Worked Examples: From Algorithms to Programs
Investment problem worked example (summary):
Input: initial balance, interest rate, target balance (e.g., 2x).
Pseudocode uses a loop to increment year and apply interest until balance reaches target.
Tiling a floor worked example (summary):
Input: floor dimensions; output: tiled floor.
Approach: tile a row with alternating black/white tiles; replicate rows until floor filled; include logic for vertical tiling if space remains.
Car cost comparison worked example (summary):
Inputs for two cars: purchase price, MPG; constants: gas price, miles per year, years.
Calculate annual fuel consumption, annual fuel cost, operating cost, and total cost for each car.
Compare total costs to decide which car is better buy.
Standard Library Items Introduced in This Chapter
java.io.PrintStream
print
println
java.lang.System
out
Practical Considerations and Best Practices
Java was designed for safety and portability, enabling browser-based execution of applets and cross-platform compatibility via the JVM.
Emphasis on using the library to avoid reinventing common functionality; focus on learning the parts needed for projects.
Familiarize yourself with your programming environment early; environment differences are common across machines.
Always consider backups and versioning as part of the development process to avoid data loss.
Quick Reference Definitions (selected)
Class: A programmer-defined data type; a building block of Java programs.
Method: A sequence of statements that can be invoked; contains a name, parameters, and possibly a return value.
Main method: The entry point of a Java application; signature public static void main(String[] args).
String: A sequence of characters.
Argument: A value supplied to a method call.
Compile-time error: A language-rule violation detected during compilation.
Run-time error: An error that occurs during program execution.
Algorithm: An unambiguous, executable, and terminating specification of a way to solve a problem.
Pseudocode: High-level description of an algorithm that is readable by humans.
Formulas Used in Examples (LaTeX)
Interest update in investment example:
Annual fuel consumption and costs in the car-cost problem:
If you want, I can expand any section with more bullet points or add more worked examples and details from the transcript.