Scribd
Upload
12 views7 pages

Java Programming Basics and Concepts

The document provides an overview of Java programming, covering its history, basic concepts, data types, operators, control statements, loops, arrays, strings, methods, object-oriented programming concepts, and exception handling. It also discusses multithreading, thread synchronization, and the Java Collection Framework, detailing core interfaces like Collection, List, Set, and Map. Examples of code snippets illustrate key concepts throughout the document.

Uploaded by

iayushsharm13dec
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
12 views7 pages

Java Programming Basics and Concepts

The document provides an overview of Java programming, covering its history, basic concepts, data types, operators, control statements, loops, arrays, strings, methods, object-oriented programming concepts, and exception handling. It also discusses multithreading, thread synchronization, and the Java Collection Framework, detailing core interfaces like Collection, List, Set, and Map. Examples of code snippets illustrate key concepts throughout the document.

Uploaded by

iayushsharm13dec
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd

JAVA PROGRAMMING

UNIT 1:

1. History of Java

 Developed by Sun Microsystems in 1995 (James Gosling)


 Originally called: Oak
 Platform-independent: Write Once, Run Anywhere (WORA)
 Runs on: JVM (Java Virtual Machine)

2. Basic Concepts

 Java is: Object-Oriented, robust, secure, multithreaded


 Java Program Structure:

public class MyClass {


public static void main(String[] args) {
[Link]("Hello, World!");
}
}

 class → blueprint
 main() → program entry point

3. Data Types
Primitive Types
Type Size Example

byte 1 byte 10

short 2 bytes 1000

int 4 bytes 100000

long 8 bytes 10000000000L

float 4 bytes 10.5f

double 8 bytes 10.5

char 2 bytes 'A'

boolean 1 bit true/false


Type Size Example

Reference Types

 String, Arrays, Objects


 Stored in heap memory, refer to an object

4. Operators

 Arithmetic: + - * / %
 Relational: == != > < >= <=
 Logical: && || !
 Assignment: = += -= *= /= %=
 Unary: ++ --
 Ternary: condition ? true : false

5. Decision Controls / Control Statements

 If Statements:

if(condition) { ... }
if(condition){...} else { ... }

 Switch Statement:

switch(variable) {
case 1: ... break;
default: ...
}

6. Loops

 For Loop:

for(int i=0;i<5;i++){ ... }

 While Loop:

while(condition){ ... }

 Do-While Loop:

do { ... } while(condition);
 Break & Continue: exit or skip iteration

7. Arrays

 Single-Dimensional:

int[] arr = new int[5];


arr[0] = 10;

 Multi-Dimensional:

int[][] matrix = new int[3][3];

 Enhanced For Loop:

for(int x : arr) { ... }

8. Strings

 Immutable objects in Java


 Common Methods: length(), charAt(), substring(), equals(), compareTo(),
concat()

9. Functions / Methods
returnType methodName(parameters) {
// body
}

 Example:

int add(int a, int b){ return a+b; }

 Method Overloading: same name, different parameters


 Scope of Variables:
o Local: inside method
o Instance: inside class, outside method
o Static: shared among all objects

10. OOP Concepts

 Class: blueprint
 Object: instance of class
 Encapsulation: private variables + getters/setters
 Constructor: special method to initialize object
 Destructor: finalize() method (deprecated in modern Java)
 Polymorphism:
o Compile-time: method overloading
o Run-time: method overriding
 Inheritance: extends keyword
 Interface: multiple inheritance possible
 Abstract Class: cannot instantiate, can have abstract methods
 Packages: organize classes (import [Link].*;)

11. Exception Handling

 Try-Catch-Finally

try {
// code
} catch(Exception e) {
// handle
} finally {
// always executes
}

 Throw & Throws: throw exceptions from a method


 Common Exceptions: ArithmeticException, NullPointerException,
ArrayIndexOutOfBoundsException

UNIT 2:

1. Multithreading in Java
Thread Model

 A thread is a lightweight process, smallest unit of execution.


 Multithreading: multiple threads run concurrently in a single program.
 Thread States: New → Runnable → Running → Waiting/Blocked → Terminated

Thread-Supporting Classes and Methods

 Thread Class Methods:


o start() → begins execution
o run() → thread code
o sleep(ms) → pauses thread
o join() → waits for thread to finish
o yield() → gives chance to other threads
o setPriority() → set thread priority
 Runnable Interface: defines run() method to create a thread
Creating Threads

1. Single Thread
class MyThread extends Thread {
public void run() {
[Link]("Thread is running");
}
}

public class Main {


public static void main(String[] args) {
MyThread t = new MyThread();
[Link]();
}
}

2. Multiple Threads (Runnable Interface)


class MyRunnable implements Runnable {
public void run() { [Link]("Runnable thread running"); }
}

public class Main {


public static void main(String[] args) {
Thread t1 = new Thread(new MyRunnable());
Thread t2 = new Thread(new MyRunnable());
[Link]();
[Link]();
}
}

Context Switching

 JVM/OS switches CPU between threads to give illusion of parallelism.


 Happens when threads are waiting, blocked, or preempted.

Thread Synchronization

 Ensures data consistency when multiple threads access shared resources.


 Synchronized Method:

synchronized void display() { ... }

 Synchronized Block:

synchronized(this) { ... }

Inter-Thread Communication

 Methods: wait(), notify(), notifyAll()


 Used for coordination between threads, e.g., producer-consumer problem.
2. Collection Framework in Java
Overview

 Java Collections: store, retrieve, manipulate groups of objects.


 Interfaces and classes to reduce complexity of arrays.

Core Interfaces
Interface Description

Collection Root interface, extended by List, Set

List Ordered, allows duplicates

Set Unordered, no duplicates

Map Key-value pairs, no duplicate keys

Queue FIFO ordering

List Interface

 ArrayList: dynamic array, fast random access


 LinkedList: doubly-linked list, fast insert/delete
 Vector: synchronized, legacy class

Example:

List<Integer> list = new ArrayList<>();


[Link](10);
[Link](20);

Set Interface

 HashSet: unordered, unique elements


 LinkedHashSet: maintains insertion order
 TreeSet: sorted elements

Example:

Set<String> set = new HashSet<>();


[Link]("A");
[Link]("B");
Map Interface

 HashMap: key-value pairs, unordered


 LinkedHashMap: maintains insertion order
 TreeMap: sorted by keys

Example:

Map<Integer, String> map = new HashMap<>();


[Link](1, "One");
[Link](2, "Two");

Common questions

Powered by AI

Abstract classes and interfaces both serve as abstraction mechanisms in Java, but they have distinct uses. An abstract class provides partial implementation shared among derived classes and can contain fields, constructors, and both abstract and concrete methods. Interfaces, by contrast, define a contract that implementing classes must follow without providing any implementation, supporting multiple inheritance of type. While abstract classes are used for closely related classes sharing base behavior, interfaces are preferred for unrelated classes that require certain capabilities .

Java Collections provide a higher level of abstraction compared to arrays, offering a more flexible and easier way to store, retrieve, and manipulate groups of objects. Interfaces like List and Set provide specific functionality; for instance, List allows ordered storage and access to elements, including duplicates, while Set ensures uniqueness of elements. Collections also include many convenient methods for common data operations, improving efficiency and code readability .

In Java, the synchronized keyword can be applied to methods or code blocks to control access to critical sections by locking the object or class, ensuring that only one thread can execute the protected code at a time. This prevents data corruption and ensures thread safety in concurrent applications. However, excessive use of synchronization can lead to thread contention and decreased efficiency due to blocking, requiring careful design to balance safety and performance .

Polymorphism in Java allows objects to be treated as instances of their parent class. Compile-time polymorphism, or method overloading, happens when multiple methods have the same name but different parameters within the same class. An example is defining multiple 'print' methods that take different types of arguments. Runtime polymorphism, or method overriding, occurs when a subclass provides its own implementation of a method declared in its parent class, allowing dynamic method resolution at runtime .

Java achieves platform independence through its 'Write Once, Run Anywhere' paradigm. This is facilitated by the Java Virtual Machine (JVM), which abstracts the underlying hardware and operating system, allowing Java bytecode to be executed on any platform that has a JVM, thus providing consistent behavior across different environments .

Exception handling in Java allows developers to manage runtime errors gracefully, maintaining normal application flow and preventing crashes. By using try-catch-finally blocks, exceptions can be caught and specific actions can be taken to handle them. Common exceptions include ArithmeticException, NullPointerException, and ArrayIndexOutOfBoundsException, which can occur due to arithmetic errors, null object access, and invalid array indexing, respectively .

JVM's context switching allows CPU resources to be shared among multiple threads, maintaining the illusion of parallelism in multithreaded applications. This is critical for balancing loads and improving CPU efficiency. However, frequent context switching can lead to performance overhead because saving and restoring thread state consumes system resources and time, potentially degrading application performance if not managed carefully .

The 'public static void main(String[] args)' method is the entry point for any standalone Java application. It is called by the Java runtime environment and must be declared public so it can be accessible from outside the class, static so it can be executed without creating an instance of the class, and it accepts a string array argument to handle command-line arguments .

Java is considered robust due to several key features: it is object-oriented which helps in modularizing code and building reusable components; it provides strict compile-time error checking and runtime exception handling which enhances stability; it supports garbage collection for automatic memory management preventing memory leaks; and it includes strong type-checking mechanisms that reduce errors .

Thread synchronization in Java ensures that multiple threads can safely access shared resources, preventing data inconsistency and race conditions. It achieves this through synchronized methods or blocks, which restrict access to a resource by allowing only one thread at a time. However, synchronization can lead to reduced performance due to increased overhead, potential deadlocks, and reduced concurrency .

You might also like