Unit 1: Java fundamentals
Programming in Java notes · PTU syllabus (BSIT502/BSBC502)
On this page
- Unit summary
- The object-oriented paradigm
- Java history and features
- Java vs C and C++
- The Java environment
- Structure of a simple Java program
- Tokens and statements
- Constants, variables and data types
- Operators and expressions
- Decision making and branching
- Looping statements
- Key terms
- Quick revision
- Important questions
Unit summary
Java is a platform-independent, object-oriented language used for enterprise software, Android apps and web back ends. This unit covers the object-oriented paradigm, Java's history and features, how it differs from C and C++, the Java environment, the structure of a simple program, tokens, constants, variables, data types, operators and expressions, and decision-making, branching and looping statements.
After this unit you can
- Explain the OOP paradigm and Java's features
- Compare Java with C and C++ and describe the Java environment
- Write simple Java programs using tokens, variables, data types and operators
- Use decision-making, branching and looping statements
PTU syllabus topics
- Object-oriented paradigm basics
- Java history and features
- differences from C/C++
- Java environment
- simple Java program structure
- tokens and statements
- constants/variables/data types
- operators and expressions
- decision making/branching/looping statements
- 1Write .java source
- 2javac compiles to bytecode
.class file
- 3JVM loads the class
- 4Bytecode verifier checks it
- 5JIT compiles and runs it
Write once, run anywhere
Topic 1
The object-oriented paradigm
- Object
- Entity with state (fields) and behaviour (methods)
- Class
- Blueprint from which objects are created
- Encapsulation
- Binding data and methods; hiding data with private access
- Abstraction
- Showing essential features, hiding details
- Inheritance
- A class acquiring properties of another
- Polymorphism
- One name, many forms — overloading and overriding
- Message passing
- Objects communicate by calling methods
- Benefits: reusability, modularity, easier maintenance, data security, real-world modelling.
Topic 2
Java history and features
- 1
1991
James Gosling's team at Sun Microsystems starts the Green project; language named Oak
- 2
1995
Renamed Java; released with "write once, run anywhere"
- 3
2006–07
Open-sourced as OpenJDK
- 4
2010
Oracle acquires Sun
- 5
2014
Java 8: lambdas and streams
- 6
2018 onward
Six-monthly releases; long-term support versions 11, 17, 21 and 25
- Simple
- No pointers or operator overloading
- Object-oriented
- Everything inside classes
- Platform independent
- Compiled to bytecode that runs on any JVM
- Secure
- No explicit pointers, bytecode verifier, sandbox
- Robust
- Strong typing, exception handling, garbage collection
- Multithreaded
- Built-in threads
- Distributed and dynamic
- Networking libraries; classes loaded at run time
- High performance
- Just-in-time (JIT) compilation
Topic 3
Java vs C and C++
| Feature | C | C++ | Java |
|---|---|---|---|
| Paradigm | Procedural | Procedural and OOP | Pure OOP (except primitives) |
| Platform | Compiled to machine code | Compiled to machine code | Bytecode on the JVM |
| Pointers | Yes | Yes | No explicit pointers |
| Multiple inheritance | — | Through classes | Through interfaces only |
| Operator overloading | No | Yes | No |
| Memory management | malloc and free | new and delete | Automatic garbage collection |
| Global variables, goto, structures | Yes | Yes | No |
| Header files | Yes | Yes | No — uses packages and import |
Topic 4
The Java environment
- 1Write Hello.java
- 2javac Hello.java
Compiler produces Hello.class (bytecode)
- 3java Hello
JVM loads, verifies and runs bytecode
- 4JIT compiles hot code to machine code
- JVM
- Java Virtual Machine — executes bytecode; platform specific
- JRE
- JVM plus core libraries — needed to run programs
- JDK
- JRE plus development tools — javac, java, javadoc, jar, jdb
- API: thousands of ready classes organised in packages — java.lang, java.util, java.io, java.awt, java.net.
Topic 5
Structure of a simple Java program
java// Documentation section: program to greet a student
package college; // optional package statement
import java.util.Scanner; // import statements
public class Hello { // class definition; file must be Hello.java
public static void main(String[] args) { // entry point
Scanner sc = new Scanner(System.in);
System.out.print("Enter your name: ");
String name = sc.nextLine();
System.out.println("Welcome to SBS, " + name);
}
}- main: public (accessible to the JVM), static (called without an object), void (returns nothing), String[] args (command-line arguments).
Topic 6
Tokens and statements
- Keywords
- Reserved words — class, int, if, static (about 50)
- Identifiers
- Names of classes, variables, methods; start with a letter, _ or $
- Literals
- Constant values — 25, 3.14, 'A', "SBS", true
- Operators
- Symbols performing operations
- Separators
- ( ) { } [ ] ; , .
- Statements: expression statements, declarations, control statements, labelled statements, synchronisation statements, empty statements.
Topic 7
Constants, variables and data types
Primitive integer
byte (1 byte), short (2), int (4), long (8)
Primitive floating
float (4), double (8)
Primitive others
char (2 bytes, Unicode), boolean (true or false)
Reference
Classes, interfaces, arrays, String
javafinal double PI = 3.14159; // constant
int age = 19; // variable
long population = 1_400_000_000L;
float cgpa = 8.6f;
char grade = 'A';
boolean passed = true;
double avg = (double) 245 / 3; // explicit casting
int x = 'A' + 1; // implicit widening: 66
var city = "Ludhiana"; // local type inference (Java 10+)- Variable kinds: local (inside methods), instance (per object), class or static (shared by all objects). Type conversion: widening is automatic (int → long → float → double); narrowing needs a cast.
Topic 8
Operators and expressions
- Arithmetic
- + − × / % (multiplication is written with the asterisk symbol)
- Relational
- < <= > >= == !=
- Logical
- &&, the double-bar OR operator, !
- Bitwise and shift
- &, ^, ~, <<, >>, >>>
- Assignment
- = += −= and so on
- Increment and decrement
- ++ and −−
- Conditional
- condition ? value1 : value2
- instanceof
- Checks an object's type
- Precedence: unary > multiplicative > additive > shift > relational > equality > bitwise > logical > conditional > assignment. Integer division truncates (7 / 2 = 3); % gives the remainder.
Topic 9
Decision making and branching
javaint marks = 72;
if (marks >= 75) System.out.println("Distinction");
else if (marks >= 60) System.out.println("First division");
else System.out.println("Pass");
int day = 3;
switch (day) {
case 1: System.out.println("Monday"); break;
case 3: System.out.println("Wednesday"); break;
default: System.out.println("Other day");
}
String type = switch (day) { // switch expression (Java 14+)
case 6, 7 -> "Weekend";
default -> "Weekday";
};Topic 10
Looping statements
javafor (int i = 1; i <= 10; i++) System.out.print(i * i + " "); // squares
int n = 12345, sum = 0;
while (n > 0) { sum += n % 10; n /= 10; } // digit sum = 15
int k = 1;
do { System.out.println(k); k++; } while (k <= 3); // runs at least once
int[] marks = {78, 85, 90};
for (int m : marks) System.out.println(m); // enhanced for
outer:
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++) {
if (i * j == 4) break outer; // labelled break
if (j == 2) continue;
System.out.println(i + "," + j);
}Key terms
- Bytecode
- Platform-independent code produced by javac
- JVM
- Virtual machine executing Java bytecode
- JDK
- Development kit with compiler and tools
- Token
- Smallest unit of a program
- Type casting
- Converting a value from one type to another
Quick revision
- OOP concepts; Java history (Oak, Sun, Oracle); features.
- Java vs C and C++.
- javac → bytecode → JVM; JDK, JRE, JVM.
- Program structure; main; tokens; eight primitive types; widening and narrowing.
- Operators and precedence; if, switch, for, while, do-while, enhanced for, labelled break and continue.
Important exam questions
Practice questions written to the PTU exam pattern for this unit's syllabus: short answers (Section A style) and long answers (Sections B and C style).
Short-answer questions
- Q1.Why is Java platform independent?
- Q2.Distinguish JDK, JRE and JVM.
- Q3.Why is main declared static?
- Q4.Name the eight primitive data types of Java.
- Q5.Distinguish while and do-while.
- Q6.What is a labelled break?
Long-answer questions
- Q1.Explain the features of Java.
- Q2.Compare Java with C and C++.
- Q3.Explain the structure of a Java program and the Java environment.
- Q4.Explain the decision-making and looping statements of Java with examples.
Stuck on this unit?
Message SBS on WhatsApp for help with Programming in Java, or to ask about studying B.Sc IT at Synetic.
