JAVA PROGRAMMING
An Internship report submitted to
Jawaharlal Nehru Technological University, Kakinada,
In the partial fulfillment for the award of the Degree in
BACHELOR OF TECHNOLOGY
IN
COMPUTERSCIENCE & ENGINEERING
Submitted by
PASAM CHAKRADHAR
22F91A0521
Under the Supervision of
Mr.K MOHAN RAO([Link])
PRAKASAMENGINEERINGCOLLEGE
(An ISO 9001-2008&NAAC Accredited Institution)
(Affiliated to Jawaharlal Nehru Technological University, Kakinada)
[Link], KANDUKUR-523105, A.P.
A.Y:2024-2025
PRAKASAMENGINEERINGCOLLEGE
(AnISO9001-2008&NAACAccreditedInstitution)
(Affiliated to Jawaharlal Nehru Technological University, Kakinada)
[Link],KANDUKUR-523105,A.P.
DEPARTMENTOF
COMPTERSCIENCE&ENGINEERING
BONAFIDECERTIFICATE
This is to certify that the Internship report entitled “JAVA PROGRAMMING” is a bonafide
work of PASAM CHAKRADHAR (22F91A0521) in the partial fulfillment of the
requirement for the award of the degree in Bachelor of Technology in COMPUTER
SCIENCE & ENGINEERING for the academic year 2023-2024.
Signature of the Coordinator Signature of the HOD
Mr.V. BALAKRISHNA RAO Mr. [Link]
[Link],(Ph.D)
MBA
Signature of External Examiner
ANDHRA PRADESH STATE COUNCIL OF HIGHER EDUCATION
(A Statutory Body of Government of A.P.)
Certificate of Completion
This is to certify Pasam Chakradhar
under of Prakasam Engineering College of JNTUK has
successfully completed 6 weeks Short -Term Internship on
Java Programming
Organized by ExcelR Edtech Pvt. Ltd. in collaboration with
Andhra Pradesh State Council of Higher Education
Cert No: EXCELR-85908 Ram Tavva
Presented on Aug 2nd 2024 CEO,
ExcelR EdTech Pvt. Ltd.
ACKNOWLEDGEMENT
I feel to render my thankful acknowledgement to the following distinguished personalities, who
stretched their helping hand to me, in completing my mini project work.
I am very grateful and my sincere thanks to our secretary & correspondent [Link] of
PRAKASAM ENGINEERING COLLEGE for giving this opportunity.
I hereby, express my regards and extend my gratitude to our PRINCIPAL, [Link]. RAVI
KUMAR , for giving this opportunity to do the thesis as a part of our course.
I express my deep sense of gratitude to [Link], [Link](Ph.d), Head of the
Department, Department of CSE for having shown keen interest at every stage of development
of our thesis and guiding us in every aspect.
I am thankful to my Internship Coordinator Mr.V. BALAKRISHNA RAO MBA who has
channeled my thoughts and timely suggestions.
I would like to thank [Link] TAWA EXCELR PVT LTD,HYDERBAD for giving me the
opportunity to do an internship within the organization.
I would also like to thank all my Faculties in Prakasam Engineering College for their constant
encouragement and for being a great group of knowledgeable and cooperative people to work
with.
PASAM CHAKRADHAR
22F91A0521
Week 1: Introduction to Java Programming
Introduction to the Internship Program
- **Overview of the Company and Its Mission**
- Brief history of the company, including its founding and major milestones.
- Core values and mission statement, emphasizing the company’s commitment to
innovation and quality.
- Key products and services offered, highlighting the company’s market position and
unique selling points.
- **Introduction to the Team and Key Contacts**
- Names and roles of team members, including their areas of expertise and
responsibilities.
- Contact information and preferred communication channels (e.g., email, Slack,
Microsoft Teams).
- Team structure and hierarchy, explaining how different departments and roles interact.
- **Explanation of Internship Goals and Expectations**
- Specific objectives for the internship, such as learning outcomes and skill development.
- Expected outcomes and deliverables, including any projects or reports to be completed.
- Evaluation criteria and feedback mechanisms, detailing how performance will be
assessed and feedback provided.
#### Setting Up the Development Environment
- **Installing Java Development Kit (JDK)**
- Step-by-step guide to downloading and installing the JDK from the official Oracle
website.
- Configuring system environment variables, including setting JAVA_HOME and updating
the PATH variable.
- **Setting Up Integrated Development Environment (IDE)**
- Overview of popular IDEs (IntelliJ IDEA, Eclipse, NetBeans), with a focus on the chosen
IDE for the internship.
- Detailed setup instructions for the chosen IDE, including installation and initial
configuration.
- Customizing IDE settings for optimal workflow, such as configuring code style, enabling
useful plugins, and setting up version control.
- **Configuring Environment Variables**
- Importance of environment variables in Java development, explaining how they affect the
compilation and execution of Java programs.
- Instructions for setting JAVA_HOME and PATH variables on different operating systems
(Windows, macOS, Linux).
#### Basic Java Syntax
- **Writing the First Java Program: “Hello, World!”**
- Detailed explanation of the program structure, including the `public class` declaration
and the `main` method.
- Compiling and running the program from the command line, with a focus on
understanding the compilation process and common errors.
- **Understanding the Structure of a Java Program**
- Explanation of classes, methods, and the `main` method, highlighting their roles in a
Java application.
- Syntax rules and conventions, including naming conventions, code indentation, and
comments.
- **Compiling and Running Java Programs**
- Using the `javac` compiler to compile Java source files, with examples of common
commands and options.
- Running Java applications with the `java` command, including passing arguments to the
`main` method.
#### Java Basics
- **Data Types and Variables**
- Overview of primitive data types (int, char, float, boolean, etc.), including their ranges
and default values.
- Declaring and initializing variables, with examples of different data types and
initialization methods.
- Type casting and type conversion, explaining the difference between implicit and explicit
casting with examples.
```java
Public class DataTypesExample {
Public static void main(String[] args) {
// Integer data type
Int age = 25;
[Link](“Age: “ + age);
// Character data type
Char grade = ‘A’;
[Link](“Grade: “ + grade);
// Float data type
Float salary = 50000.50f;
[Link](“Salary: “ + salary);
// Boolean data type
Boolean isJavaFun = true;
[Link](“Is Java fun? “ + isJavaFun);
```
- **Operators and Expressions**
- Arithmetic operators, including addition, subtraction, multiplication, division, and
modulus, with examples of their usage.
- Relational operators, such as equality, inequality, greater than, and less than, with
examples of their use in conditional statements.
- Logical operators, including AND, OR, and NOT, with examples of combining logical
operators in complex expressions.
- Assignment operators, including basic assignment and compound assignment
operators, with examples of their usage.
```java
Public class TypeCastingExample {
Public static void main(String[] args) {
// Implicit casting (widening conversion)
Int num = 100;
Double doubleNum = num; // int to double
[Link](“Double value: “ + doubleNum);
// Explicit casting (narrowing conversion)
Double decimalNum = 9.78;
Int intNum = (int) decimalNum; // double to int
[Link](“Integer value: “ + intNum);
```
- **Control Flow Statements**
- Conditional statements, including `if`, `if-else`, and `switch` statements, with
examples and use cases.
- Looping statements, including `for`, `while`, and `do-while` loops, with examples of
iterative processes and common patterns.
```java
Public class ControlFlowExample {
Public static void main(String[] args) {
// If-else statement
Int number = 10;
If (number > 0) {
[Link](“The number is positive.”);
} else {
[Link](“The number is not positive.”);
// For loop
[Link](“For loop:”);
For (int I = 0; I < 5; i++) {
[Link](“i: “ + i);
// While loop
[Link](“While loop:”);
Int j = 0;
While (j < 5) {
[Link](“j: “ + j);
J++;
// Do-while loop
[Link](“Do-while loop:”);
Int k = 0;
Do {
[Link](“k: “ + k);
K++;
} while (k < 5);
}
```
#### Object-Oriented Programming (OOP) Concepts
- **Introduction to OOP**
- Understanding classes and objects, explaining the concepts of encapsulation,
inheritance, and polymorphism.
- Defining a class and creating objects, with examples of class definitions and object
instantiation.
- Constructors and methods, explaining their roles in initializing objects and defining
behavior.
```java
// Class and Object Example
Class Student {
String name;
Int age;
Void display() {
[Link](“Name: “ + name);
[Link](“Age: “ + age);
Public class Main {
Public static void main(String[] args) {
Student student1 = new Student();
[Link] = “John”;
[Link] = 20;
[Link]();
```
- **Encapsulation**
- Access modifiers (private, public, protected), explaining their impact on visibility and
access control.
- Getters and setters, with examples of encapsulating fields and providing controlled
access.
```java
Class Person {
Private String name;
Private int age;
// Getter for name
Public String getName() {
Return name;
// Setter for name
Public void setName(String name) {
[Link] = name;
}
// Getter for age
Public int getAge() {
Return age;
// Setter for age
Public void setAge(int age) {
[Link] = age;
Public class Main {
Public static void main(String[] args) {
Person person = new Person();
[Link](“Alice”);
[Link](30);
[Link](“Name: “ + [Link]());
[Link](“Age: “ + [Link]());
```
- **Inheritance**
- Extending classes, explaining the concept of inheritance and the `extends` keyword.
- Method overriding, with examples of overriding methods in subclasses to provide
specific behavior.
```java
// Base class
Class Animal {
Void eat() {
[Link](“This animal eats food.”);
// Derived class
Class Dog extends Animal {
Void bark() {
[Link](“The dog barks.”);
Public class Main {
Public static void main(String[] args) {
Dog dog = new Dog();
[Link](); // Inherited method
[Link](); // Specific method
```
#### Advanced OOP Concepts
- **Polymorphism**
- Method overloading, explaining the concept and providing examples of overloaded
methods.
- Method overriding, with a focus on runtime polymorphism and the use of the
`@Override` annotation.
```java
Class MathOperations {
// Method overloading
Int add(int a, int b) {
Return a + b;
Double add(double a, double b) {
Return a + b;
Public class Main {
Public static void main(String[] args) {
MathOperations math = new MathOperations();
[Link](“Sum of integers: “ + [Link](5, 10));
[Link](“Sum of doubles: “ + [Link](5.5, 10.5));
```
- **Abstraction**
- Abstract classes and methods, explaining their roles in defining abstract behavior and
providing partial implementation.
- Interfaces, explaining their use in defining contracts and enabling multiple inheritance.
```java
// Abstract class
Abstract class Shape {
Abstract void draw();
// Concrete class
Class Circle extends Shape {
Void draw
___________________________________________
### Week 2: Advanced Java Programming Concepts
#### Introduction to Advanced Java Concepts
- **Overview of Week 2 Objectives**
- Deepening understanding of Java programming.
- Introduction to more complex programming concepts and techniques.
- Application of these concepts through practical exercises and projects.
#### Data Structures and Algorithms
- **Introduction to Data Structures**
- Importance of data structures in programming.
- Overview of common data structures: arrays, linked lists, stacks, queues, trees, and
graphs.
- **Arrays and Linked Lists**
- Definition and use cases of arrays.
- Basic operations on arrays: insertion, deletion, traversal.
- Definition and use cases of linked lists.
- Types of linked lists: singly linked list, doubly linked list, circular linked list.
- Basic operations on linked lists: insertion, deletion, traversal.
```java
// Example of Array Operations
Public class ArrayExample {
Public static void main(String[] args) {
Int[] numbers = {1, 2, 3, 4, 5};
// Traversing the array
For (int number : numbers) {
[Link](number);
// Example of Linked List Operations
Class Node {
Int data;
Node next;
Node(int data) {
[Link] = data;
[Link] = null;
Public class LinkedListExample {
Node head;
// Inserting a new node at the end
Public void insert(int data) {
Node newNode = new Node(data);
If (head == null) {
Head = newNode;
} else {
Node temp = head;
While ([Link] != null) {
Temp = [Link];
[Link] = newNode;
// Displaying the linked list
Public void display() {
Node temp = head;
While (temp != null) {
[Link]([Link] + “ “);
Temp = [Link];
Public static void main(String[] args) {
LinkedListExample list = new LinkedListExample();
[Link](1);
[Link](2);
[Link](3);
[Link]();
```
- **Stacks and Queues**
- Definition and use cases of stacks.
- Basic operations on stacks: push, pop, peek.
- Definition and use cases of queues.
- Basic operations on queues: enqueue, dequeue, front, rear.
```java
// Example of Stack Operations
Import [Link];
Public class StackExample {
Public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
[Link](1);
[Link](2);
[Link](3);
[Link](“Stack: “ + stack);
[Link]();
[Link](“Stack after pop: “ + stack);
// Example of Queue Operations
Import [Link];
Import [Link];
Public class QueueExample {
Public static void main(String[] args) {
Queue<Integer> queue = new LinkedList<>();
[Link](1);
[Link](2);
[Link](3);
[Link](“Queue: “ + queue);
[Link]();
[Link](“Queue after remove: “ + queue);
}
```
#### Algorithms
- **Sorting Algorithms**
- Importance of sorting in computer science.
- Overview of common sorting algorithms: bubble sort, selection sort, insertion sort,
merge sort, quick sort.
```java
// Example of Bubble Sort
Public class BubbleSortExample {
Public static void bubbleSort(int[] arr) {
Int n = [Link];
For (int I = 0; I < n – 1; i++) {
For (int j = 0; j < n – I – 1; j++) {
If (arr[j] > arr[j + 1]) {
// Swap arr[j] and arr[j + 1]
Int temp = arr[j];
Arr[j] = arr[j + 1];
Arr[j + 1] = temp;
}
Public static void main(String[] args) {
Int[] arr = {64, 34, 25, 12, 22, 11, 90};
bubbleSort(arr);
[Link](“Sorted array: “);
For (int num : arr) {
[Link](num + “ “);
```
- **Searching Algorithms**
- Importance of searching in computer science.
- Overview of common searching algorithms: linear search, binary search.
```java
// Example of Linear Search
Public class LinearSearchExample {
Public static int linearSearch(int[] arr, int key) {
For (int I = 0; I < [Link]; i++) {
If (arr[i] == key) {
Return I;
Return -1;
}
Public static void main(String[] args) {
Int[] arr = {2, 4, 0, 1, 9};
Int key = 1;
Int result = linearSearch(arr, key);
If (result == -1) {
[Link](“Element not found”);
} else {
[Link](“Element found at index: “ + result);
// Example of Binary Search
Public class BinarySearchExample {
Public static int binarySearch(int[] arr, int key) {
Int low = 0;
Int high = [Link] – 1;
While (low <= high) {
Int mid = (low + high) / 2;
If (arr[mid] == key) {
Return mid;
} else if (arr[mid] < key) {
Low = mid + 1;
} else {
High = mid – 1;
Return -1;
Public static void main(String[] args) {
Int[] arr = {2, 4, 6, 8, 10, 12, 14};
Int key = 10;
Int result = binarySearch(arr, key);
If (result == -1) {
[Link](“Element not found”);
} else {
[Link](“Element found at index: “ + result);
```
#### Practical Exercises and Mini-Project
- **Hands-on Coding Exercises**
- Writing programs to demonstrate the use of data structures and algorithms.
- Debugging and testing code, explaining common debugging techniques and tools.
- **Mini-Project: Library Management System**
- Designing a class structure for a library management system.
- Implementing functionalities like adding books, issuing books, returning books, and
searching for books.
```java
Import [Link];
Import [Link];
Class Book {
Private String title;
Private String author;
Private boolean isIssued;
Public Book(String title, String author) {
[Link] = title;
[Link] = author;
[Link] = false;
Public String getTitle() {
Return title;
Public String getAuthor() {
Return author;
}
Public boolean isIssued() {
Return isIssued;
Public void issue() {
isIssued = true;
Public void returnBook() {
isIssued = false;
Class Library {
Private List<Book> books;
Public Library() {
Books = new ArrayList<>();
Public void addBook(Book book) {
[Link](book);
Public void issueBook(String title) {
For (Book book : books) {
If ([Link]().equals(title) && ![Link]()) {
[Link]();
[Link](“Book issued: “ + title);
Return;
[Link](“Book not available or already issued.”);
Public void returnBook(String title) {
For (Book book : books) {
If ([Link]().equals(title) && [Link]()) {
[Link]();
[Link](“Book returned: “ + title);
Return;
[Link](“Book not found or not issued.”);
Public void searchBook(String title) {
For (Book book : books) {
If ([Link]().equals(title)) {
[Link](“Book found: “ + title + “ by “ + [Link]());
Return;
}
}
[Link](“Book not found.”);
Public class LibraryManagementSystem {
Public static void main(String[] args) {
Library library = new Library();
[Link](new Book(“The Great Gatsby”, “F. Scott Fitzgerald”));
[Link](new Book(“1984”, “George Orwell”));
[Link](“1984”);
[Link](“1984”);
[Link](“1984”);
```
### Week 3: Java Programming – Advanced Topics and Practical Applications
#### Introduction to Week 3
- **Overview of Week 3 Objectives**
- Deepening understanding of advanced Java programming concepts.
- Applying these concepts through practical exercises and projects.
- Enhancing problem-solving skills and coding efficiency.
#### Exception Handling
- **Introduction to Exceptions**
- Definition and importance of exception handling in Java.
- Types of exceptions: checked and unchecked exceptions.
- **Try-Catch Block**
- Syntax and usage of try-catch blocks.
- Multiple catch blocks and nested try statements.
```java
Public class ExceptionExample {
Public static void main(String[] args) {
Try {
Int[] numbers = {1, 2, 3};
[Link](numbers[5]); // This will throw an
ArrayIndexOutOfBoundsException
} catch (ArrayIndexOutOfBoundsException e) {
[Link](“Array index is out of bounds!”);
} finally {
[Link](“This block is always executed.”);
```
- **Throw and Throws**
- Using `throw` to manually throw an exception.
- Using `throws` to declare an exception.
```java
Public class ThrowExample {
Public static void checkAge(int age) {
If (age < 18) {
Throw new ArithmeticException(“Access denied – You must be at least 18 years
old.”);
} else {
[Link](“Access granted – You are old enough!”);
Public static void main(String[] args) {
checkAge(15); // This will throw an exception
```
#### File I/O
- **Introduction to File Handling**
- Importance of file handling in Java.
- Overview of [Link] package.
- **Reading and Writing Files**
- Using FileReader and FileWriter classes.
- Using BufferedReader and BufferedWriter for efficient file operations.
```java
Import [Link].*;
Public class FileIOExample {
Public static void main(String[] args) {
// Writing to a file
Try (FileWriter writer = new FileWriter(“[Link]”);
BufferedWriter bw = new BufferedWriter(writer)) {
[Link](“Hello, World!”);
} catch (IOException e) {
[Link]();
// Reading from a file
Try (FileReader reader = new FileReader(“[Link]”);
BufferedReader br = new BufferedReader(reader)) {
String line;
While ((line = [Link]()) != null) {
[Link](line);
} catch (IOException e) {
[Link]();
}
```
#### Collections Framework
- **Introduction to Collections**
- Importance of collections in Java.
- Overview of the Collections Framework: List, Set, Map, and Queue interfaces.
- **List Interface**
- ArrayList and LinkedList classes.
- Basic operations: adding, removing, and accessing elements.
```java
Import [Link];
Import [Link];
Public class ListExample {
Public static void main(String[] args) {
List<String> fruits = new ArrayList<>();
[Link](“Apple”);
[Link](“Banana”);
[Link](“Orange”);
// Accessing elements
[Link]([Link](1)); // Output: Banana
// Removing an element
[Link](“Banana”);
// Iterating over the list
For (String fruit : fruits) {
[Link](fruit);
```
- **Set Interface**
- HashSet and TreeSet classes.
- Basic operations: adding, removing, and checking for elements.
```java
Import [Link];
Import [Link];
Public class SetExample {
Public static void main(String[] args) {
Set<String> animals = new HashSet<>();
[Link](“Dog”);
[Link](“Cat”);
[Link](“Horse”);
// Checking for an element
[Link]([Link](“Cat”)); // Output: true
// Removing an element
[Link](“Cat”);
// Iterating over the set
For (String animal : animals) {
[Link](animal);
```
- **Map Interface**
- HashMap and TreeMap classes.
- Basic operations: adding, removing, and accessing key-value pairs.
```java
Import [Link];
Import [Link];
Public class MapExample {
Public static void main(String[] args) {
Map<String, Integer> ages = new HashMap<>();
[Link](“Alice”, 30);
[Link](“Bob”, 25);
[Link](“Charlie”, 35);
// Accessing a value
[Link]([Link](“Alice”)); // Output: 30
// Removing a key-value pair
[Link](“Bob”);
// Iterating over the map
For ([Link]<String, Integer> entry : [Link]()) {
[Link]([Link]() + “: “ + [Link]());
```
#### Practical Exercises and Mini-Project
- **Hands-on Coding Exercises**
- Writing programs to demonstrate the use of exception handling, file I/O, and collections.
- Debugging and testing code, explaining common debugging techniques and tools.
- **Mini-Project: Student Management System**
- Designing a class structure for a student management system.
- Implementing functionalities like adding students, updating student information, and
displaying student details.
```java
Import [Link];
Import [Link];
Class Student {
Private String name;
Private int age;
Private String id;
Public Student(String name, int age, String id) {
[Link] = name;
[Link] = age;
[Link] = id;
Public String getName() {
Return name;
Public int getAge() {
Return age;
}
Public String getId() {
Return id;
@Override
Public String toString() {
Return “Student{“ +
“name=’” + name + ‘\’’ +
“, age=” + age +
“, id=’” + id + ‘\’’ +
‘}’;
Class StudentManagementSystem {
Private List<Student> students;
Public StudentManagementSystem() {
Students = new ArrayList<>();
Public void addStudent(Student student) {
[Link](student);
Public void updateStudent(String id, String newName, int newAge) {
For (Student student : students) {
If ([Link]().equals(id)) {
[Link](student);
[Link](new Student(newName, newAge, id));
Break;
Public void displayStudents() {
For (Student student : students) {
[Link](student);
Public static void main(String[] args) {
StudentManagementSystem sms = new StudentManagementSystem();
[Link](new Student(“Alice”, 20, “S001”));
[Link](new Student(“Bob”, 22, “S002”));
[Link](“All Students:”);
[Link]();
[Link](“S001”, “Alice Smith”, 21);
[Link](“Updated Students:”);
[Link]();
}
``
___________________________________________
Ji### Week 4: Java Programming – GUI Development and Multithreading
#### Introduction to Week 4
- **Overview of Week 4 Objectives**
- Understanding the basics of GUI development in Java.
- Learning about multithreading and concurrency.
- Applying these concepts through practical exercises and projects.
#### Graphical User Interface (GUI) Development
- **Introduction to GUI Programming**
- Importance of GUI in application development.
- Overview of Java’s Abstract Window Toolkit (AWT) and Swing.
- **Creating a Simple GUI with AWT**
- Basic components: Frame, Button, Label, TextField.
- Event handling using ActionListener.
```java
Import [Link].*;
Import [Link].*;
Public class AWTExample {
Public static void main(String[] args) {
Frame frame = new Frame(“AWT Example”);
Label label = new Label(“Enter your name:”);
TextField textField = new TextField();
Button button = new Button(“Submit”);
[Link](50, 50, 100, 30);
[Link](160, 50, 150, 30);
[Link](100, 100, 80, 30);
[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
[Link](“Name: “ + [Link]());
});
[Link](label);
[Link](textField);
[Link](button);
[Link](400, 200);
[Link](null);
[Link](true);
}
```
- **Creating a Simple GUI with Swing**
- Basic components: JFrame, JButton, JLabel, JTextField.
- Event handling using ActionListener.
```java
Import [Link].*;
Import [Link].*;
Public class SwingExample {
Public static void main(String[] args) {
JFrame frame = new JFrame(“Swing Example”);
JLabel label = new JLabel(“Enter your name:”);
JTextField textField = new JTextField();
JButton button = new JButton(“Submit”);
[Link](50, 50, 100, 30);
[Link](160, 50, 150, 30);
[Link](100, 100, 80, 30);
[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
[Link](“Name: “ + [Link]());
});
[Link](label);
[Link](textField);
[Link](button);
[Link](400, 200);
[Link](null);
[Link](true);
[Link](JFrame.EXIT_ON_CLOSE);
```
#### Multithreading and Concurrency
- **Introduction to Multithreading**
- Importance of multithreading in Java.
- Overview of the Thread class and Runnable interface.
- **Creating and Running Threads**
- Extending the Thread class.
- Implementing the Runnable interface.
```java
// Extending the Thread class
Class MyThread extends Thread {
Public void run() {
For (int I = 0; I < 5; i++) {
[Link]([Link]().getId() + “ Value “ + i);
Public class ThreadExample {
Public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
[Link]();
[Link]();
```
```java
// Implementing the Runnable interface
Class MyRunnable implements Runnable {
Public void run() {
For (int I = 0; I < 5; i++) {
[Link]([Link]().getId() + “ Value “ + i);
}
Public class RunnableExample {
Public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
Thread t2 = new Thread(new MyRunnable());
[Link]();
[Link]();
```
- **Thread Synchronization**
- Importance of synchronization in multithreading.
- Using synchronized methods and blocks.
```java
Class Counter {
Private int count = 0;
Public synchronized void increment() {
Count++;
Public int getCount() {
Return count;
}
Public class SynchronizationExample {
Public static void main(String[] args) {
Counter counter = new Counter();
Thread t1 = new Thread(new Runnable() {
Public void run() {
For (int I = 0; I < 1000; i++) {
[Link]();
});
Thread t2 = new Thread(new Runnable() {
Public void run() {
For (int I = 0; I < 1000; i++) {
[Link]();
});
[Link]();
[Link]();
Try {
[Link]();
[Link]();
} catch (InterruptedException e) {
[Link]();
[Link](“Count: “ + [Link]());
```
#### Practical Exercises and Mini-Project
- **Hands-on Coding Exercises**
- Writing programs to demonstrate the use of GUI components and multithreading.
- Debugging and testing code, explaining common debugging techniques and tools.
- **Mini-Project: Simple Chat Application**
- Designing a class structure for a simple chat application.
- Implementing functionalities like sending and receiving messages, and displaying chat
history.
```java
Import [Link].*;
Import [Link].*;
Import [Link].*;
Import [Link];
Class ChatWindow extends JFrame {
Private JTextArea chatArea;
Private JTextField inputField;
Private JButton sendButton;
Private ArrayList<String> chatHistory;
Public ChatWindow() {
chatHistory = new ArrayList<>();
chatArea = new JTextArea();
[Link](false);
[Link](20, 20, 360, 200);
inputField = new JTextField();
[Link](20, 230, 260, 30);
sendButton = new JButton(“Send”);
[Link](290, 230, 90, 30);
[Link](new ActionListener() {
public void actionPerformed(ActionEvent e) {
String message = [Link]();
[Link](message);
[Link](“You: “ + message + “\n”);
[Link](“”);
});
Add(chatArea);
Add(inputField);
Add(sendButton);
setSize(400, 300);
setLayout(null);
setVisible(true);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Public class ChatApplication {
Public static void main(String[] args) {
New ChatWindow();
```
### Week 5: Java Programming – Advanced Topics and Practical Applications
#### Introduction to Week 5
- **Overview of Week 5 Objectives**
- Exploring advanced Java programming concepts.
- Applying these concepts through practical exercises and projects.
- Enhancing problem-solving skills and coding efficiency.
#### Java Networking
- **Introduction to Networking in Java**
- Importance of networking in modern applications.
- Overview of [Link] package.
- **Working with Sockets**
- Understanding the concept of sockets.
- Creating a simple client-server application using sockets.
```java
// Server Program
Import [Link].*;
Import [Link].*;
Public class Server {
Public static void main(String[] args) {
Try (ServerSocket serverSocket = new ServerSocket(5000)) {
[Link](“Server is listening on port 5000”);
Socket socket = [Link]();
[Link](“Client connected”);
InputStream input = [Link]();
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String message = [Link]();
[Link](“Received: “ + message);
[Link]();
} catch (IOException ex) {
[Link]();
// Client Program
Import [Link].*;
Import [Link].*;
Public class Client {
Public static void main(String[] args) {
Try (Socket socket = new Socket(“localhost”, 5000)) {
OutputStream output = [Link]();
PrintWriter writer = new PrintWriter(output, true);
[Link](“Hello, Server!”);
[Link]();
} catch (UnknownHostException ex) {
[Link](“Server not found: “ + [Link]());
} catch (IOException ex) {
[Link](“I/O error: “ + [Link]());
```
#### Java Database Connectivity (JDBC)
- **Introduction to JDBC**
- Importance of database connectivity in applications.
- Overview of JDBC API.
- **Connecting to a Database**
- Setting up a database connection.
- Executing SQL queries using JDBC.
```java
Import [Link].*;
Public class JDBCExample {
Public static void main(String[] args) {
String url = “jdbc:mysql://localhost:3306/testdb”;
String user = “root”;
String password = “password”;
Try (Connection connection = [Link](url, user, password)) {
String query = “SELECT * FROM users”;
Statement statement = [Link]();
ResultSet resultSet = [Link](query);
While ([Link]()) {
[Link](“User ID: “ + [Link](“id”));
[Link](“User Name: “ + [Link](“name”));
} catch (SQLException e) {
[Link]();
```
#### JavaFX for GUI Development
- **Introduction to JavaFX**
- Importance of JavaFX in modern GUI development.
- Overview of JavaFX components and layout managers.
- **Creating a Simple JavaFX Application**
- Setting up a JavaFX project.
- Creating a basic user interface with JavaFX.
```java
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Public class JavaFXExample extends Application {
@Override
Public void start(Stage primaryStage) {
Button button = new Button(“Click Me”);
[Link](e -> [Link](“Button Clicked”));
StackPane root = new StackPane();
[Link]().add(button);
Scene scene = new Scene(root, 300, 250);
[Link](“JavaFX Example”);
[Link](scene);
[Link]();
Public static void main(String[] args) {
Launch(args);
```
#### Practical Exercises and Mini-Project
- **Hands-on Coding Exercises**
- Writing programs to demonstrate the use of networking, JDBC, and JavaFX.
- Debugging and testing code, explaining common debugging techniques and tools.
- **Mini-Project: Online Bookstore Application**
- Designing a class structure for an online bookstore application.
- Implementing functionalities like browsing books, adding books to the cart, and checking
out.
```java
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link].*;
Import [Link];
Import [Link];
Class Book {
Private String title;
Private String author;
Public Book(String title, String author) {
[Link] = title;
[Link] = author;
@Override
Public String toString() {
Return title + “ by “ + author;
Public class BookstoreApplication extends Application {
Private List<Book> books = new ArrayList<>();
@Override
Public void start(Stage primaryStage) {
ListView<Book> listView = new ListView<>();
Button loadButton = new Button(“Load Books”);
[Link](e -> loadBooks(listView));
VBox vbox = new VBox(listView, loadButton);
Scene scene = new Scene(vbox, 400, 300);
[Link](“Online Bookstore”);
[Link](scene);
[Link]();
Private void loadBooks(ListView<Book> listView) {
String url = “jdbc:mysql://localhost:3306/bookstore”;
String user = “root”;
String password = “password”;
Try (Connection connection = [Link](url, user, password)) {
String query = “SELECT * FROM books”;
Statement statement = [Link]();
ResultSet resultSet = [Link](query);
[Link]();
While ([Link]()) {
String title = [Link](“title”);
String author = [Link](“author”);
[Link](new Book(title, author));
[Link]().setAll(books);
} catch (SQLException e) {
[Link]();
}
Public static void main(String[] args) {
Launch(args);
```
### Week 6: Java Programming – Advanced Topics and Practical Applications
#### Introduction to Week 6
- **Overview of Week 6 Objectives**
- Exploring advanced Java programming concepts.
- Applying these concepts through practical exercises and projects.
- Enhancing problem-solving skills and coding efficiency.
#### Java Networking
- **Introduction to Networking in Java**
- Importance of networking in modern applications.
- Overview of [Link] package.
- **Working with Sockets**
- Understanding the concept of sockets.
- Creating a simple client-server application using sockets.
```java
// Server Program
Import [Link].*;
Import [Link].*;
Public class Server {
Public static void main(String[] args) {
Try (ServerSocket serverSocket = new ServerSocket(5000)) {
[Link](“Server is listening on port 5000”);
Socket socket = [Link]();
[Link](“Client connected”);
InputStream input = [Link]();
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String message = [Link]();
[Link](“Received: “ + message);
[Link]();
} catch (IOException ex) {
[Link]();
// Client Program
Import [Link].*;
Import [Link].*;
Public class Client {
Public static void main(String[] args) {
Try (Socket socket = new Socket(“localhost”, 5000)) {
OutputStream output = [Link]();
PrintWriter writer = new PrintWriter(output, true);
[Link](“Hello, Server!”);
[Link]();
} catch (UnknownHostException ex) {
[Link](“Server not found: “ + [Link]());
} catch (IOException ex) {
[Link](“I/O error: “ + [Link]());
```
#### Java Database Connectivity (JDBC)
- **Introduction to JDBC**
- Importance of database connectivity in applications.
- Overview of JDBC API.
- **Connecting to a Database**
- Setting up a database connection.
- Executing SQL queries using JDBC.
```java
Import [Link].*;
Public class JDBCExample {
Public static void main(String[] args) {
String url = “jdbc:mysql://localhost:3306/testdb”;
String user = “root”;
String password = “password”;
Try (Connection connection = [Link](url, user, password)) {
String query = “SELECT * FROM users”;
Statement statement = [Link]();
ResultSet resultSet = [Link](query);
While ([Link]()) {
[Link](“User ID: “ + [Link](“id”));
[Link](“User Name: “ + [Link](“name”));
} catch (SQLException e) {
[Link]();
```
#### JavaFX for GUI Development
- **Introduction to JavaFX**
- Importance of JavaFX in modern GUI development.
- Overview of JavaFX components and layout managers.
- **Creating a Simple JavaFX Application**
- Setting up a JavaFX project.
- Creating a basic user interface with JavaFX.
```java
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Public class JavaFXExample extends Application {
@Override
Public void start(Stage primaryStage) {
Button button = new Button(“Click Me”);
[Link](e -> [Link](“Button Clicked”));
StackPane root = new StackPane();
[Link]().add(button);
Scene scene = new Scene(root, 300, 250);
[Link](“JavaFX Example”);
[Link](scene);
[Link]();
Public static void main(String[] args) {
Launch(args);
```
#### Practical Exercises and Mini-Project
- **Hands-on Coding Exercises**
- Writing programs to demonstrate the use of networking, JDBC, and JavaFX.
- Debugging and testing code, explaining common debugging techniques and tools.
- **Mini-Project: Online Bookstore Application**
- Designing a class structure for an online bookstore application.
- Implementing functionalities like browsing books, adding books to the cart, and checking
out.
```java
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link];
Import [Link].*;
Import [Link];
Import [Link];
Class Book {
Private String title;
Private String author;
Public Book(String title, String author) {
[Link] = title;
[Link] = author;
@Override
Public String toString() {
Return title + “ by “ + author;
Public class BookstoreApplication extends Application {
Private List<Book> books = new ArrayList<>();
@Override
Public void start(Stage primaryStage) {
ListView<Book> listView = new ListView<>();
Button loadButton = new Button(“Load Books”);
[Link](e -> loadBooks(listView));
VBox vbox = new VBox(listView, loadButton);
Scene scene = new Scene(vbox, 400, 300);
[Link](“Online Bookstore”);
[Link](scene);
[Link]();
Private void loadBooks(ListView<Book> listView) {
String url = “jdbc:mysql://localhost:3306/bookstore”;
String user = “root”;
String password = “password”;
Try (Connection connection = [Link](url, user, password)) {
String query = “SELECT * FROM books”;
Statement statement = [Link]();
ResultSet resultSet = [Link](query);
[Link]();
While ([Link]()) {
String title = [Link](“title”);
String author = [Link](“author”);
[Link](new Book(title, author));
[Link]().setAll(books);
} catch (SQLException e) {
[Link]();
Public static void main(String[] args) {
Launch(args);
```