Java Best Practices and Review#
Lecture 42#
Java Programming (4343203)
Diploma in ICT - Semester IV
Gujarat Technological University
Press Space for next page
layout: default#
Learning Objectives#
By the end of this lecture, you will be able to:
- 🎯 Review all major Java programming concepts covered in the course
- 📋 Apply Java best practices and coding standards
- 🔍 Analyze code quality and maintainability aspects
- 🚀 Integrate multiple Java concepts in comprehensive projects
- 📝 Prepare effectively for examinations and practical assessments
- 🛠️ Debug and optimize Java programs efficiently
- 🏆 Demonstrate proficiency in all course outcomes (COs)
layout: default#
Course Overview and Journey#
Units Covered#
Unit I: Java Fundamentals (8 Lectures)#
- Java introduction and environment
- Data types, variables, and operators
- Control structures and arrays
- Program structure and compilation
Unit II: Object-Oriented Programming (11 Lectures)#
- Classes, objects, and encapsulation
- Constructors and method overloading
- Access modifiers and keywords
- String handling and user input
Unit III: Inheritance & Interfaces (11 Lectures)#
- Inheritance types and implementation
- Method overriding and polymorphism
- Abstract classes and interfaces
- Packages and access control
Unit IV: Exception Handling & Multithreading (6 Lectures)#
- Exception hierarchy and handling
- Try-catch-finally and custom exceptions
- Thread creation and management
- Synchronization concepts
Unit V: File Handling & Collections (6 Lectures)#
- File I/O operations
- Collections framework
- List, Set, and Map implementations
- Utility methods and best practices
Course Statistics#
- Total Teaching Hours: 42 hours ✅
- Practical Exercises: 30+ hands-on labs
- Key Concepts: 100+ programming topics
- Real-world Projects: Multiple mini-projects
- Assessment Methods: Theory + Practical + Micro-project
layout: default#
Java Coding Best Practices#
1. Code Style and Conventions#
Naming Conventions#
// Classes: PascalCase
public class BankAccount { }
public class StudentManagementSystem { }
// Variables and methods: camelCase
private String firstName;
private int accountBalance;
public void calculateInterest() { }
// Constants: UPPER_SNAKE_CASE
public static final int MAX_RETRY_ATTEMPTS = 3;
public static final String DEFAULT_FILE_PATH = "/data/files/";
// Packages: lowercase with dots
package com.company.banking.accounts;
package edu.gtu.ict.projects;
Code Formatting#
// GOOD: Proper indentation and spacing
public class GoodExample {
private int value;
public void processData(String input, int count) {
if (input != null && count > 0) {
for (int i = 0; i < count; i++) {
System.out.println(input + " - " + i);
}
} else {
System.err.println("Invalid input parameters");
}
}
}
// BAD: Poor formatting
public class BadExample{
private int value;
public void processData(String input,int count){
if(input!=null&&count>0){
for(int i=0;i<count;i++){
System.out.println(input+" - "+i);
}
}else{
System.err.println("Invalid input parameters");
}
}
}
2. Documentation and Comments#
JavaDoc Comments#
/**
* Represents a bank account with basic operations.
*
* @author Student Name
* @version 1.0
* @since 2024
*/
public class BankAccount {
/**
* Deposits money into the account.
*
* @param amount The amount to deposit (must be positive)
* @throws IllegalArgumentException if amount is negative or zero
* @return The new account balance after deposit
*/
public double deposit(double amount) {
if (amount <= 0) {
throw new IllegalArgumentException("Amount must be positive");
}
this.balance += amount;
return this.balance;
}
}
Inline Comments#
public void calculateGrade(int marks) {
// Validate input range
if (marks < 0 || marks > 100) {
throw new IllegalArgumentException("Marks must be between 0 and 100");
}
// Calculate grade based on GTU grading system
if (marks >= 70) {
grade = 'A'; // Excellent performance
} else if (marks >= 60) {
grade = 'B'; // Good performance
} else if (marks >= 50) {
grade = 'C'; // Average performance
} else if (marks >= 35) {
grade = 'D'; // Pass
} else {
grade = 'F'; // Fail
}
}
layout: default#
Object-Oriented Design Principles#
SOLID Principles in Java#
1. Single Responsibility Principle (SRP)#
// BAD: Class doing too many things
public class BadStudent {
private String name;
private int marks;
// Student data management
public void setName(String name) { this.name = name; }
// Grade calculation - different responsibility
public char calculateGrade() { /* logic */ }
// File operations - different responsibility
public void saveToFile() { /* file I/O */ }
// Email operations - different responsibility
public void sendEmail() { /* email logic */ }
}
// GOOD: Each class has single responsibility
public class Student {
private String name;
private int marks;
// Only student data management
}
public class GradeCalculator {
public char calculateGrade(int marks) { /* logic */ }
}
public class FileManager {
public void saveStudent(Student student) { /* file I/O */ }
}
public class EmailService {
public void sendNotification(Student student) { /* email */ }
}
2. Open/Closed Principle (OCP)#
// Base class open for extension, closed for modification
public abstract class Shape {
public abstract double calculateArea();
}
// Extend without modifying base class
public class Rectangle extends Shape {
private double width, height;
public double calculateArea() {
return width * height;
}
}
public class Circle extends Shape {
private double radius;
public double calculateArea() {
return Math.PI * radius * radius;
}
}
Design Patterns#
1. Singleton Pattern#
public class DatabaseConnection {
private static DatabaseConnection instance;
private Connection connection;
// Private constructor prevents external instantiation
private DatabaseConnection() {
// Initialize database connection
}
// Thread-safe singleton implementation
public static synchronized DatabaseConnection getInstance() {
if (instance == null) {
instance = new DatabaseConnection();
}
return instance;
}
public Connection getConnection() {
return connection;
}
}
// Usage
DatabaseConnection db = DatabaseConnection.getInstance();
2. Factory Pattern#
public abstract class Animal {
public abstract void makeSound();
}
public class Dog extends Animal {
public void makeSound() { System.out.println("Woof!"); }
}
public class Cat extends Animal {
public void makeSound() { System.out.println("Meow!"); }
}
public class AnimalFactory {
public static Animal createAnimal(String type) {
switch (type.toLowerCase()) {
case "dog": return new Dog();
case "cat": return new Cat();
default: throw new IllegalArgumentException("Unknown animal type");
}
}
}
// Usage
Animal dog = AnimalFactory.createAnimal("dog");
dog.makeSound(); // Output: Woof!
3. Observer Pattern#
import java.util.*;
public class Subject {
private List<Observer> observers = new ArrayList<>();
private String state;
public void addObserver(Observer observer) {
observers.add(observer);
}
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(state);
}
}
public void setState(String state) {
this.state = state;
notifyObservers();
}
}
public interface Observer {
void update(String state);
}
layout: default#
Error Handling and Debugging Best Practices#
Exception Handling Excellence#
1. Specific Exception Handling#
public class FileProcessor {
public void processFile(String filename) {
try {
FileReader reader = new FileReader(filename);
BufferedReader buffer = new BufferedReader(reader);
String line;
while ((line = buffer.readLine()) != null) {
processLine(line);
}
} catch (FileNotFoundException e) {
// Handle missing file specifically
System.err.println("File not found: " + filename);
createDefaultFile(filename);
} catch (IOException e) {
// Handle I/O errors
System.err.println("Error reading file: " + e.getMessage());
logError("File I/O Error", e);
} catch (SecurityException e) {
// Handle permission issues
System.err.println("Access denied: " + filename);
requestPermissions();
} finally {
// Always clean up resources
cleanupResources();
}
}
}
2. Custom Exception Design#
// Well-designed custom exception hierarchy
public class BankingException extends Exception {
public BankingException(String message) {
super(message);
}
public BankingException(String message, Throwable cause) {
super(message, cause);
}
}
public class InsufficientFundsException extends BankingException {
private double requestedAmount;
private double availableBalance;
public InsufficientFundsException(double requested, double available) {
super(String.format("Insufficient funds. Requested: %.2f, Available: %.2f",
requested, available));
this.requestedAmount = requested;
this.availableBalance = available;
}
// Getters for detailed error handling
public double getRequestedAmount() { return requestedAmount; }
public double getAvailableBalance() { return availableBalance; }
}
Debugging Techniques#
1. Effective Logging#
import java.util.logging.Logger;
import java.util.logging.Level;
public class ServiceManager {
private static final Logger logger = Logger.getLogger(ServiceManager.class.getName());
public void processRequest(String requestId, Object data) {
// Log entry point with context
logger.info("Processing request: " + requestId + " with data type: " +
data.getClass().getSimpleName());
try {
// Log key decision points
if (data == null) {
logger.warning("Null data received for request: " + requestId);
return;
}
// Process data
String result = performComplexOperation(data);
// Log successful completion
logger.info("Request " + requestId + " completed successfully. Result length: " +
result.length());
} catch (Exception e) {
// Log errors with full context
logger.log(Level.SEVERE,
"Failed to process request: " + requestId + " - " + e.getMessage(), e);
throw e; // Re-throw if needed
}
}
}
2. Defensive Programming#
public class SafeCalculator {
public double divide(double dividend, double divisor) {
// Input validation
if (Double.isNaN(dividend) || Double.isInfinite(dividend)) {
throw new IllegalArgumentException("Invalid dividend: " + dividend);
}
if (Double.isNaN(divisor) || Double.isInfinite(divisor)) {
throw new IllegalArgumentException("Invalid divisor: " + divisor);
}
if (divisor == 0.0) {
throw new ArithmeticException("Division by zero");
}
// Additional safety check
if (Math.abs(divisor) < 1e-10) {
throw new ArithmeticException("Divisor too close to zero: " + divisor);
}
return dividend / divisor;
}
public int[] safeArrayAccess(int[] array, int index) {
// Null check
Objects.requireNonNull(array, "Array cannot be null");
// Bounds check
if (index < 0 || index >= array.length) {
throw new IndexOutOfBoundsException(
String.format("Index %d out of bounds for array length %d",
index, array.length));
}
return array;
}
}
layout: default#
Performance Optimization#
Memory Management#
1. String Optimization#
public class StringOptimization {
// BAD: Creating many temporary String objects
public String concatenateBad(String[] words) {
String result = "";
for (String word : words) {
result += word + " "; // Creates new String each time
}
return result.trim();
}
// GOOD: Using StringBuilder for multiple concatenations
public String concatenateGood(String[] words) {
StringBuilder sb = new StringBuilder();
for (String word : words) {
sb.append(word).append(" ");
}
return sb.toString().trim();
}
// BETTER: Pre-sizing StringBuilder
public String concatenateBetter(String[] words) {
// Estimate capacity to avoid internal array resizing
int estimatedLength = words.length * 10; // Estimate average word length
StringBuilder sb = new StringBuilder(estimatedLength);
for (String word : words) {
sb.append(word).append(" ");
}
return sb.toString().trim();
}
}
2. Collection Optimization#
public class CollectionOptimization {
// Choose right collection for the job
public void demonstrateCollectionChoice() {
// Use ArrayList for indexed access
List<String> indexedList = new ArrayList<>();
String item = indexedList.get(100); // O(1) for ArrayList
// Use LinkedList for frequent insertions/deletions
List<String> linkedList = new LinkedList<>();
linkedList.add(0, "first"); // O(1) for LinkedList, O(n) for ArrayList
// Use HashSet for fast lookups
Set<String> fastLookup = new HashSet<>();
boolean contains = fastLookup.contains("item"); // O(1) average
// Use TreeSet for sorted unique elements
Set<String> sortedSet = new TreeSet<>(); // Maintains sorted order
// Use HashMap for key-value mapping
Map<String, Integer> keyValue = new HashMap<>();
Integer value = keyValue.get("key"); // O(1) average
}
// Pre-size collections when size is known
public List<Integer> processLargeDataset(int expectedSize) {
// Avoid multiple resizing operations
List<Integer> results = new ArrayList<>(expectedSize);
for (int i = 0; i < expectedSize; i++) {
results.add(processItem(i));
}
return results;
}
}
Algorithm Optimization#
1. Loop Optimization#
public class LoopOptimization {
// BAD: Inefficient loop with method call in condition
public void inefficientLoop(List<String> items) {
for (int i = 0; i < items.size(); i++) { // size() called every iteration
processItem(items.get(i));
}
}
// GOOD: Cache size calculation
public void efficientLoop(List<String> items) {
int size = items.size(); // Calculate once
for (int i = 0; i < size; i++) {
processItem(items.get(i));
}
}
// BETTER: Use enhanced for loop when index not needed
public void bestLoop(List<String> items) {
for (String item : items) { // Most readable and efficient
processItem(item);
}
}
// Search optimization example
public boolean findItemOptimized(int[] sortedArray, int target) {
// Use binary search for sorted arrays - O(log n) vs O(n)
return Arrays.binarySearch(sortedArray, target) >= 0;
}
}
2. Caching and Memoization#
public class FibonacciCalculator {
// Naive recursive approach - very slow for large n
public long fibonacciNaive(int n) {
if (n <= 1) return n;
return fibonacciNaive(n - 1) + fibonacciNaive(n - 2); // O(2^n)
}
// Memoization - cache results to avoid recalculation
private Map<Integer, Long> fibCache = new HashMap<>();
public long fibonacciMemoized(int n) {
if (n <= 1) return n;
// Check cache first
if (fibCache.containsKey(n)) {
return fibCache.get(n);
}
// Calculate and cache result
long result = fibonacciMemoized(n - 1) + fibonacciMemoized(n - 2);
fibCache.put(n, result);
return result; // O(n) time, O(n) space
}
// Iterative approach - best performance
public long fibonacciIterative(int n) {
if (n <= 1) return n;
long prev = 0, curr = 1;
for (int i = 2; i <= n; i++) {
long next = prev + curr;
prev = curr;
curr = next;
}
return curr; // O(n) time, O(1) space
}
}
layout: default#
Code Review and Quality Assurance#
Code Review Checklist#
1. Functionality#
// Example of thorough method implementation
public class BankAccount {
private double balance;
private String accountNumber;
/**
* Withdraws money from account with proper validation
*/
public void withdraw(double amount) throws InsufficientFundsException {
// 1. Input validation
if (amount <= 0) {
throw new IllegalArgumentException("Withdrawal amount must be positive");
}
// 2. Business rule validation
if (amount > balance) {
throw new InsufficientFundsException(
"Insufficient funds: " + balance + " available, " + amount + " requested");
}
// 3. Additional business rules
if (amount > 10000) { // Daily limit example
throw new IllegalArgumentException("Daily withdrawal limit exceeded");
}
// 4. Perform operation
balance -= amount;
// 5. Log transaction
logTransaction("WITHDRAWAL", amount);
// 6. Send notification (if configured)
notifyAccountHolder("Withdrawal of $" + amount + " completed");
}
}
2. Error Handling#
public class FileProcessor {
public void processConfiguration(String configPath) {
InputStream inputStream = null;
Properties config = new Properties();
try {
// Try multiple locations for config file
inputStream = tryGetConfigStream(configPath);
if (inputStream == null) {
inputStream = getDefaultConfigStream();
}
config.load(inputStream);
// Validate required properties
validateConfiguration(config);
} catch (IOException e) {
logger.error("Failed to load configuration from: " + configPath, e);
// Fallback to default configuration
loadDefaultConfiguration();
} catch (SecurityException e) {
logger.error("Access denied to configuration file: " + configPath, e);
throw new ConfigurationException("Cannot access configuration", e);
} finally {
// Always clean up resources
if (inputStream != null) {
try {
inputStream.close();
} catch (IOException e) {
logger.warn("Failed to close configuration stream", e);
}
}
}
}
}
3. Performance and Security#
public class SecureUserManager {
// Password security best practices
public boolean validatePassword(String username, char[] password) {
try {
// 1. Input validation
if (username == null || username.trim().isEmpty()) {
return false;
}
if (password == null || password.length == 0) {
return false;
}
// 2. Prevent timing attacks - always check hash
String storedHash = getStoredPasswordHash(username);
if (storedHash == null) {
// Still perform hashing to prevent timing attacks
hashPassword("dummy".toCharArray());
return false;
}
// 3. Use secure hashing
String providedHash = hashPassword(password);
// 4. Secure comparison
return constantTimeEquals(storedHash, providedHash);
} finally {
// 5. Clear sensitive data from memory
if (password != null) {
Arrays.fill(password, '\0');
}
}
}
// Prevent timing attacks with constant-time comparison
private boolean constantTimeEquals(String a, String b) {
if (a.length() != b.length()) {
return false;
}
int result = 0;
for (int i = 0; i < a.length(); i++) {
result |= a.charAt(i) ^ b.charAt(i);
}
return result == 0;
}
}
4. Testing and Maintainability#
public class TestableCalculator {
// Dependencies injected for testability
private final Logger logger;
private final ConfigurationService config;
public TestableCalculator(Logger logger, ConfigurationService config) {
this.logger = logger;
this.config = config;
}
// Pure function - easy to test
public double calculateTax(double income, TaxBracket bracket) {
validateInput(income, bracket);
double rate = bracket.getRate();
double deduction = bracket.getStandardDeduction();
double taxableIncome = Math.max(0, income - deduction);
double tax = taxableIncome * rate;
logger.info("Tax calculated: " + tax + " for income: " + income);
return tax;
}
// Separate validation method - testable in isolation
private void validateInput(double income, TaxBracket bracket) {
if (income < 0) {
throw new IllegalArgumentException("Income cannot be negative");
}
if (bracket == null) {
throw new IllegalArgumentException("Tax bracket cannot be null");
}
if (bracket.getRate() < 0 || bracket.getRate() > 1) {
throw new IllegalArgumentException("Invalid tax rate: " + bracket.getRate());
}
}
}
layout: default#
Comprehensive Review Exercise#
Student Management System#
Create a complete application demonstrating all concepts:
// Main entity class
public class Student {
private String enrollmentNo;
private String name;
private String email;
private int age;
private Map<String, Integer> subjects;
public Student(String enrollmentNo, String name, String email, int age) {
setEnrollmentNo(enrollmentNo);
setName(name);
setEmail(email);
setAge(age);
this.subjects = new HashMap<>();
}
// Validation methods
private void setEnrollmentNo(String enrollmentNo) {
if (enrollmentNo == null || !enrollmentNo.matches("\\d{12}")) {
throw new IllegalArgumentException("Invalid enrollment number format");
}
this.enrollmentNo = enrollmentNo;
}
private void setEmail(String email) {
if (email == null || !email.contains("@") || !email.contains(".")) {
throw new IllegalArgumentException("Invalid email format");
}
this.email = email;
}
// Subject management
public void addSubject(String subject, int marks) {
if (subject == null || subject.trim().isEmpty()) {
throw new IllegalArgumentException("Subject name cannot be empty");
}
if (marks < 0 || marks > 100) {
throw new IllegalArgumentException("Marks must be between 0 and 100");
}
subjects.put(subject, marks);
}
// Grade calculation
public char calculateOverallGrade() {
if (subjects.isEmpty()) {
throw new IllegalStateException("No subjects added");
}
double average = subjects.values().stream()
.mapToInt(Integer::intValue)
.average()
.orElse(0.0);
if (average >= 70) return 'A';
if (average >= 60) return 'B';
if (average >= 50) return 'C';
if (average >= 35) return 'D';
return 'F';
}
@Override
public String toString() {
return String.format("Student{enrollment='%s', name='%s', grade=%c}",
enrollmentNo, name, calculateOverallGrade());
}
}
// Custom exceptions
class StudentNotFoundException extends Exception {
public StudentNotFoundException(String enrollmentNo) {
super("Student not found: " + enrollmentNo);
}
}
class DuplicateStudentException extends Exception {
public DuplicateStudentException(String enrollmentNo) {
super("Student already exists: " + enrollmentNo);
}
}
// Management service
public class StudentManager {
private Map<String, Student> students;
private Logger logger;
public StudentManager() {
this.students = new ConcurrentHashMap<>();
this.logger = Logger.getLogger(StudentManager.class.getName());
}
public void addStudent(Student student) throws DuplicateStudentException {
Objects.requireNonNull(student, "Student cannot be null");
String enrollmentNo = student.getEnrollmentNo();
if (students.containsKey(enrollmentNo)) {
throw new DuplicateStudentException(enrollmentNo);
}
students.put(enrollmentNo, student);
logger.info("Student added: " + enrollmentNo);
}
public Student findStudent(String enrollmentNo) throws StudentNotFoundException {
if (enrollmentNo == null || enrollmentNo.trim().isEmpty()) {
throw new IllegalArgumentException("Enrollment number cannot be empty");
}
Student student = students.get(enrollmentNo);
if (student == null) {
throw new StudentNotFoundException(enrollmentNo);
}
return student;
}
// File operations with proper exception handling
public void saveToFile(String filename) throws IOException {
try (PrintWriter writer = new PrintWriter(new FileWriter(filename))) {
writer.println("EnrollmentNo,Name,Email,Age,Grade");
for (Student student : students.values()) {
writer.printf("%s,%s,%s,%d,%c%n",
student.getEnrollmentNo(),
student.getName(),
student.getEmail(),
student.getAge(),
student.calculateOverallGrade());
}
logger.info("Student data saved to: " + filename);
}
}
// Thread-safe operations
public synchronized List<Student> getStudentsByGrade(char grade) {
return students.values().stream()
.filter(s -> s.calculateOverallGrade() == grade)
.collect(Collectors.toList());
}
}
layout: default#
Examination Preparation Strategy#
Theory Examination Tips#
Key Topics by Unit#
Unit I (14 marks)
- Java features and JVM architecture
- Data types and type conversion
- Operators and precedence
- Control structures implementation
- Array operations
Unit II (18 marks)
- OOP concepts and principles
- Class design and object creation
- Access modifiers and encapsulation
- Method overloading and constructors
- String class methods
Unit III (18 marks)
- Inheritance types and implementation
- Method overriding vs overloading
- Abstract classes vs interfaces
- Package creation and usage
- Polymorphism concepts
Unit IV (10 marks)
- Exception hierarchy and types
- Try-catch-finally syntax
- Custom exception creation
- Thread lifecycle and creation
- Synchronization basics
Unit V (10 marks)
- File I/O operations
- Collections framework structure
- ArrayList vs LinkedList
- HashMap usage
- Utility methods
Practical Examination Strategy#
Essential Programs to Master#
Rectangle class with constructor (Unit II)
public class Rectangle { private double height, width; public Rectangle(double height, double width) { this.height = height; this.width = width; } public double calculateArea() { return height * width; } public double calculatePerimeter() { return 2 * (height + width); } }Shape inheritance hierarchy (Unit III)
abstract class Shape { public abstract double calculateArea(); } class Triangle extends Shape { private double base, height; public double calculateArea() { return 0.5 * base * height; } }Banking application with exceptions (Unit IV)
public void withdraw(double amount) throws InsufficientFundsException { if (amount > balance) { throw new InsufficientFundsException("Not enough funds"); } balance -= amount; }File operations (Unit V)
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) { String line; while ((line = reader.readLine()) != null) { System.out.println(line); } }HashMap with student data (Unit V)
Map<String, String> students = new HashMap<>(); students.put("201901001", "John Doe"); students.put("201901002", "Jane Smith"); String name = students.get("201901001");
layout: default#
Micro-Project Ideas and Implementation#
Project 1: Library Management System#
Core Features#
public class Book {
private String isbn;
private String title;
private String author;
private boolean isAvailable;
private Date issueDate;
// Constructor, getters, setters
}
public class Member {
private String memberId;
private String name;
private List<Book> issuedBooks;
// Member management methods
}
public class Library {
private Map<String, Book> books;
private Map<String, Member> members;
public void issueBook(String memberId, String isbn)
throws BookNotAvailableException, MemberNotFoundException {
// Implementation with proper exception handling
}
public void returnBook(String memberId, String isbn)
throws BookNotFoundException {
// Implementation with date calculations
}
// File operations for persistence
public void saveBooksToFile(String filename) throws IOException {
try (ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream(filename))) {
oos.writeObject(books);
}
}
}
Advanced Features#
- Multi-threading for concurrent operations
- File-based data persistence
- Search functionality with collections
- Fine calculation system
- Member categorization (Student, Faculty, etc.)
Project 2: Inventory Management System#
Core Implementation#
public class Product {
private String productId;
private String name;
private double price;
private int quantity;
private Category category;
// Validation methods
public void updateQuantity(int change) throws InvalidQuantityException {
if (quantity + change < 0) {
throw new InvalidQuantityException("Insufficient stock");
}
quantity += change;
}
}
public class InventoryManager {
private Map<String, Product> inventory;
// CRUD operations
public void addProduct(Product product) throws DuplicateProductException {
if (inventory.containsKey(product.getProductId())) {
throw new DuplicateProductException(product.getProductId());
}
inventory.put(product.getProductId(), product);
}
// Search operations
public List<Product> findProductsByCategory(Category category) {
return inventory.values().stream()
.filter(p -> p.getCategory() == category)
.collect(Collectors.toList());
}
// Report generation
public void generateLowStockReport(int threshold) {
List<Product> lowStockItems = inventory.values().stream()
.filter(p -> p.getQuantity() < threshold)
.sorted((p1, p2) -> Integer.compare(p1.getQuantity(), p2.getQuantity()))
.collect(Collectors.toList());
// Generate report
}
}
Assessment Criteria#
- Functionality (40%): Core features working correctly
- Code Quality (30%): Following best practices, proper structure
- Exception Handling (15%): Robust error handling
- Documentation (10%): Comments and user guide
- Innovation (5%): Additional creative features
layout: default#
Advanced Java Concepts Preview#
Beyond Basic Java#
1. Generics (Type Safety)#
// Generic class
public class Box<T> {
private T content;
public void set(T content) {
this.content = content;
}
public T get() {
return content;
}
}
// Usage with type safety
Box<String> stringBox = new Box<>();
stringBox.set("Hello World");
String content = stringBox.get(); // No casting needed
Box<Integer> intBox = new Box<>();
intBox.set(42);
Integer number = intBox.get();
// Generic methods
public static <T> void swap(T[] array, int i, int j) {
T temp = array[i];
array[i] = array[j];
array[j] = temp;
}
2. Lambda Expressions (Java 8+)#
// Traditional anonymous class
List<String> names = Arrays.asList("John", "Jane", "Bob");
names.sort(new Comparator<String>() {
@Override
public int compare(String a, String b) {
return a.compareTo(b);
}
});
// Lambda expression
names.sort((a, b) -> a.compareTo(b));
// Even simpler with method reference
names.sort(String::compareTo);
// Functional interfaces
interface Calculator {
int calculate(int a, int b);
}
Calculator add = (a, b) -> a + b;
Calculator multiply = (a, b) -> a * b;
int sum = add.calculate(5, 3); // Result: 8
int product = multiply.calculate(5, 3); // Result: 15
3. Stream API (Functional Programming)#
public class StreamExamples {
public void demonstrateStreams() {
List<Student> students = Arrays.asList(
new Student("John", 85),
new Student("Jane", 92),
new Student("Bob", 78),
new Student("Alice", 95)
);
// Filter high-performing students
List<Student> topStudents = students.stream()
.filter(s -> s.getMarks() >= 90)
.collect(Collectors.toList());
// Calculate average marks
double averageMarks = students.stream()
.mapToInt(Student::getMarks)
.average()
.orElse(0.0);
// Find student with highest marks
Optional<Student> topStudent = students.stream()
.max(Comparator.comparing(Student::getMarks));
// Group students by grade
Map<Character, List<Student>> studentsByGrade = students.stream()
.collect(Collectors.groupingBy(this::calculateGrade));
// Complex processing pipeline
List<String> topStudentNames = students.stream()
.filter(s -> s.getMarks() >= 85)
.sorted(Comparator.comparing(Student::getMarks).reversed())
.limit(3)
.map(Student::getName)
.collect(Collectors.toList());
}
private char calculateGrade(Student student) {
int marks = student.getMarks();
if (marks >= 90) return 'A';
if (marks >= 80) return 'B';
if (marks >= 70) return 'C';
if (marks >= 60) return 'D';
return 'F';
}
}
4. Modern Java Features#
// Try-with-resources (Java 7+)
try (FileReader fr = new FileReader("data.txt");
BufferedReader br = new BufferedReader(fr)) {
String line;
while ((line = br.readLine()) != null) {
System.out.println(line);
}
} // Automatic resource closing
// Optional class (Java 8+) - Null safety
Optional<String> optionalValue = Optional.ofNullable(getValue());
optionalValue.ifPresent(System.out::println);
String result = optionalValue.orElse("Default Value");
// Method references
List<String> words = Arrays.asList("hello", "world", "java");
words.forEach(System.out::println); // Method reference
// Switch expressions (Java 14+)
String dayType = switch (dayOfWeek) {
case MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY -> "Weekday";
case SATURDAY, SUNDAY -> "Weekend";
};
layout: default#
Career Pathways and Next Steps#
Java Career Opportunities#
1. Software Development Roles#
Entry Level (0-2 years)
- Junior Java Developer
- Software Trainee
- Associate Software Engineer
- Starting Salary: ₹3-6 LPA
Mid Level (2-5 years)
- Java Developer
- Software Engineer
- Full Stack Developer (Java + Frontend)
- Backend Developer
- Salary Range: ₹6-15 LPA
Senior Level (5+ years)
- Senior Java Developer
- Technical Lead
- Software Architect
- System Designer
- Salary Range: ₹15-40+ LPA
2. Specialized Java Domains#
Enterprise Applications
- Spring Framework specialist
- Microservices architect
- API developer
- Cloud-native applications
Android Development
- Mobile app developer
- Android architect
- Play Store publisher
- Mobile UI/UX specialist
Web Development
- Full-stack Java developer
- REST API specialist
- Web services developer
- E-commerce platform developer
Continuous Learning Path#
Phase 1: Foundation Strengthening#
// Master these core areas first
1. Object-Oriented Design Patterns
2. Data Structures and Algorithms
3. Database Integration (JDBC)
4. Unit Testing (JUnit)
5. Version Control (Git)
Phase 2: Framework Mastery#
// Popular Java frameworks to learn
1. Spring Framework (Dependency Injection, Spring Boot)
2. Hibernate (ORM - Object Relational Mapping)
3. Maven/Gradle (Build tools)
4. JPA (Java Persistence API)
5. RESTful Web Services
Phase 3: Advanced Technologies#
// Modern Java ecosystem
1. Microservices Architecture
2. Cloud Platforms (AWS, Azure, GCP)
3. Containerization (Docker, Kubernetes)
4. Message Queues (RabbitMQ, Apache Kafka)
5. NoSQL Databases (MongoDB, Redis)
Recommended Study Plan#
Months 1-3: Strengthen Java fundamentals Months 4-6: Learn Spring Boot and database integration Months 7-9: Build portfolio projects Months 10-12: Contribute to open source, prepare for interviews
Portfolio Projects Ideas#
- E-commerce Backend API
- Task Management System
- Social Media Platform
- Banking Application
- Chat Application with real-time features
Certification Paths#
- Oracle Certified Java Programmer (OCPJP)
- Spring Professional Certification
- AWS Certified Developer
- Google Associate Cloud Engineer
layout: default#
Course Assessment and Final Review#
Course Outcomes Achievement Check#
CO-a: Write simple Java programs ✅#
Evidence:
- Basic syntax and structure mastery
- Control flow implementation
- Array manipulation programs
- Mathematical calculations
Sample Achievement:
// Simple program demonstrating CO-a
public class GradeCalculator {
public static void main(String[] args) {
int[] marks = {85, 92, 78, 89, 96};
// Calculate average
int sum = 0;
for (int mark : marks) {
sum += mark;
}
double average = sum / 5.0;
// Determine grade
char grade;
if (average >= 90) grade = 'A';
else if (average >= 80) grade = 'B';
else if (average >= 70) grade = 'C';
else grade = 'F';
System.out.printf("Average: %.2f, Grade: %c%n", average, grade);
}
}
CO-b: Apply OOP concepts ✅#
Evidence:
- Class and object creation
- Encapsulation with private fields
- Method overloading implementation
- Constructor usage
CO-c: Use inheritance and packages ✅#
Evidence:
- Single, multilevel, hierarchical inheritance
- Method overriding
- Package organization
- Interface implementation
CO-d: Multithreading and exception handling ✅#
Evidence:
- Exception hierarchy understanding
- Custom exception creation
- Thread creation and management
- Synchronization concepts
CO-e: Files and collections ✅#
Evidence:
- File I/O operations
- ArrayList and LinkedList usage
- HashMap implementation
- Collections utility methods
Final Assessment Checklist#
Theory Readiness ✅#
- All 42 lectures completed
- Unit-wise notes prepared
- Previous year questions solved
- Key concepts memorized
- Programming syntax mastered
Practical Readiness ✅#
- All 30 practical exercises completed
- Compulsory practicals (*) perfected
- Micro-project completed
- Code writing speed improved
- Debugging skills developed
Exam Strategy ✅#
- Time management practiced
- Question pattern understood
- Code templates memorized
- Error handling mastered
- Documentation skills polished
You are now ready for Java programming success! 🎉
layout: center class: text-center#
Congratulations!#
Java Programming Journey Complete#
42 Lectures Successfully Completed!
You have mastered Java programming fundamentals and are ready to build amazing applications
Key Achievements 🏆#
- ✅ 560+ concepts learned across 5 units
- ✅ 30+ practical exercises completed
- ✅ 100+ code examples implemented
- ✅ 5 major projects designed
- ✅ Real-world applications built
What’s Next? 🚀#
- Apply for Java developer positions
- Contribute to open-source projects
- Build your own applications
- Continue learning advanced frameworks
- Share knowledge with others
🎓
Ready to code the future with Java!
layout: center class: text-center#
Thank You!#
Java Programming Course (4343203) Complete#
From Basic Syntax to Professional Development
You’ve journeyed through 42 comprehensive lectures covering every aspect of Java programming
Final Words of Wisdom#
“The best way to learn programming is by writing programs. Now that you know Java, keep coding, keep learning, and keep building amazing things!”
Connect and Continue Learning#
- Join Java developer communities
- Follow Java blogs and tutorials
- Practice coding challenges daily
- Build real-world projects
- Mentor other beginners
Happy Coding! 🚀 | Gujarat Technological University