1 Variable and
Operator
2 Control
Statement
3 Oops Concept
4 Collections
5 Exceptions and
Others
1 Variable and Operator
a variable is a named container that stores data that can be manipulated and used in a program and managing different types of data, such as numbers, text, and objects. They serve several important purposes in Java and other programming languages:
Storage: Variables allow you to store data in memory. This data can be numbers, characters, objects, or any other data type supported by Java.
Manipulation: You can
perform operations on the data stored in variables.
For example, you can add, subtract, multiply, and divide
numbers, concatenate strings, and perform various other computations.
Referencing: Variables
provide a way to reference and access data.
You can use the variable name to retrieve and modify the data it holds.
Control flow: Variables
are essential for controlling the flow of a program.
They are used in conditional statements (if-else),
loops (for, while), and other control structures to make decisions and perform
actions based on the data they hold.
Organization: Variables help organize and structure your code. They give names to pieces of data, making your code more readable and self-explanatory.
In Java, variables are declared with a specific data type, and they can be categorized into the following types:
Primitive Data Types: These
are the basic data types provided by Java, and they store simple values.
Examples include int, double, char, and boolean.
java
int age = 30;
double price = 19.99;
char grade = 'A';
boolean isJavaFun = true;
Reference Data Types:
These variables store references to objects.
Examples include class instances, arrays, and interfaces.
Reference variables do not store the actual object but rather a reference to
where the object is stored in memory.
java String name = "Alice";
List<String> namesList = new
ArrayList<>();
Arrays: Arrays are a
special type of variable used to store multiple values of the same data type in
a structured way.
java int[] numbers = {1, 2, 3, 4, 5};
Custom Objects: You can
create your own custom classes and use objects of those classes as variables to
store more complex data.
java class Person {
String name;
int age;
}
Person person1 = new Person();
person1.name = "Bob";
person1.age = 25;
Variables in Java must be declared before they can be
used, and
they have a scope that determines where in the
program they can be accessed.
Proper use of variables is essential for writing
maintainable and efficient Java code.
Java Variables
**********************************************
In programming, an operator is a symbol
or a keyword that represents an operation or action to manipulate and process
data in various ways, depending on the programming language.
They allow you to build complex algorithms, make
decisions, and manipulate data. By using operators effectively, you can create
efficient and powerful code that accomplishes various tasks, from simple
calculations to complex data processing and decision-making.
Here is a list of common operators used in programming:
Arithmetic Operators:
+ (Addition)
-
(Subtraction)
*
(Multiplication)
/ (Division)
% (Modulus -
remainder after division)
Comparison Operators:
== (Equal to)
!= (Not equal
to)
< (Less
than)
> (Greater
than)
<= (Less
than or equal to)
>= (Greater
than or equal to)
Logical Operators:
&&
(Logical AND)
|| (Logical
OR)
! (Logical
NOT)
Assignment Operators:
= (Assignment)
+= (Add and
assign)
-= (Subtract
and assign)
*= (Multiply
and assign)
/= (Divide and
assign)
%= (Modulus
and assign)
Increment and Decrement
Operators:
++ (Increment
by 1)
-- (Decrement
by 1)
Conditional (Ternary) Operator: ? : (Ternary conditional operator for conditional assignment)
********************************************************
2 Control Statement
In Java, control statements are constructs that enable
you to control the flow of a program's execution. They allow you to make
decisions, repeat actions, and manage the order in which statements are
executed. Control statements are fundamental to writing dynamic and responsive
programs. Here are the main types of control statements in Java and their
purposes:
Conditional Statements:
if Statement: The if statement is used to
execute a block of code if a specified condition is true. You can also use
else and else if clauses to handle alternative conditions.
java if (condition) { // Code to execute if condition is true
} else if (anotherCondition) { // Code to execute if anotherCondition is true
} else { // Code to execute if neither condition is true}
Switch Statement: The switch statement is used for multi-way branching. It tests an expression against multiple case values and executes code based on the first matching case. It is an alternative to long chains of if-else statements.
java switch (expression) {
case value1: // Code to execute if expression matches value1 break;
case value2: // Code to execute if expression matches value2 break;
default: // Code to execute if no cases match}
Looping Statements:
for Loop: The for
loop is used to execute a block of code a specific number of times. It
typically includes an initialization, a condition, and an increment/decrement
operation.
java for (initialization; condition; increment/decrement) {
// Code to execute repeatedly as long
as the condition is true
}
while Loop: The while
loop is used to repeatedly execute a block of code as long as a specified
condition is true.
java while (condition) { // Code to execute repeatedly as long as the condition is true}
do-while Loop: The
do-while loop is similar to the while loop but ensures that the block of code
is executed at least once before checking the condition.
java do { // Code to execute at least once and then repeatedly as long as the condition is true
} while (condition);
Branching Statements:
break Statement: The break
statement is used to exit a loop prematurely or to terminate the execution of a
switch statement.
java for (int i = 0; i < 10; i++) {
if (i == 5) { break; // Exit the loop when i is 5 }
}
Continue Statement: The
continue statement is used to skip the current iteration of a loop and continue
with the next iteration.
for (int i = 0; i < 10; i++) { if (i == 5)
{continue; // Skip the rest of the loop's body and
continue to the next iteration }
}
Control statements are essential for creating programs
that can adapt to different situations, make decisions based on input, and
perform repetitive tasks efficiently. They enable you to control the flow of
execution, which is crucial for building versatile and functional software.
Java If...Else (Conditions)
Java Switch
Java Loops
Oops Concept:
1. Classes and Objects:
In Java, you define a class with attributes (fields) and
behaviors (methods), and then create objects based on that class. Here's a
simple example of a Car class and its usage:
java
Copy code
class Car {
String make;
String model;
int year;
void start() { System.out.println("The car is starting.");
}
void stop() { System.out.println("The car is stopping.");
}
}
public class CarExample {
public static void main(String[] args)
{
Car myCar =
new Car();
myCar.make =
"Toyota";
myCar.model =
"Camry";
myCar.year =
2020;
myCar.start();
myCar.stop(); }
}
In this example, we define a Car class with fields make,
model, and year, as well as methods start() and stop(). We then create an
instance of the Car class, set its attributes, and call its methods.
2. Encapsulation:
Encapsulation is about restricting direct access to some
of an object's components and providing controlled access through methods. In
Java, you often use getters and setters for this purpose. Here's how you can
encapsulate the Car class:
java Copy code
class Car {
private String make;
private String model;
private int year;
public void setMake(String make) { this.make = make;
}
public String getMake() {
return make; } // Similar getters and setters for model and year
}
In this example, we've made the make, model, and year
fields private and provided public setter and getter methods to control access
to these fields.
3. Inheritance:
Inheritance allows you to create a new class that's based
on an existing class. Here's an example using inheritance in Java:
java Copy code
class Vehicle {
String type;
void move() {
System.out.println("The vehicle is moving."); }
}
class Car extends Vehicle {
int wheels;
void honk() {
System.out.println("Honk! Honk!"); }
}
public class InheritanceExample {
public static void main(String[] args)
{
Car myCar =
new Car();
myCar.type =
"Sedan";
myCar.wheels =
4;
myCar.move();
myCar.honk(); }
}
In this example, the Car class inherits from the Vehicle
class, gaining its attributes and methods. It demonstrates the "is-a"
relationship where a car is a type of vehicle.
4. Polymorphism:
Polymorphism allows objects of different classes to be
treated as objects of a common superclass.
Abstraction and Interfaces are essential object-oriented
programming concepts in Java that help in achieving abstraction and defining
contracts for classes to follow. Let's explore both concepts with
examples:
Abstraction:
Abstraction involves simplifying complex reality by
modeling classes based on their essential attributes and behaviors while hiding
unnecessary details. In Java, you can achieve abstraction using abstract
classes. Here's an example of abstraction using an abstract class:
java
Copy code
abstract class Shape {
abstract double area();
abstract double parameter();}
class Circle extends Shape {
private double radius;
public Circle(double radius) {
this.radius =
radius; }
@Override
double area() {
return Math.PI
* radius * radius;
}
@Override
double perimeter() {
return 2 *
Math.PI * radius; }
}
class Rectangle extends Shape {
private double length;
private double width;
public Rectangle(double length, double
width) {
this.length =
length;
this.width =
width; }
@Override
double area() {
return length
* width; }
@Override
double perimeter() {
return 2 *
(length + width); }
}
public class AbstractionExample {
public static void main(String[] args)
{
Shape circle =
new Circle(5.0);
Shape
rectangle = new Rectangle(4.0, 6.0);
System.out.println("Circle Area: " + circle.area());
System.out.println("Circle Perimeter: " + circle.perimeter());
System.out.println("Rectangle Area: " + rectangle.area());
System.out.println("Rectangle Perimeter: " +
rectangle.perimeter()); }
}
In this example, the Shape class is an abstract class
that defines two abstract methods: area() and perimeter(). The Circle and
Rectangle classes inherit from Shape and provide concrete implementations for
these methods. This abstraction allows you to work with shapes without worrying
about their specific details.
Interface:
An interface defines a contract that classes must adhere
to by implementing its methods. In Java, you create interfaces using the
interface keyword. Here's an example of an interface:
java
Copy code
interface Vehicle {
void start();
void stop();}
class Car implements Vehicle {
@Override
public void start() {
System.out.println("Car started.");
}
@Override
public void stop() {
System.out.println("Car stopped."); }
}
class Bicycle implements Vehicle {
@Override
public void start() {
System.out.println("Bicycle started pedaling.");
}
@Override
public void stop() {
System.out.println("Bicycle stopped."); }
}
public class InterfaceExample {
public static void main(String[] args)
{
Vehicle car =
new Car();
Vehicle
bicycle = new Bicycle();
car.start();
car.stop();
bicycle.start();
bicycle.stop(); }
}Method overriding is a way to achieve polymorphism.
Here's an example:
java
Copy code
class Animal {
void makeSound() {
System.out.println("The animal makes a sound."); }
}
class Dog extends Animal {
@Override
void makeSound() {
System.out.println("The dog barks."); }
}
class Cat extends Animal {
@Override
void makeSound() {
System.out.println("The cat meows."); }
}
public class PolymorphismExample {
public static void main(String[] args)
{
Animal myDog =
new Dog();
Animal myCat =
new Cat();
myDog.makeSound(); // Calls Dog's makeSound method
myCat.makeSound(); // Calls Cat's makeSound method }
}
In this example, we have a common Animal class with a
makeSound method.
The Dog and Cat classes override this method to provide
their specific sound.
We then create objects of the Dog and Cat classes
but refer to them using the common Animal type, demonstrating
polymorphism.
These examples illustrate the core OOP concepts in Java,
providing a foundation for building complex and structured software systems.
Java Methods
Java Classes and Objects
Java Modifiers
Java Encapsulation
Java Packages
Java Inheritance
Java Inner Classes