WEEK 1 CP213

OOP idea

Program is a set of objects that act & interact like real-world things.

Object Contains

Data (fields) + methods (actions).

Class

Blueprint for objects, objects share the same methods, can have different data values.

Main program

Class with a main() method (entry point) = public static void main(String[] args).

Benefits of OOP

Readable, Maintainable, Reusable, Team-friendly - divide work by class; Fewer errors.

Encapsulation

Bundles data + methods into a class; use private for data (inside the class access only - hidden), public for access → protects integrity & modification.

Inheritance

One class (subclass/child) can reuse and extend another (superclass/parent). Subclass inherits fields + methods from the superclass automatically; can also add new features or override existing methods.

Polymorphism

Same method or object behaves differently depending on its type. Achieved through method overriding — subclass changes how a superclass method works.

Abstraction

Show essential features (what obj does not how), hides details; use abstract classes/interfaces → simpler, modular design.

Objects

Share structure/methods, but have their own data.

Java Origin

Created by James Gosling & team, 1991, Sun Microsystems → Oracle.

Java Goal

Run programs on different processors.

Java Bytecode

Intermediate form compiled from programs; runs on the Java Virtual Machine (JVM) → portable across all systems.

Java Applets

Small programs for browsers or applet viewer; graphical interface.

System.out

An object that sends output to the screen.

println()

A method that prints text to the screen.

Method call syntax

object.methodName(arguments); where object = who performs the action, methodName = what action to perform, arguments = info sent to the method (optional).

Variable Declaration Syntax

type variableName;

Assignment

Assigns a value to a variable using =; for example, ans = 2 + 2; // ans now holds 4.

+ Operator (Numbers)

Performs addition → 3 + 5 → 8.

+ Operator (Strings)

Performs concatenation → 'Hi' + ' there' → 'Hi there'.

High-level language

Human-readable (like Java). Must be translated to run.

Low-level language / Machine code

Directly understood by the computer.

Compiler

Converts high-level → low-level. This process = compiling.

Java's Execution Model

Java compiles to bytecode (universal for JVM).

Interpreter

Executes bytecode line by line.

JIT (Just-In-Time Compiler)

Converts frequently-used bytecode into machine code while running, improving speed.

Source code

Written by you (input to compiler).

Object code

Compiled version (bytecode in Java).

JVM

Runs bytecode.

Class Loader

Loads bytecode of needed classes (like a linker in other languages).

Compiling

javac FirstProgram.java creates FirstProgram.class (bytecode file).

Running

java FirstProgram. Don't include .java or .class, only run the class with a main() method.

Syntax

Structure / grammar (rules).

Semantics

Meaning / logic of code.

Syntax error

Example: Missing ;.

Semantic error

Example: 5 / 0 (invalid operation).

Syntax error (Type)

Detected at compile-time, e.g., Missing ;, misspelled keyword.

Run-time error (Type)

Detected during execution, e.g., Division by 0.

Logic error (Type)

Detected after execution, e.g., Wrong output, bad formula.

Identifiers

Names for variables, methods, classes, etc.

Naming Convention for Variable / Method

Start lowercase, use camelCase, e.g., firstName, totalScore.

Naming Convention for Class

Start Uppercase, e.g., StudentRecord.

Naming Convention for Constant

ALL_CAPS, underscores, e.g., MAX_USERS.

Variables

Must declare before use; tells the compiler the data type.

Assignment Statements

Purpose: Assign/change variable values. Structure: variable = expression;.

Chained assignments

a = b = c = 10.

Uninitialized variables

May cause errors if used. Best practice: Initialize explicitly, e.g., int num = 0.

Shorthand Assignment

Combines arithmetic with = for concise updates.

Form

variable Op= expression; → variable = variable Op expression

Assignment Compatibility

Type mismatch: Value of one type usually cannot be stored in a variable of another type.

Widening

Allowed: Smaller → larger type automatically.

Hierarchy

byte → short → int → long → float → double

Narrowing

Requires explicit cast.

Boolean

Cannot mix with numeric types.

Arithmetic Operators

Operators: + (add), - (subtract), * (multiply), / (divide), % (modulo).

Type rules

int + int → int

Mixed types

Result is widest type.

Brackets

Parentheses clarify order; recommended to avoid ambiguity.

Operator precedence

Determines evaluation order when no parentheses.

Associativity

Resolves operations of equal precedence.

Floating-point numbers

Are approximate.

Division

If any operand is floating-point → result is floating-point.

Modulo %

Remainder.

Type conversion

Widening (int → double) automatic.

Increment/Decrement

++ adds 1, -- subtracts 1.

String

No primitive type; handled by String class.

String object

Sequence of characters in double quotes ("Hello").

Concatenation

+ joins strings; combining with other types converts them to string.

String Methods

Actions objects can perform; shared by all objects of the same class.

.length()

Returns string length.

.toUpperCase()

Converts to uppercase.

.charAt(index)

Returns character at index.

Escape Sequences

Special characters in strings.

Strings are immutable

Char inside string obj cannot be changed.

Named Constants

Fixed value that can't change.

Primitive Constants

Types include Integer, Floating-point, Character, String, Boolean.

Comments

Single-line: // comment, Multi-line: /* ... */, Documentation (Javadoc): /** ... */