Code With Clarity

2025-12-14T00:45:00.000-08:00

How to Master JAVA without wasting Time & Money in Learning C/C++

Most students are told:
👉 “First learn C, then C++, then Java.”

Truth?
That path wastes years, confuses beginners, and kills confidence.

If your goal is JAVA Developer / Backend / Spring Boot, you don’t need C or C++.

What you actually need:

✔ Core Java (OOP + Clarity)
✔ Problem-solving in Java
✔ Real project mindset
✔ Industry-relevant learning path

If you’re:

Confused where to start
Stuck watching random YouTube videos
Spending money on courses but not progressing

🚀 Book Your Spot!

⭐ What My Students Say ⭐

Real feedback from students who built their Java careers with clarity.

🚀 Book Your Spot!

🎥 Student Video Feedback

Hear directly from students who gained clarity and confidence.

Ambe Kalawati — Full-Stack Developer

Anjali — Full-Stack Developer

Anu — Full-Stack Developer

🚀 Book Your Spot!

Trigger

2020-01-27T23:12:00.000-08:00

In this lesson, we will introduce you to MySQL triggers.

By definition, a MySQL trigger is a type of stored program, associated with a table, that will be activated automatically once a specific event related to the table of association occurs.
This event must be related to one of the following three DML statements: INSERT, UPDATE, or DELETE.
Therefore, triggers are a powerful and handy tool that professionals love to use where database consistency and integrity are concerned.
Moreover, to any of these DML statements, one of two types of triggers can be assigned – a "before", or an "after" trigger. In other words, a trigger is a MySQL object that can “trigger” a specific action or calculation ‘before’ or ‘after’ an INSERT, UPDATE or DELETE statement has been executed. For instance, a trigger can be activated before a new record is inserted into a table, or after a record has been updated.

Perfect! Let’s execute some code:
First, in case you are just starting Workbench, select “Employees” as your default database.

USE employees;
Then, execute a COMMIT statement, because the triggers we are about to create will make some changes to the state of the data in our database. At the end of the exercise, we will ROLLBACK up to the moment of this COMMIT.
COMMIT;

We said triggers are a type of stored program. Well, one could say the syntax resembles that of stored procedures, couldn’t they?

BEFORE INSERT
DELIMITER $$
CREATE TRIGGER before_salaries_insert
BEFORE INSERT ON salaries
FOR EACH ROW
BEGIN
IF NEW.salary < 0 THEN
SET NEW.salary = 0;
END IF;
END $$
DELIMITER ;
After stating we want to CREATE a TRIGGER and then indicating its name, we must indicate its type and the name of the table to which it will be applied. In this case, we devised a “before” trigger, which will be activated whenever new data is inserted in the “Salaries” table.

Then, an interesting phrase follows – “for each row”. It designates that before the trigger is activated, MySQL will perform a check for a change of the state of the data on all rows. In our case, a change in the data of the “Salaries” table will be caused by the insertion of a new record.

Within the BEGIN-END block, you can see a piece of code that is easier to understand if you just read it without focusing on the syntax.

The body of this block acts as the core of the “before_salaries_insert” trigger. Basically, it says that if the newly inserted salary is of negative value, it will be set as 0.
/*
IF NEW.salary < 0 THEN
SET NEW.salary = 0;
END IF;
*/

From a programmer’s perspective, there are three things to note about these three lines of code.
First, especially for those of you who are familiar with some programming, this is an example of a conditional. The IF statement starts the conditional block. Then, if the condition for negative salary is satisfied, one must use the keyword THEN before showing what action should follow. The operation is terminated by the END IF phrase and a semi-colon.

The second thing to be noted here is even more interesting. That’s the use of the keyword NEW. In general, it refers to a row that has just been inserted or updated. In our case, after we insert a new record, “NEW dot salary” will refer to the value that will be inserted in the “Salary” column of the “Salaries” table.
The third part of the syntax regards the SET keyword. As you already know, it is used whenever a value has to be assigned to a certain variable. Here, the variable is the newly inserted salary, and the value to be assigned is 0.

Let’s execute this query. BEFORE INSERT
DELIMITER $$
CREATE TRIGGER before_salaries_insert
BEFORE INSERT ON salaries
FOR EACH ROW
BEGIN
IF NEW.salary < 0 THEN
SET NEW.salary = 0;
END IF;
END $$
DELIMITER ;

Let’s check the values of the “Salaries” table for employee 10001.
SELECT
*
FROM
salaries
WHERE
emp_no = '10001';
Now, let’s insert a new entry for employee 10001, whose salary will be a negative number.
INSERT INTO salaries VALUES ('10001', -92891, '2010-06-22', '9999-01-01');
Let’s run the same SELECT query to see whether the newly created record has a salary of 0 dollars per year.
SELECT
*
FROM
salaries
WHERE
emp_no = '10001';
You can see that the “before_salaries_insert” trigger was activated automatically. It corrected the value of minus 92,891 we tried to insert.
Now, let’s look at a BEFORE UPDATE trigger. The code is similar to one of the triggers we created above, with two substantial differences.
BEFORE UPDATE
DELIMITER $$
CREATE TRIGGER trig_upd_salary
BEFORE UPDATE ON salaries
FOR EACH ROW
BEGIN
IF NEW.salary < 0 THEN
SET NEW.salary = OLD.salary;
END IF;
END $$
DELIMITER ;

First, we indicated that this will be a BEFORE UPDATE trigger.
/*
BEFORE UPDATE ON salaries
*/
Second, in the IF conditional statement, instead of setting the new value to 0, we are basically telling MySQL to keep the old value. Technically, this is achieved by setting the NEW value in the “Salary” column to be equal to the OLD one. This is a good example of when the OLD keyword needs to be used.
/*
IF NEW.salary < 0 THEN
SET NEW.salary = OLD.salary;
END IF;
*/
Create the “before_salaries_update” trigger by executing the above statement.

Then, run the following UPDATE statement, with which we will modify the salary value of employee 10001 with another positive value.
UPDATE salaries
SET
salary = 98765
WHERE
emp_no = '10001'
AND from_date = '2010-06-22';
Execute the following SELECT statement to see that the record has been successfully updated.
SELECT
*
FROM
salaries
WHERE
emp_no = '10001'
AND from_date = '2010-06-22';

Now, let’s run another UPDATE statement, with which we will try to modify the salary earned by 10001 with a negative value, minus 50,000.
UPDATE salaries
SET
salary = - 50000
WHERE
emp_no = '10001'
AND from_date = '2010-06-22';
Let’s run the same SELECT statement to check if the salary value was adjusted.
SELECT
*
FROM
salaries
WHERE
emp_no = '10001'
AND from_date = '2010-06-22';
No, it wasn’t. Everything remained intact. So, we can conclude that only an update with a salary higher than zero dollars per year would be implemented.
All right. For the moment, you know you have created only two triggers. But how could you prove that to someone who is seeing your script for the first time? Well, in the ‘info’ section of the “employees” database, you can find a tab related to triggers. When you click on its name, MySQL will show you the name, the related event, table, timing, and other characteristics regarding each trigger currently in use.
Let’s introduce you to another interesting fact about MySQL. You already know there are pre-defined system variables, but system functions exist too! System functions can also be called built-in functions. Often applied in practice, they provide data related to the moment of the execution of a certain query.
For instance, SYSDATE() delivers the date and time of the moment at which you have invoked this function.
SELECT SYSDATE();
Another frequently employed function, “Date Format”, assigns a specific format to a given date. For instance, the following query could extract the current date, quoting the year, the month, and the day.
SELECT DATE_FORMAT(SYSDATE(), '%y-%m-%d') as today;

Of course, there are many other ways in which you could format a date; what we showed here was just an example. So, using system functions seems cool, doesn’t it?
You already know how to work with the syntax that allows you to create triggers.
As an exercise, try to understand the following query. Technically, it regards the creation of a more complex trigger. It is of the size that professionals often have to deal with.

DELIMITER $$
CREATE TRIGGER trig_ins_dept_mng
AFTER INSERT ON dept_manager
FOR EACH ROW
BEGIN
DECLARE v_curr_salary int;

SELECT
MAX(salary)
INTO v_curr_salary FROM
salaries
WHERE
emp_no = NEW.emp_no;

IF v_curr_salary IS NOT NULL THEN
UPDATE salaries
SET
to_date = SYSDATE()
WHERE
emp_no = NEW.emp_no and to_date = NEW.to_date;

INSERT INTO salaries
VALUES (NEW.emp_no, v_curr_salary + 20000, NEW.from_date, NEW.to_date);
END IF;
END $$
DELIMITER ;

After you are sure you have understood how this query works, please execute it and then run the following INSERT statement.
INSERT INTO dept_manager VALUES ('111534', 'd009', date_format(sysdate(), '%y-%m-%d'), '9999-01-01');

SELECT the record of employee number 111534 in the ‘dept_manager’ table, and then in the ‘salaries’ table to see how the output was affected.
SELECT
*
FROM
dept_manager
WHERE
emp_no = 111534;

SELECT
*
FROM
salaries
WHERE
emp_no = 111534;

Conceptually, this was an ‘after’ trigger that automatically added $20,000 to the salary of the employee who was just promoted as a manager. Moreover, it set the start date of her new contract to be the day on which you executed the insert statement.
Finally, to restore the data in the database to the state from the beginning of this lecture, execute the following ROLLBACK statement.
ROLLBACK;

SQL Query

2020-01-25T08:52:00.000-08:00

Please download the script from the GitHub.
Schema

Database-Schema

JOINS

2020-01-21T23:54:00.000-08:00

The SQL tool that allows us to construct a relationship between objects.
A join shows a result set, containing fields derived from two or more tables.
We must find a related column from the two tables that contain the same type of data.
We will be free to add columns from these two tables to our output the columns you use to relate tables must represent the same object, such as id.
The tables you are considering need not be logically adjacent

Types of joins
INNER JOIN = JOIN
LEFT JOIN = LEFT OUTER JOIN
RIGHT JOIN = RIGHT OUTER JOIN
CROSS JOIN

INNER JOIN
Extract only records in which the values in the related columns match. Null values, or values appearing in just one of the two tables and not appearing in the other, are not displayed.
Only non-null matching values are in play. And what if such matching values did not exist?
Simply, the result set will be empty. There will be no link between the two tables.
Syntax
SELECT
table_1.column_name(s), table_2.column_name(s)
FROM
table_1
JOIN

table_2 ON table_1.column_name = table_2.column_name;
LEFT JOIN
All matching values of the two tables and all values from the left table that match no values from the right table.
When working with left joins, the order in which you join tables matters.
Left joins can deliver a list with all records from the left table that do not match any rows from the right table.
Syntax
SELECT
table_1.column_name(s), table_2.column_name(s)
FROM
table_1
LEFT JOIN

table_2 ON table_1.column_name = table_2.column_name;
RIGHT JOIN
Their functionality is identical to LEFT JOINs, with the only difference being that the direction of the operation is inverted.
When applying a RIGHT JOIN, all the records from the right table will be included in the result set
values from the left table will be included only if their linking column contains a value coinciding, or matching, with a value from the linking column of the right table
Syntax
SELECT
table_1.column_name(s), table_2.column_name(s)
FROM
table_1
RIGHT JOIN

table_2 ON table_1.column_name = table_2.column_name;

Note: LEFT and RIGHT joins are perfect examples of one to many relationships
UNION ALL
Used to combine a few SELECT statements in a single output you can think of it as a tool that allows you to unify tables. We have to select the same number of columns from each table.
These columns should have the same name, should be in the same order, and should contain related data types.
SQL SYNTAX
SELECT
N columns
FROM
table_1
UNION ALL SELECT
N columns
FROM
table_2;
Join more than two tables
SELECT
e.first_name,
e.last_name,
e.hire_date,
m.from_date,
d.dept_name
FROM
employees e
JOIN
dept_manager m ON e.emp_no = m.emp_no
JOIN
departments d ON m.dept_no = d.dept_no;
Here employees, dept_manager and departments.

UNION vs UNION ALL
When uniting two identically organized tables

UNION displays only distinct values in the output whereas UNION ALL retrieves the duplicates as well.
UNION uses more MySQL resources (computational power and storage space) whereas UNION ALL uses less MySQL resources.

Looking for better results: use UNION
Seeking to optimize performance: opt for UNION ALL
SUBQUERY

Queries embedded in a query
subqueries = inner queries = nested queries = inner select
They are part of another query, called an outer query(outer select) a subquery should always be placed within parentheses.
The SQL engine starts by running the inner query then it uses its returned output, which is intermediate, to execute the outer query.
The subquery may return a single value(a scalar), single row, single column, or an entire table
you can have a lot more than one subquery in your outer query it is possible to nest inner queries within other inner queries
In that case, the SQL engine would execute the innermost query first, and then each subsequent query, until it runs the outermost query last

Select the second highest salary of the employee.

select e1.* from employee e1 where 1 = (select count(distinct salary) from employee e2 where e2.salary>e1.salary);
Next Topic: Stored Routines

Stored Routines

2020-01-21T23:03:00.005-08:00

Routine in a context other than a computer, a usual, fixed action, or series of actions, repeated periodically.
Stored routine
An SQL statement, or a set of SQL statements, that can be stored on the database server
Whenever a user needs to run the query in question, they can call, reference, or invoke the routine.
Types of Store routines
1. Stored procedures
2. functions = user define functions not built-in functions like aggregate function ,date function
The MySQL Syntax for Stored Procedures
DELIMITER $$
CREATE or replace PROCEDURE procedure_name()
BEGIN
SQL QUERY
END$$
DELIMITER; From this moment on, $$ will not act as a delimiter.
How can you call the Stored Procedure?
call employees.select_employees();
call employees.select_employees;
call select_employees();
call select_employees;
Here employees is the database name and select_employees is the stored procedure name.
Stored Procedures with an Input Parameter
A stored routine can perform a calculation that transforms an input value in output value.
Stored procedures can take an input value and then use it in the query, or queries, written in the body of the procedure, this value is represented by the IN parameter.
For example:
DELIMITER $$
CREATE PROCEDURE procedure_name
(in parameter)
BEGIN
SELECT * FROM employees
LIMIT 1000;
END$$
DELIMITER ;
After that calculation is ready, a result will be returned.
Stored Procedures with an Output Parameter
DELIMITER $$
CREATE PROCEDURE procedure_name
(in parameter, out parameter)
BEGIN
SELECT * FROM employees
LIMIT 1000;
END$$
DELIMITER ;
Note :
Output Parameter: It will represent the variable containing the output value of the operation executed by the query of the stored procedure.
Every time you create a procedure containing both an IN and an OUT parameter, remember that you must use the SELECT INTO structure in the query of this object’s body.
For Example
DELIMITER $$
CREATE PROCEDURE emp_info(in p_first_name varchar(255), in p_last_name varchar(255), out p_emp_no integer)
BEGIN
SELECT
e.emp_no
INTO p_emp_no FROM
employees e
WHERE
e.first_name = p_first_name
AND e.last_name = p_last_name;
END$$
DELIMITER ;
Variables
when you are defining a program, such as a stored procedure, for instance, you can say you are using parameters
Parameters are a more abstract term
Once the structure has been solidified, then it will be applied to the database. The input value you insert is typically referred to as the argument, while the obtained output value is stored in a variable.
IN-OUT parameters
input = output
User-Defined Functions in MySQL
DELIMITER $$
CREATE FUNCTION function_name(parameter data_type) RETURNS data_type
DECLARE variable_name data_type
BEGIN
SELECT …
RETURN variable_name
END$$
DELIMITER ;
Note :
Parameters: Here you have no OUT parameters to define between the parentheses after the object’s name, all parameters are IN, and since this is well known, you need not explicitly indicate it with the word, ‘IN’.
Although there are no OUT parameters, there is a return value
It is obtained after running the query contained in the body of the function.
How we can call the function in MySQL
SELECT function_name(input_value);

Difference between Stored Procedure and User-defined Function

Stored Procedure	User-defined function
It doesn’t return a value.	Returns a value.
CALL Procedure;	SELECT function;
It can have multiple OUT parameters.	It can return a single value only.
You can use SELECT, INSERT, UPDATE, DELETE with stored procedures.	But you can use only select statement with function.
You can’t include the procedure in a SELECT statement.	You can easily include function as a column in a SELECT statement.

Next Topic: VIEWS

MySQL Index

2020-01-21T22:34:00.002-08:00

The index of table functions as the index of a book
Data is taken from a column of the table and is stored in a certain order in a distinct place called an index.
Your datasets will typically contain 100,000+ or even 1,000,000+ records the larger a database is, the slower the process of finding the record or records you need.
We can use an index that will increase the speed of searches related to a table
Apply the index on large datasets don't apply the index on small datasets otherwise the costs of having an index might be higher than the benefits

Syntax to create an Index
CREATE INDEX index_name
ON table_name (column_1, column_2, …);

Note: The parentheses serve us to indicate the column names on which our search will be based.
These must be fields from your data table you will search frequently.
For example
CREATE INDEX i_hire_date ON employees(hire_date);

Composite Indexes
Applied to multiple columns, not just a single one carefully pick the columns that would optimize your search.
Primary and unique keys are MySQL indexes they represent columns on which a person would typically base their search.

Views

2020-01-21T22:16:00.002-08:00

A virtual table whose contents are obtained from an existing table or tables called base tables.
The view itself does not contain any real data; the data is physically stored in the base table.
The view simply shows the data contained in the base table.
Acts as a dynamic table because it instantly reflects data and structural changes in the base table.
Don’t forget they are not real, physical data sets, meaning we cannot insert or update the information that has already been extracted. They should be seen as temporary virtual data tables retrieving information from base tables

Syntax to create a view in MySQL
CREATE OR REPLACE VIEW view_name AS
SELECT
column_1, column_2,… column_n
FROM
table_name;

For example:
CREATE OR REPLACE VIEW v_dept_emp_latest_date AS
SELECT
emp_no, MAX(from_date) AS from_date, MAX(to_date) AS to_date
FROM
dept_emp
GROUP BY emp_no;

A view acts as a shortcut for writing the same SELECT statement every time a new
the request has been made

How to call the view in MySQL
SELECT * FROM employees.dept_emp_latest_date;
Note: In the above query employees is the database name and dept_emp_latest_date is the view name.

Benefits of Views
Saves a lot of coding time.
Occupies no extra memory

Next Topic: MySQL INDEX

SQL Data Type

2020-01-06T06:13:00.005-08:00

String Data Type

String Data Type		Storage/ MAX_SIZE(Byte)	Example	Remark
Character	CHAR	Fixed/255	CHAR(5)	50% faster
Variable character	VARCHAR	Variable/65,535	VARCHAR(5)	a lot more responsive to the data value inserted
ENUM (enumeration)	ENUM		ENUM(‘M’,’F’)	MySQL will show an error if you attempt to insert any value different from "M" or "F"

Numeric Data Type
Integer
Fixed-point
Floating-point

Integer
Integer data types are ‘signed’ by default.
If you want to use a range containing only positive, ‘unsigned’ values, you would have to specify this in your query.

Numeric Data Type	Size(byte)	MIN_VALUE (signed/unsigned)	MIN_VALUE (signed/unsigned)
TINYINT	1	-128	127
TINYINT	1	0	255
SMALLINT	2	-32,768	32,767
SMALLINT	2	0	65,535
MEDIUMINT	3	-8,388,608	8,388,607
MEDIUMINT	3	0	16,777,215
INT	4	-2,147,483,648	2,147,483,647
INT	4	0	4,294,967,295
BIGINT	8	-9,223,372,036,854,775,808	9,223,372,036,854,775,807
BIGINT	8	0	18,446,744,073,709,551,615

Fixed-point
DECIMAL
NUMERIC
DECIMAL(P, S)
e.g. DECIMAL(5,3)
10.523, here precision is 5 and scale is 3.
367.875, here precision is 6 and scale is 3

Floating-point

Floating-Point Data Type	Size(byte)	Precision	Max number of digits
FLOAT	4	Single	23
DOUBLE	8	Double	53

Next Topic: JOINS

Introduction to SQL

2020-01-06T05:41:00.000-08:00

Structure Query Language: It is a tool which is used to communicate with the database
Types of SQL statements
1. Data Definition Language(DDL)
e.g. CREATE, ALTER, DROP, RENAME, TRUNCATE
2. Data Manipulation Language(DML)
e.g. SELECT, INSERT, UPDATE, DELETE
3. Data Control Language(DCL)
e.g. GRANT & REVOKE
4. Transaction Control Language(TCL)
e.g. COMMIT ROLLBACK

Data Definition Language(DDL)
A set of statements that allow the user to define or modify data structures and objects, such as tables.

The CREATE statement
It is used for creating entire databases and database objects like tables.
How to create a database in MySQL?
CREATE DATABASE sales;
How to create a table in SQL.
CREATE TABLE <table_name>(
<col_name> <data_type>
<col2_name> <data_type>);

For example:
CREATE TABLE sales (
purchase_number INT,
customer_id INT,
item_code VARCHAR(10)
);

The ALTER statement
It is used when altering existing objects

ALTER TABLE sales
ADD COLUMN date_of_purchase DATE;

ALTER TABLE sales
ADD PRIMARY KEY(purchase_number);

ALTER TABLE sales
ADD UNIQUE KEY (item_code);

ALTER TABLE sales
DROP INDEX item_code;

ALTER TABLE sales
CHANGE COLUMN customer_id customer_id INT DEFAULT 0;

ALTER TABLE sales
CHANGE customer_id cust_id INT;

ALTER TABLE sales
MODIFY cust_id INT NOT NULL;

The DROP statement
It is used for deleting a database object.
DROP TABLE sales;

The RENAME statement
It allows you to rename an object.
RENAME TABLE sales TO sale;

The TRUNCATE statement
Instead of deleting an entire table through DROP, we can also remove its data and continue to have the table as an object in the database.
TRUNCATE TABLE customers;

Data Manipulation Language (DML)
Its statements allow us to manipulate the data in the tables of a database

The SELECT statement
It is used to retrieve data from database objects, like tables
SELECT * FROM sales;

The INSERT statement
It is used to insert data into tables
INSERT INTO… VALUES…;
INSERT INTO sales (purchase_number, date_of_purchase) VALUES(1, ‘2017-10-11’);
INSERT INTO sales VALUES(1, ‘2017-10-11’);

The UPDATE statement
It allows you to renew existing data from your tables.

UPDATE sales
SET date_of_purchase = '2017-12-12'
WHERE purchase_number = 1;

The DELETE statement
With DELETE, you can specify precisely what you would like to be removed functions similarly to the TRUNCATE statement

TRUNCATE vs. DELETE
TRUNCATE allows us to remove all the records contained in a table whereas
with DELETE, you can specify precisely what you would like to be removed.

DELETE FROM sales;
TRUNCATE TABLE sales;

DELETE FROM sales
WHERE
purchase_number = 1;

Next Topic: SQL DATA TYPE

JDBC Statements

2020-01-03T11:00:00.002-08:00

Statement
PreparedStatement
CallableStatement
1.Statement
Statement is an interface available in java.sql package.
Subclass of Statement interface is provided by Driver vendor. You can create the Statement object using the following methods of Connection interface.
public Statement createStatement();
public Statement createStatement(int,int);
public Statement createStatement(int,int,int);
You can call one of the following methods on Statement object to submit the SQL statement to Database.
public int executeUpdate(String sql);
public ResultSet executeQuery(String sql);
public boolean execute(String sql);

public int executeUpdate(String sql)
When you want to submit INSERT or UPDATE or DELETE SQL statements then use executeUpdate() method which returns the number of records inserted or updated or deleted.

public ResultSet executeQuery(String sql)
When you want to submit SELECT SQL statements the use executeQuery() method which returns the ResultSet object contains the records returned by the SELECT statement.

public boolean execute(String sql)
When you want to submit INSERT, UPDATE, DELETE, SELECT SQL statements then use execute() method which returns the boolean value.
If the returned value is true which means that SELECT SQL statement is submitted and the ResultSet object is created. Use the following method of statement to get the ResultSet object
public ResultSet getResultSet();
If the returned value is false which means that INSERT, UPDATE or DELETE SQL statement is submitted and the integer number is available which represents the number of records
inserted, updated or deleted. Use the following method of Statement to get the integer number available
public int getUpdateCount();
Using the single Statement object, you can submit any type of SQL statement and any number of SQL statements.
For example:
Statement st = con.createStatement();
String sql1 = "insert...";
String sql2 = "update...";
String sql3 = "delete...";
String sql4 = "select...";
boolean b1 = st.execute(sql1);
int x = st.executeUpdate(sql2);
int y = st.executeUpdate(sql3);
ResultSet rs = st.executeQuery(sql4);
When you submit the SQL statement using Statement object then SQL statement will compiled and executed every time.
Total time = req.time + compile time + execution time + res.time
= 5ms + 5ms + 5ms + 5ms =20ms.
1 SQL stmt = 20ms.
100 SQL stmts = 2000ms.
When you provide dynamic values for the SQL statement then you need to use concatination operator, Formatter or format() of String class etc to format the query.
int sid =101;
String name = "Shail";
String email= "shail@gmail.com"
long phone = 1234567890;
String sql ="insert into student values(" +sid+ ","+name+","+email+","+phone+")";
String sql = String.format("insert into student values(%d,'%s','%s',%d)",sid,name,email,phone);
Formatter fmt = new Formatter();
String sql = fmt.format("insert into student values(%d,'%s','%s',%d)",sid,name,email,phone).toString();

2.PreparedStatement
PreparedStatement is an interface available in java.sql package.
PreparedStatement is extending the Statement interface.
Subclass of PreparedStatement interface is provided by Driver vendor.
You can create the PreparedStatement object using the following methods of Connection interface.
public PreparedStatement prepareStatement(sql);
public PreparedStatement prepareStatement(sql,int,int);
public PreparedStatement prepareStatement(sql,int,int,int);
You can call one of the following methods on PreparedStatement object to submit the SQL statment to Database.
public int executeUpdate();
public ResultSet executeQuery();
public boolean execute();
Using the single public PreparedStatement prepareStatement(sql);object, you can submit only one SQL statement.
For example:
String sql = "insert...";
PreparedStatement ps = con.prepareStatement(sql);
int x = ps.executeUpdate();
When you submit the SQL statement using PreparedStatement object then SQL statement will be compiled only once first time and pre-compiled SQL statement wil be
executed every time.
Total time = req.time + compile time + execution time + res.time
= 5ms + 5ms + 5ms + 5ms =20ms.
First time = 20ms
Second time onwards = 5ms +0ms + 5ms + 5ms = 15ms.
100 SQL stmts =20ms+99*15ms
=20ms + 1485ms.
=1505ms.
PreparedStatement gives you the place holder mechanism for providing the data dynamically to the SQL statement. You need to use the "?" symbol for the placeholder.
To provide the value for placeholder, you need to invoke the setter method depending on the placeholder data type.
public void setInt(int paramIndex, int val);
public void setString(int paramIndex, String val);
public void setLong(int paramIndex, long val);
public void setDouble(int paramIndex, double val); etc
int sid =101;
String name = "Shail";
String email= "shail@gmail.com"
long phone = 1234567890;
String sql = "insert into student values(?,?,?)";
ps=con.prepareStatement(sql);
ps.setInt(1,sid);
ps.setString(2,name);
ps.setString(3,email);
ps.setLong(4,phone);

3.CallableStatement
CallableStatement is an interface available in java.sql package.
CallableStatement is extending PrepareStatement interface.
Subclass of CallableStatement interface is provided by the Driver vendor.
You can create the CallableStatement object using the following methods of Connection interface.
public CallableStatement prepareCall(sql);
public CallableStatement prepareCall(sql,int,int);
public CallableStatement prepareCall(sql,int,int,int);
You can call the following mmethod on CallableStatement object to submit the SQL statement to database.
public boolean execute();
Using the single CallableStatement object, you can submit call to only one procedure.
For example:
String sql "call p1(?,?)";
CallableStatement cs = con.prepareCall(sql);
cs.setInt(1,10);
cs.setInt(2,20);
cs.execute();
When you submit the call to stored procedure using CallableStatement object then pre-compiled stored procedure will be executed directly.
Total time = req.time + compile time + execution time + res.time
= 5ms + 0ms + 4*5ms + 5ms =30ms.
4 SQL stmts * 25 times.
=30*25.
=750.
CallableStatement gives you the placeholder mechanism for providing the data dynamically to the procedure parameters. You need to use the "?" symbol for the placeholder.
To provide the value for placeholder, you need to invoke the setter methods depending on the placeholder date type.
public void setInt(int paramIndex, int val);.
public void setString(int paramIndex, String val);
public void setLong(int paramIndex, long val);
public void setDouble(int paramIndex, double val); etc

You need to use the following method to specify the OUT parameter.
public void registerOutParameter(int parameterIndex,int sqlType);
sqlType is a constant from java.sql.Types class.
You need to use the following method to access the result of OUT parameter.
public int getInt(int paramIndex);
public String getString(int paramIndex);
public long getLong(int paramIndex);
public double getDouble(int paramIndex);

Parameters

2020-01-03T04:35:00.001-08:00

Servlet Instance Creation

By default, the servlet instance will be created when the first client will send the request to the servlet.
Only one instance will be created for one servlet and will be used to process all the requests by using multiple threads.
If you want to create the instance while starting the server or container then you can use the following:

In web.xml
<servlet>
<load-on-startup>X</load-on-startup>
</servlet>
In Annotation
@WebServlet(loadOnStartup=X)

Note: X will be int type value. It must be +ve integer.
It indicates in which order the servlet instance will be created.

Parameters

Parameter is name-value pair.
Parameter name and value are of type String.
The parameter is read-only i.e web container stores the parameter in the corresponding object and you can read and use that value. You can not modify the parameters.

There are 3 types of parameters

ServletRequest Parameters
ServletConfig Parameters
ServletContex Parameters

ServletRequest Parameters
Client submitted data which is coming from web client to web server along with HTTP request are called as request parameters
Web container collects client submitted data and stores that in HttpServletRequest object as request parameters. As a developer, you can collect that data from the request object as follows.

Case 1:
String name = request.getParameter("name");
String[] course = request.getParameterValues("course");

Case 2:
You can access the parameter names and values as Map
Map<String,String[]> map = request.getParameterMap();
Set pnames = map.keySet();
Iterator it = pnames.iterator();
while(it.hasNext()){
String parameterName = (String)it.next();
Object val = map.get(parameterName);
String[] values = (String[])val;
for(String value: values){
System.out.println(value);
}
}

Case 3:
To access only request parameters
Enumeration<String> ens = request.getParameterNames();
List<String> list = Collections.list(ens);
for(String pn : list){
String pv = request.getParameter(pn);
System.out.println(pn+" "+pv);
}

The container is storing multiple values for the same key in the map in the form of a String array.
Map<String,String[]> map = ...;
String course[] = new String[2];
course[0]="Java";
course[1]="JDBC";
map.put("course",course);

ServletConfig Parameters

ServletConfig is an interface available in javax.servlet package and web container vendor are responsible to provide the subclass for this interface.
Every servlet will have its own ServletConfig object and can not be shared.
When you want to use any data which is common for all the users but specific to a particular servlet that data can be specified as config parameters or init parameters.

With Servlet 2.x: Specify the config parameters in web.xml
<servlet>
<servlet-name>helloServlet</servlet-name>
<servlet-class>com.mak.servlets.HelloServlet</servlet-class>
<init-param>
<param-name>email</param-name>
<param-value>mak@gmail.com</param-value>
</init-param>
</servlet>
With servlet 3.x: specify the config parameters in servlet class with annotations
@WebServlet(name="helloServlet",urlPatterns={"hello.do"},
initParams={@WebInitParam(name="email",value="mak@gmail")})
public class HelloServlet extends HttpServlet{}

Web container collects data from either web.xml or annotation and stores that in ServletConfig object as config parameters. As a developer, you can collect that data from the config object as follows.
String email = config.getInitParameter("email");
You can override the following method in the servlet class to acess the ServletConfig
public void init(ServletConfig cfg)

You can use the following inheritance method from HttpServlet
public ServletConfig getServletConfig()
Here when HttpServlet class init() implementation will be invoked(from init() method) then the config object will be returned otherwise null will be returned.

Assume that HttpServlet class is implemented as follows
public abstract class HttpServlet...{
private ServletConfig config;
public void init(ServletConfig config){
this.config=config;
}
public ServletConfig getServletConfig(){}
...
}

Case 1:
class AServlet extends HttpServlet{
protected void service(...){
ServletConfig cfg = getServletConfig(); // inherited
//return the config object
//Since init() method from HttpServlet will be called and config will be initialized.
}
}

Case 2 :
class BServlet extends HttpServlet{
public void init(ServletConfig cfg){
super.init(cfg); // invoking the HttpServlet init() method
}
protected void service(...){
ServletConfig cfg = getServletConfig();
//returns the config object
// Since init() method from your class will be called and you are calling HttpServlet init() so config will be initialized.
}
}

Case 3:
class CServlet extends HttpServlet{
public void init(ServletConfig cfg){
}
protected void service(...){
ServletConfig cfg = getServletConfig(); // inherited
//returns null value
// Since init() method from your class will be called and you are not calling HttpServlet init() so config won't be initialized.
}
}

ServletContext Parameters

ServletContex is an interface available in javax.servlet package and container vendor is responsible to provide the subclass for this interface.
One web application will have only one ServletContext object i.e ServletContext object can be shared with all the servlets running in the container.
When you want to use any data which is common for all the users and common to all the servlets then data can be specified as context parameters in the web.xml as
follows.

web.xml
<context-param>
<param-name>website</param-name>
<param-value>www.google.com</param-value>
</context-param>

Web container collects data from web.xml and stores that in ServletContext object as context parameters. As a developer, you can collect that data from the context object as follows:
String web = context.getInitParameter("website");
You can use the following method with ServletConfig or ServletContext object to access the corresponding parameter names.
Enumeration<String> ens = sc.getInitParameterNames();
List<String> list = Collections.list(ens);
for(String pn: list){
String pv = sc.getInitParameter(pn);
System.out.printl(pv);
}

Introduction

2020-01-02T23:39:00.000-08:00

JDBC is a technology which is used to interact with the database from Java Application
JDBC Technology is a part of Java Standard Edition
JDBC is a Specification provided by Java vendor and implemented by Java Vendor or DB vendor.

JDBC Versions
JDBC 3.0 is released under J2SE 1.4.2
No updation under J2SE 5.0
JDBC 4.0 is released under Java SE 6
JDBC 4.1 is released under Java SE 7
JDBC 4.2 is released under Java SE 8

Java Program which is using JDBC API is called as JDBC Program.
Two packages provided under JDBC API called:
java.sql
javax.sql

Classes and Interfaces under java.sql package
DriverManager
Types
Driver
Connection
Statement
PreparedStatement
CallableStatement
ResultSet
ResultSetMetaData
DatabaseMetaData

Classes and Interfaces under javax.sql package
RowSet
JdbcRowSet
CachedRowSet
DataSource

Types of JDBC Drivers
There are four types of JDBC drivers
Type I Driver: JDBC ODBC Bridge Driver
Type II Driver: Partial Java and Partial Native Driver
Type III Driver: Net Protocol Driver
Type IV Driver: Pure Java Driver

Pros and Cons of Types of Drivers

	Advantages	Disadvantages
Type I Driver	Type I is very easy to use and maintain. Type I is suitable for migrating an application to Java without changing existing ODBC setup. No extra software is required for Type I implementation. The performance of Type I is acceptable.	Type I driver implementation is possible in window OS only because ODBC drivers are available only with windows. The performance of this driver is not excellent but acceptable.
Type II Driver	Type II is faster than all other drivers.	In Type II both client and server machine will have the database library. When the database is migrated then you will get much maintenance because you need to re-install client-side libraries in all the client machines.
Type III Driver	In Type III, client-side DB libraries are moved to the middleware server called the IDS server. Because of this, client-side maintenance is reduced.	You need to purchase extra software called the IDS server. Because of having a middleware server between your program and database server, performance will be reduced
Type IV Driver	This driver is best among all the drivers and highly recommendable to use.	Negligible

Note: Type I driver support is removed from Java 8.

Type IV Driver

Name	Pure Java Driver
Vendor	Database Vendor
Username	<Database Username>
Password	<Database Password>
Software Required	Database, Java

For Oracle

Driver Class	oracle.jdbc.driver.OracleDriver
URL	Jdbc:oracle:thin:@<host>:<port>:<serverName> e.g. jdbc:oracle:thin:@localhost:1521:XE
Classpath	ojdbc14.jar ojdbc6.jar

For MySQL

Driver Class	com.mysql.jdbc.Driver
URL	jdbc:mysql://<host>:<port>/<dbName> e.g. jdbc:mysql://localhost:3306/testdb
Classpath	mysql.jar

Architecture

Type IV Driver

Steps to Write JDBC Program
Step 1: Load the Driver class.
Step 2: Establish the Connection between the JDBC program and Database.
Step 3: Prepare the SQL statement.
Step 4: Create the JDBC statement.
Step 5: Submit the SQL statement to Database using JDBC statement.
Step 6: Process the result.
Step 7: Close all the resources.

Create the below database and table in MySQL
create database testdb;
use testdb;
create table student(sid int primary key,name varchar(20),state varchar(20));

JDBC Program to insert a record into the database(MySQL)

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
public class JdbcDemo {
public static void main(String[] args) {
Connection con = null;
Statement st = null;
try {
// Step 1:Load the Driver class.
Class.forName("com.mysql.jdbc.Driver");
// Step 2: Establish the connection.
final String url = "jdbc:mysql://localhost:3306/testdb";
con = DriverManager.getConnection(url, "root", "password");
// Step 3: Prepare the SQL statement.
String sql = "insert into student values(101,'Anu','M.P')";
// Step 4: Create JDBC statement
st = con.createStatement();
// Step 5: Submit the SQL statement to Database using JDBC statement.
int x = st.executeUpdate(sql);
// Step 6: Process the result.
if (x == 1) {
System.out.println("Record Inserted");
} else {
System.out.println("Record Not Inserted");
}
} catch (ClassNotFoundException | SQLException e) {
e.printStackTrace();
} finally {
// Step 7: Close all the resources.
try {
if (con != null)
con.close();
if (st != null)
st.close();
} catch (SQLException e) {
System.out.println("Exception occur while closing the resources");
}
}
}
}

Servlet

2020-01-02T01:03:00.000-08:00

Servlet is a web technology that is used to develop server-side web components.
Web components reside in server and perform the following:
Receive the incoming request data
Process the request
Prepare the HTML response
Servlets will be used to develop Dynamic Web application
One web application can have one or more web components like Servlets and JSPs.
One web container can have one or more web applications
One web server will have only one web container.

Client-Server

Steps to develop and run the first Servlet 4.x based Web App.
1. Consider the login requirement.

Assignment

2. Create the Dynamic Web Project in STS/eclipse as follows:
Select File->New->Dynamic Web Project
Project Name: Lab1
Click on New Runtime button (for the first time)
Select Apache Tomcat v9.0 and click on Next button
Browse the Tomcat Home Directory i.e D:\apache-tomcat-9.0.30
Click on the finish button
Click on the finish button
3. Observe the following Directory structure of Dynamic Web Project in STS.
4. Create login.html under the WebContent folder.
5. Create a package com.demo.servlets under Java Rsources>src
6. Create LoginServlet.java file in package com.demo.servlets.
7. Deploy into Tomcat 9 as follows
Right-click on Lab1
Select Run As->Run on Server
8. Open the Browser
9. Provide the following URL
http://localhost:8080/Lab1/login.html

Required Files
login.html

<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<form action="login.do">
<h1>Account Login</h1>
<p>Username</p>
<input type="text" name="username"/>
<p>Password</p>
<input type="password" name="password"/>
<p><input type ="submit" value="Login"/></p>
</form>
</body>
</html>

LoginServlet.java

import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@WebServlet("/login.do")
public class LoginServlet extends HttpServlet {
private static final long serialVersionUID = 1L;
protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String username= request.getParameter("username");
String password= request.getParameter("password");
System.out.println(username);
String message="";
if(username.equals(password)) {
message ="<h1>Welcome"+username+"<h1>";
}else {
message="<h1> Invalid username or password</h1>";
}
PrintWriter out = response.getWriter();
out.write(message);
out.flush();
out.close();
}
}

Java 8 Date Time API

2019-12-27T03:30:00.000-08:00

Why did Java 8 introduce a new date and time API when it already had classes such as Date and Calendar?
Below are the main reasons
1.Bad API design. For example, The Date class has both date and time components, if you only want time information and not date-related information, you have to set the date-related value to zero. Some aspects of the classes are unintuitive as well. For example, in the Date constructor, the range of date values is 1 to 31 but the range of month values is 0 to 11(not 1 to 12).
2.Java.util.Date,java.util.Calendar,java.time.SimpleDateFormatter classes are not thread-safe.

Java 8 provides very good support for date and time-related functionality in the newly introduced package java.time package.
Most of the classes in this package are immutable and thread-safe. We will learn LocalDate, LocalTime, LocalDateTime,Instant,Period, Duration,TemporalUnit and DateTimeFormatter.

The java.time package consists of four sub-packages
java.time.temporal: Access date/time fields and units.
java.time.format: Formats the input and output of date/time objects.
java.time.zone: Handles time zones.
java.time.chrono: Supports calendar systems such as Japanese and Thai Calendars.

LocalDate
java.time.LocalDate represents a date without time or time zone. LocalDate is represented in the ISO-8601 calendar system in a year-month-day format(YYYY-MM-DD). For example,2019-12-27.

How to get today's date?
LocalDate today = LocalDate.now();

LocalTime
java.time.LocalTime class is similar to LocalDate except that LocalTime represents time without dates or time zones. The time is in the ISO-8601 calendar system format HH:MM:SS: nanosecond.

How to get the current time?
LocalTime currentTime = LocalTime.now();

LocalDateTime
This class java.time.LocalDateTime represents both data and time without time zones.
You can think of LocalDateTime as a logical combination of the LocalTime and LocalDate classes. The date and time formats use the ISO-8601 calendar system:
YYYY-MM-DD HH:MM: SS.nanosecond. For example,
LocalDateTime dateTime =LocalDateTime.now();

Instant
Represents machine time starting from Unix epoch(1970-01-01T00:00:00Z)
Typically used for timestamps
Instant instant = Instant.now();

What is the difference between LocalDateTime and Instant?
LocalDateTime uses the default time zone, but Instant does not.
For examaple,
LocalDateTime dateTime =LocalDateTime.now();//2019-12-27T15:27:27.139835100
Instant instant = Instant.now();//2019-12-27T09:57:27.139835100Z

Period
Represents the amount of time in terms of years, months and days.
Typically used for difference between two LocalDate objects.
How to find out when medicine will expire?
LocalDate manufactureDate = LocalDate.of(2018,Month.MARCH,15);
LocalDate expiryDate = LocalDate.of(2021, Month.JULY, 20);
Period expire = Period.between(manufactureDate, expiryDate);
System.out.println(expire);//P3Y4M5D, here P-> Period, Y-> Year, M-> Month, D-> Day
System.out.println(expire.getYears()+"Years "+expire.getMonths()+"Months "+expire.getDays()+"Days");//3Years 4Months 5Days

Duration
Represents the amount of time in terms of hours, minutes, seconds and fractions of seconds.
Typically used for difference between two LocalTime objects.

How to find out how many hours to go, to wish your best friend's birthday?
LocalDateTime comingMidnight = LocalDateTime.of(LocalDate.now().plusDays(1),LocalTime.MIDNIGHT);
LocalDateTime now1 = LocalDateTime.now();
Duration duration =Duration.between(now1, comingMidnight);
System.out.println(duration);//PT8H9M29.7853329S, Here PT-> Period Time, H-> Hour, M-> Minute, S->Second

TemporalUnit
The TemporalUnit interface is the part of java.time.temporal package.
It represents date or time units such as seconds, hours, days, months, years, etc.
The enumeration java.util.temporal.ChronoUnit implements TemporalUnit interface.
Instead of using constant values, it is better to use their equivalent enumeration values. Beacuase using enumeration values in ChronoUnit results in more readable code;further, you are less likely to make mistakes. For example,
System.out.println(Duration.of(1, ChronoUnit.MINUTES).getSeconds());//60
System.out.println(Duration.of(1, ChronoUnit.HOURS).getSeconds());//3600
System.out.println(Duration.of(1, ChronoUnit.DAYS).getSeconds());//86400

Time Zone
There are three important classes related to time zones that you need to know in order to work with dates and times across time zones.

ZoneId
ZoneOffset
ZoneDateTime

ZoneId
The java.time.ZoneId class represents time zones. Time zones are typically identified using an offset from Greenwich Mean Time(GMT, also known as UTC/Greenwich).
For example, the time zone of India is Asia/Calcutta
System.out.println(ZoneId.systemDefault());//Asia/Calcutta

ZoneOffset
It represents the time-zone offset from UTC/Greenwich. For example, zone ID "Asia/Calcutta" has a zone offset of +5:30(plus 5 hours and 30 minutes) from UTC/Greenwich.
The ZoneOffset class is the child class of ZoneId class.

ZonedDateTime
If you want all three- date, time, and time zone together. For that, you can use the ZoneDateTime class.
LocalDate currentDate = LocalDate.now();
LocalTime currentTime = LocalTime.now();
ZoneId myZone = ZoneId.systemDefault();
ZonedDateTime zoneDateTime = ZonedDateTime.of(currentDate,currentTime,myZone);
System.out.println(zoneDateTime);//2019-12-27T16:14:59.424905800+05:30[Asia/Calcutta]

Formatting Dates and Times
Using java.time.format.DateTimeFormatter class you can format the date and time according to your requirement.
DateTimeFormatter class provides many predefined constants for formatting date and time values.
Here is a list of a few such predefined formatters.
ISO_DATE(2019-12-27)
ISO_TIME(11:30:25.624)
ISO_ZONED_DATE_TIME(2019-12-27T16:14:59.424905800+05:30[Asia/Calcutta])
RFC_1123_DATE_TIME(Thu,26 Dec 2019 11:27:30+0530)
For example,
LocalTime wakeupTime = LocalTime.of(6,0,0);
System.out.println(DateTimeFormatter.ISO_TIME.format(wakeupTime));// 06:00:00

If you want to use a custom format instead of any of the predefined format. To do so, you can use the
ofPattern() method in the DateTimeFormatter class.
DateTimeFormatter customFormat = DateTimeFormatter.ofPattern("dd/MM/yyyy");
System.out.println(customFormat.format(LocalDate.of(2019,Month.MARCH,01)));//01/03/2019

Important letters and their meanings for creating patterns for dates
G(era: BC,AD)
y(year of the era: 2020,20)
Y(week based year: 2020,20)
M(month:3,Mar,November)
w(week in year: 12)
W(week in month: 3)
E(day name in week: Sun, Sunday)
D(day of year: )
d(day of month)

Example:
class DateFormatter{
public static void main(String[] args) {
String[] dateFormats = { "d-M-y",
"dd-MM-yy",
"dd-MMM-yyy",
"dd-MM-yyyy",
"D-MM-yyyy",
"DD-MM-yyyy",
"DDD-MM-yyyy",
"d - MMM- Y",
"w'th week of' YY",
"w'th week of' YYY",
"E, dd'th' MMMM,YYYY",
"EE, dd'th' MMMM,YYYY",
"EEE, dd'th' MMMM,YYYY",
"EEEE, dd'th' MMMM,YYYY" };
Arrays.stream(dateFormats)
.forEach(i -> System.out.println(DateTimeFormatter.ofPattern(i).format(LocalDate.now())));

}
}

Important letters and their meanings for creating patterns for time
a(marker for the text a.m/p.m marker)
H(hour:value range 0-23)
k(hour value range 1-24)
K(hour in an a.m/p.m :value range 0-11)
h(hour in a.m/p.m : value range 1-12)
m(minute)
s(second)
S(fraction of a second)
z(time zone: general time-zone format)

class TimeFormatter{
public static void main(String[] args) {
String[] timeFormats = { "h:mm",
"hh 'o''clock'",
"H:mm a",
"hh:mm:ss:SS",
"K:mm:ss a"
};
Arrays.stream(timeFormats)
.forEach(i -> System.out.println(DateTimeFormatter.ofPattern(i).format(LocalTime.now())));

}
}

Collection

2019-12-14T07:48:00.000-08:00

The collection framework is very important for fresher and experienced developers. You must have a good hold on it if you want to crack java interviews. You are supposed to prepare theoretical, coding and scenario-based questions related to this topic. I will try to explain each concept and interview questions of the Collection framework in a simple way. Almost, in all the interview it is asked that what is the difference between List, Set, Map, etc. How will you choose which Collection is suitable for a particular situation? With the help of the below diagram, you can answer the above questions with confidence. So please spend some time in the below diagram.

Collection Framework

Dependency Injection

2019-10-22T10:36:00.001-07:00

What is Dependency Injection aka Inversion of control?
Let's understand first "coupling". When one class depends on another, they are called coupled.
Coupled class can't be tested in isolation.
For example: Client depends on BookService, BookService depends on BookDAO, BookDAO depends on JdbcRepository.

class Client{
public static void main(String[] args){
Book book = new Book(1,"Effective Java","Joshua Bloch");
BookService service = new BookService();//dependency
service.add(book);
}
}

class Book{
private int bookId;
private String name;
private String author;
Book(int bookId,String name,String author){
this.bookId=bookId;
this.name=name;
this.author=author;
}
//getters & setters
}

class BookService{
private BookDAO bookDao = new BookDAO();//dependency
public void add(Book book){
bookDao.save(book);
}
}

class BookDAO{
private JdbcRepository repository = new JdbcRepository();//dependency
public void save(Book book){
repository.save(book);
}
}

How can we reduce coupling?

Program to interfaces(Still have coupling because of new operator).
Dependency Injection(Pass collaborators in as parameters rather than hard-coding them).
Centralize Configuration(Capture all the dependencies in one place. Use a "container" to create and configure your objects.)

public class Client {
public static void main(String[] args) {
BookService service = Container.getBookServiceInstance();
Book book = new Book(1,"Effective Java","Joshua Bloch");
service.save(book);
}
}

class Book{
private int bookId;
private String name;
private String author;
Book(int bookId,String name,String author){
this.bookId=bookId;
this.name=name;
this.author=author;
}
//getters & setters
}

interface BookService{
public void save(Book book);
public void delete(int bookId);
public void update(Book book);
}

class BookServiceImpl implements BookService{
private BookDAO bookDao = Container.getBookDaoInstance();
@Override
public void save(Book book) {
bookDao.save(book);
}
@Overridpublic void delete(int bookId) {
// logic
}
@Override
public void update(Book book) {
// logic
}
}

interface BookDAO{
public void save(Book book);
public void delete(int bookId);
public void update(Book book);
}

class JdbcImpl implements BookDAO{
@Override
public void save(Book book) {
//logic
}
@Override
public void delete(int bookId) {
// logic
}
@Override
public void update(Book book) {
// logic
}
}

class HibernateDao implements BookDAO{
@Override
public void save(Book book) {
System.out.println("Book is saving into the database");
}
@Override
public void delete(int bookId) {
// logic
}
@Override
public void update(Book book) {
// logic
}
}

class Container{
public static BookDAO getBookDaoInstance() {
return new HibernateDao();
}
public static BookService getBookServiceInstance() {
return new BookServiceImpl();
}
}

Expectations

2019-10-06T12:48:00.001-07:00

The expectation from Core a Java Developer

General

General expectation of client from core java developer is he should strong in Data structure , multithreading and fundamental , client expect when complex question asked from candidate he should attempt and try to solve the problem, the idea of asking complex question is they want to see are developer attempting to solve the problem which he has never solved , if trying to solve what approach taking , how breaking a problem into small part ,how using design principle and pattern.

some time client asking an open-ended question, the purpose of asking the open-ended question is, the developer should answer based on his past experience if developer answer in totality with confidence the probability of clearing interview become very high

the idea of asking the ambiguous question is the developer should be asked a question to clarify the requirement if the requirement is not clear and then try to solve the problem

Problem Solving

The idea of asking problem-solving is to evaluate developer design skills, sometimes client not expecting concrete implementation, they want to understand what approach developer taking to solve the design problem, are they giving up or the attempting to solve the problem

Fundamental

In fundamental client expecting , developer should know purpose of all the keyword , static binding , dynamic binding , overloading rule , overriding rule in terms of access modifier, exception handling, impact of dynamic linking on performance , how to improve performance by using final keyword , whats default implementation of hash code and equal , cloning, immutability, advantage of immutability , importance of final in security , Exception handling rules

Data Structure

In Data structure the expectation is developer should know all basic data structure and how those basic data structures internally working , base on use case developer should answer question which data structure is the best fit for given use case , how hashing concept is working in hash set and map , how to improve map /set performance by optimizing hash code , whats are time complexity of different operation on data structure , how resizing is happening in data structure , how to use comparable comparator , how to implement different sorting algorithm . How to optimize data structure by changing the capacity and load factor could able to implement one data structure by using another, could able to answer how to implement the data structure

Concurrent API

developer should know how concurrent hash map internally managing a lock how segmentation is working ,how many thread can work on concurrent hash map , benefit of using concurrent hash map over hash table and synchronize map , what kind of business use case can be implemented by using concurrent hash map , how blocking queue is working what kind of problem can be solved by using blocking queue, when we should use linked blocking queue and when array blocking queue whats implementation of blocking queue, how to use blocking queue in inter-thread communication, whats fail-safe iterator

how to implement thread pool, whats advantage of the thread pool, how many types of thread pool do we have, how we can use executor service, how to use executor service to implement parallel /pipeline processing. , what kind of business problem can be solved by a cyclic barrier and count down the latch and how it's working, how to use semaphore, whats CAS concept (Compare and set), how atomic API is working internally

Multithreading

the expectation here is developer should know basic of multithreading, should know how to wait, notify, sleep, join is working, how locking is working , whats class label lock , whats object lock, how to implement inter-thread communication by using wait and notify , how volatile is working , how happen before concept is working in terms of volatile , how to implement thread pool in java 4 , how important is immutability in multithreading , whats code can create deadlock, what code can create starvation,

Serialization

Developer should know the purpose of serialization, purpose of serial version UID, if serial version UID is not defined how JVM generating it, how to customize serialization behavior, how to serialize transient variable how to improve performance by customizing serialization behavior

Memory management

Developer should know java memory model , should know heap , how garbage collection is working , how to optimize memory , should aware where class metadata storing in memory, should know reason of Perm gen Exception, reason of Out of memory exception, should aware how to do memory profiling, how to identify which code consuming memory

Design Pattern

Developers should know at least 2 to 3 design patterns thoroughly while explaining use case implementation should use some of the design patterns, must know the best way of implementing singleton pattern, factory pattern, strategy pattern, builder pattern, flyweight pattern, decorator and adapter pattern. Should know at-least 1 example of these patterns implementations from JDK.

Design Principle

Developer should know SOLID concept very well, whenever explaining solution design principle should reflect in his solution, how important is code for interface concept

Object-oriented Concept

Developer should know Encapsulation, Polymorphic, Composition, Inheritance, when should use inheritance when should we use composition.

Database

Developer should able to write some of the queries on join and aggregation, Should aware index, type of index and how indexing is working, should aware all key

Spring

Knows basics of Spring-like dependency injection (inversion of control), auto wiring (both XML and annotations), bean life cycle, profiling, transaction management and externalization of properties.

Rest

Basic understanding of REST principles (Uniform interface, Stateless interactions, Cacheable, Client-Server, Layered System, Code on Demand. HTTP protocol (HTTP methods, Headers, Error codes) and the concept of resources for REST.

Micro-Services

What is MicroServices? How it is different from Monolithic architecture? what are the advantages in Microservices w.r.t Monolithic architecture? Small application using Spring boot.

Java 8 features

2019-10-06T12:34:00.002-07:00

Agenda

Lambda Expression
Functional Interface
Default Method
Inbuilt functional interfaces
1.Consumer
2.Supplier
3.Function
4.Predicate
Double colon operator(::)
Stream API
Optional
Date and Time API

Lambda Expression a.k.a Anonymous Function.
A function having no
1. Name
2. Return type
3. Modifiers
Let's understand the above concept with the help of an example.
Take a method having name m return type int and modifier public
public int m(){};
Note here; is optional

Now apply the Lambda Expression to the above method.
public int m(){};
means remove
1. Name i.e m
2. Return type i.e int
3.Access Modifiers i.e public
After removing it becomes
() {}
To make it Lambda express we have a link with arrow symbol -> like below.
()->{};
Note here; is mandatory.

Important points to Remember

The method parameter type is optional, Compiler automatically knows the method parameter type which is called Type Inference. You know Functional Interface contains only one abstract method so the compiler can guess the type of parameter.
If there is only one parameter then parenthesis () is also optional.
If there is only one statement inside the method body then curly braces also optional. But if you are removing {} then also remove the return keyword otherwise you will get a compilation error.
If there is no parameter then parenthesis is mandatory.
If there are more than one parameters then also parenthesis is mandatory.

Convert below methods in lamda expression
Example1
public int add(int a,int b) {
return a+b;
}
(int a,int b)->{return a+b};//valid
(a,b)->{return a+b};//valid
(a,b)->return a+b;//invalid
(a,b)->a+b;//valid
a,b->{return a+b;};//invalid

Example2
public void method(int a){}

(int a)->{System.out.println(a);};
(a)->{System.out.println(a);};
a->{System.out.println(a);};
a->System.out.println(a);

Example3
public void methodOne(){}

()->{System.out.println("Anu");};
()->System.out.println("Anu");

Now think how can you invoke the above lambda express.
The answer is using the Functional Interface.

Functional Interface.
Functional Interfaces are those which will satisfy the below rules.
1. Having only one abstract method.
2. No restriction with the default method
3. No restriction with the static method.
For example

public interface InterF {
public void m();
default void m2() {
}
default int m3() {
return 0;
}
public static void m4() {
}
public static void m5() {
}
}

Q. How can we invoke Lambda expression?
Ans: Using Functional Interface.

InterF f=()->{System.out.println("hello");};
f.m();

public class Test {
public void m6() {};
public static void main(String[] args) {
InterF f=()->{System.out.println("Hello Lambda");};
f.m();
}
}

Note: In Java 1.8v @FunctionalInterface annotation is introduced to specify that the interface is Functional interface and if you not abide functional interface rules then you will get compilation error.

Example
@FunctionalInterface
public interface InterF {
public void m1();
public void m2();
}//you will get compilation error.

Functional Interface w.r.t Inheritance
If an interface extends Functional Interface and child interface doesn't contain any abstract method then the child interface is also a Functional Interface.

@FunctionalInterface
public interface InterA {
public void m1();
}

@FunctionalInterface
public interface InterB extends InterA {
public void m1();
}//No compilation error.

@FunctionalInterface
public interface InterB extends InterA {
public void m2();//compilation error
}

public interface InterB extends InterA {
public void m2();//No compilation error because this is not a functional interface. it is a normal interface which can contain any number of abstract methods
}

Next Topic: Default Method

Happy coding.
You can download the code from Github using the below URL.
https://github.com/mahendrakr/java8

Wrapper classes

2019-10-05T02:16:00.001-07:00

Agenda

Wrapper classes
The class hierarchy of wrapper class
Creating an object of the wrapper classes

Wrapper classes

The wrapper classes are used to wrap primitives in an object. So, they can be added to a collection object.
To define utility functions that are required for the primitives.
All wrapper classes are immutable.
Wrapper classes Byte, Short, Integer and Long cache objects with values in the range of -128 to 127. The Character class caches objects with values 0 to 127.
Wrapper classes Float and Double don't cache objects for any range of values.

Example:

public class Test{
public static void main(String[] args){
Integer a =10;
Integer b=10;
System.out.println(a==b);//true
Integer c=128;
Integer d =128;
System.out.println(c==d);//false,reason value 128 is out of range of cache objects .So it will create new object.
}
}

Creating object of the wrapper classes
You can create objects of all the wrapper classes in multiple ways
Assignment : By assigning a primitive to a wrapper class variable(Auto-boxing)
Ex: Integer a =10;
Constructor: By using wrapper class constructors.
Ex: Integer a = new Integer(10);
Static methods: By calling static method of wrapper classes, like valueOf();
Ex: Integer wrapper = Integer.valueOf(10);

Wrapper Classes Constructors

Wrapper Class	Constructors
Byte	Byte(byte a),Byte(String s)
Short	Short(short a),Short(String s)
Integer	Integer(int a),Integer(String s)
Long	Long(long a),Long(String s)
Float	Float(float a),Float(String s)
Double	Double(double a),Double(String s)
Character	Character(char a)
Boolean	Boolean(boolean a),Boolean(String s)

Note: Wrapper class Character has no String argument constructor.
The class hierarchy of wrapper class

Conversion of Wrapper Classes to String and Primitive and Vice-Versa
String to Wrapper Class:
Integer wrapper= Integer.valueOf("10");

String to Primitive:
int primitive = Integer.parseInt("10");

Wrapper to String:
String String1= String.valueOf(wrapper);
String String2 = wrapper.toString();

Wrapper to primitive:
int intValue = wrapper.intValue();

Primitive to Wrapper:
Integer wrapper = Integer.valueOf(10);

Primitive to String:
String string3 = Integer.toString(10);

Summary of above conversion in Diagram

Optional

2019-09-22T00:35:00.001-07:00

Q.What is the alternative to null in Java?
Java 8 introduces a new class called java.util.Optional<T> that’s inspired by the ideas of Haskell and Scala. It’s a class that encapsulates an optional value.

Q.How do you model the absence of a value?
Imagine you have the following nested object structure for a person owning a car and having car insurance.
The Person / Car / Insurance data model
If you design your classes like below

class Person{
private Car car;
public Car getCar() {
return car;
}
}

class Car{
private Insurance insurance;
public Insurance getInsurance() {
return insurance;
}
}

class Insurance {
private String name;
public String getName() {
return name;
}
}

class Test {
public String getCarInsuranceName(Person person) {
return person.getCar().getInsurance().getName();
}
public static void main(String[] args) {
Test t = new Test();
t.getCarInsuranceName(new Person());
}

Problems with null

It’s a source of error. NullPointerException is by far the most common exception in Java.
It bloats your code. It worsens readability by making it necessary to fill your code with often deeply nested null checks.
It’s meaningless. It doesn’t have any semantic meaning, and in particular, it represents the wrong way to model the absence of a value in a statically typed language.
It breaks Java philosophy. Java always hides pointers from developers except in one case: the null pointer.
It creates a hole in the type system. null carries no type or other information, meaning it can be assigned to any reference type. This is a problem because, when it’s propagated to another part of the system, you have no idea what that null was initially supposed to be.

I argue that using null to represent the absence of a value is the wrong approach.
What you need is a better way to model the absence and presence of a value.

Redefining the Person / Car / Insurance data model using Optional

class Person {
private Optional<Car> car;
public Optional<Car> getCar() {
return car;
}
}

class Car {
private Optional<Insurance> insurance;
public Optional<Insurance> getInsurance() {
return insurance;
}
}

class Insurance {
private String name;
public String getName() {
return name;
}
}

class OptionalVersion {
public String getCarInsurance(Optional<Person1> person) {
return person.flatMap(Person1::getCar).flatMap(Car::getInsurance).map(Insurance::getName).orElse("Unknow");
}
public static void main(String[] args) {
OptionalVersion t = new OptionalVersion();
Optional<Person> p = Optional.empty();
System.out.println(t.getCarInsurance(p));;
}
}

Creating Optional objects
There are several ways to create Optional objects.
Empty optional:
Optional<Car> optCar = Optional.empty();
Optional from a non-null value:
Optional<Car> optCar = Optional.of(car);
If car were null, a NullPointerException would be immediately thrown (rather than getting a
latent error once you try to access properties of the car).
Optional from null:
Optional<Car> optCar = Optional.ofNullable(car);
If car were null, the resulting Optional object would be empty

The methods of the Optional class

Method	Description
empty	Returns an empty Optional instance
filter	If the value is present and matches the given predicate, returns this Optional; otherwise returns the empty one
flatMap	If a value is present, returns the Optional resulting from the application of the provided mapping function to it; otherwise returns the empty Optional
get	Returns the value wrapped by this Optional if present, otherwise throws a NoSuchElementException
ifPresent	If a value is present, invokes the specified consumer with the value; otherwise does nothing
isPresent	Returns true if there is a value present; otherwise false
map	If a value is present, applies the provided mapping function to it
of	Returns an Optional wrapping the given value or throws a NullPointerException if this value is null
ofNullable	Returns an Optional wrapping the given value or the empty Optional if this value is null
orElse	Returns the value if present or the given default value otherwise
orElseGet	Returns the value if present or the one provided by the given Supplier otherwise
orElseThrow	Returns the value if present or throws the exception created by the given Supplier otherwise

Double colon operator

2019-09-21T09:42:00.001-07:00

Method and Constructor reference by using "::" operator

The functional interface method can be mapped to our specified method by using "::" operator. This is called method reference.
Our specified method can be either a static or instance method.
The functional interface method and our specified method should have the same argument types except for return-type, method-name, modifiers, etc are not required to match.

Syntax
If our specified method is a static method.
Class-name::method-name

If the method is an instance method
Object-reference::method-name

Constructor references
We also can use ":: "operator to refer constructors
Syntax
Class-name::new

Example:

class Student{
private String name;
Student(String name){
this.name=name;
}
}
interface A{
public Student getName(String name);
}
class Test{
public static void main(String[] args){
A a= s-> new Sample(s);
a.getName("Anu");
A a1 = Student::new;
a1.getName("Kalawati");
}
}

Note: In method and constructor references compulsory the argument types must be matched.

Java 8 in built functions

2019-09-21T06:02:00.000-07:00

IN BUILT FUNCTIONS
Consumer,Supplier,Function and Predicate all are available under java.util.function package.

Comparison of in built functions

Properties	Consumer	Supplier	Function	Predicate
Purpose	To consume some input and perform required operation.It won’t return anything	To supply some value base on requirement	To take some input and perform the required operation and return the result.	To some input and perform some conditional checks
Interface Declaration	interface Consumer<T>{}	interface Supplier<R>{}	interface Function<T,R>{}	interface Predicate<T>{}
Single abstract method	public void accept(T t);	public R get();	public R apply(T t);	public boolean test(T t);
Default method	andThen()	NA	andThen(), compose()	and(),or(), negate()
Static method			identify()	isEqual()

How to call in built functions?

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
public class Test {
public static void main(String[] args) {
//void accept(T t);
Consumer<String> consumer1 = (String s)->{System.out.println(s);};
Consumer<String> consumer2=(s)->{System.out.println(s);};
Consumer<String> consumer3=s->System.out.println(s);
consumer3.accept("Amit");
// T get();
Supplier<Integer> supplier1 = ()->10;
System.out.println(supplier1.get());
//R apply(T t);
Function<String, Integer> function1 = (String s)->{return 20;};
Function<String, Integer> function2 = (s)->{return 20;};
Function<String, Integer> function3 = (s)-> 20;
Function<String, Integer> function4 = s->20;
System.out.println(function4.apply("Kalawati"));
// boolean test(T t);
Predicate<Integer> predicate1=(Integer i)->{return i%2==0;};
Predicate<Integer> predicate2=(i)->{return i%2==0;};
Predicate<Integer> predicate3=(i)->i%2==0;
Predicate<Integer> predicate4=i-> i%2==0;
System.out.println(predicate4.test(20));
System.out.println(predicate4.test(15));
}
}

Predicate chaining
It is possible to combine predicates into a single predicate by using the following methods.

and()
or()
negate()
These are exactly same as logical AND, OR, complement operator

Function chaining
It is also possible to combine functions into a single function by using the following methods

andThen()
compose()

Consumer chaining
It is also possible to combine consumers into a single consumer by using andThen() method.

Example

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
public class FunctionChaining {
public static void main(String[] args) {
//Predicate chaining
Predicate<Integer> p1 = i->i%2==0;
Predicate<Integer> p2 = i->i%3==0;
System.out.println(p1.negate().test(10));//false
System.out.println(p1.or(p2).test(15));//true
System.out.println(p1.or(p2).test(7));//false
System.out.println(p1.and(p2).test(12));//true
System.out.println(p1.and(p2).test(10));//false
//Function chaining
Function<Integer, Integer> f1= i-> i+2;
Function<Integer,Integer> f2= i->i*3;
System.out.println(f1.andThen(f2).apply(4));//18
//Note in andThen() f1 will apply first then f2
System.out.println(f1.compose(f2).apply(4));//14
//Note in compose() f2 will apply first and then f2.
//Consumer chaining
Consumer<Integer> c1 = i->System.out.print(i+2);
Consumer<Integer> c2= i->System.out.print(i*2);
c1.andThen(c2).accept(4);//68
}
}

Next Topic : Double Colon Operator

Default method

2019-09-20T23:32:00.001-07:00

Default Methods

In Java 1.8v onwards, you can also define the default method inside the interface.
You can define the default method using the keyword default.
Default methods are by default available to all implementation classes. Based on our business requirement implementation class can use these default methods directly or override.
You can't override object class methods as default methods inside interface otherwise you will get a compilation error. Because you know Object class methods are by default available to each class/interface hence it is not required to override.
If you try to override Object class methods in the interface, you will get compiler error.

Note: You can't define the default method inside the concrete class and abstract class, otherwise compilation error.

Let's understand the above concept through examples.
Example1:

public default void methodOne(){
System.out.println("methodOne");
}
public default int methodOne(int a){
return 10;
}

Example2:

interface InterA{
public default int add(int a, int b){
return a+b;
}
}
class Test implements InterA{
public static void main(String[] args){
Test t = new Test();
t.add(10,20);
}
}

Example3:

interface InterA{
public default void methodOne(){
System.out.println("methodOne of InterA");
}
}
class Test implements InterA{
public void methodOne(){
System.out.println("methodOne of Test");
}
public static void main(String[] args){
Test t = new Test();
t.methodOne();//methodOne of Test
}
}

Example4:

interface InterA{
public default String toString(){
return null;// compilation error, you can't override Object class methods.
}
}

Default method w.r.t Inheritance
If two interfaces contain default method with same method signature then you will get ambiguity problem(diamond problem) in implementation class.To overcome this problem compulsory you should override default method in the implementation class otherwise you will get compilation error.

Example:

interface A{
default void methodOne(){
System.out.println("Interface A default method");
}
}
interface B{
default void methodOne(){
System.out.println("Interface A default method");
}
}
class Test implements A,B{}//compilation error

Q. How to override default method?
In the implementation class, you can override the default method by removing keyword default and abide by overriding rules.

Example:

class Test implements A,B{
public void methodOne(){
System.out.println("Override default method");
//You can also do as below
A.super.methodOne();
B.super.methodOne();
}
public static void main(String args){
Test t = new Test();
t.methodOne();
}
}

Next Topic : In Built Functional Interfaces

Generic concept

2019-09-17T20:51:00.000-07:00

Agenda

Introduction
The generic concept is introduced in Java 1.5v
To resolve two problems of collection.
Type safety
ClassCastException
ArrayList list = new ArrayList();//Non generic a.k.a raw type version till java 1.4
ArrayList<String> list = new ArrayList<String>();//Generic Type
In Java 1.7 diamond operator <> is introuduce to improve code readability
ArrayList<String> list = new ArrayList<>();//Generic Type,valid from java 1.7 onwards
Here you can't add elements other than String type othewise you will get compilation error.
Example:
list.add("Anu");//valid
list.add(10);// invalid
Note1: Polymorphism concept is applicable only for the base type,not for parameter type.
Note2: Parameter type must not be primitive types. It should be any class or interface
Example
ArrayList<int> list = new ArrayList<>();// invalid

Generic Classes

Until Java 1.4v ArrayList class is defined as follows.
Example
class ArrayList{
public boolean add(Object o){}
public Object get(int index){}

}
add() method can take Object as the argument and hence we can add any type of the object to the ArrayList. Due to this, we are not getting type of safety.
The return type of get() method is object hence at the time of retrieval compulsory we should perform typecasting. But in Java 1.5v a generic version of ArrayList class is defined as follows.

Generic

Example: class ArrayList<E>{
public boolen add(E data){}
public E get(int index){}
}
Based on our requirement E will be replaced with our provided type.
To hold only String type of objects we can create ArrayList object as follow.
Example
ArrayList<String> list = new ArrayList<>():
For this requirement compiler considered ArrayList class is
Example
class ArrayList<String>{
public boolen add(String data){}
public String get(int index){}
}
add() method can take only String type as argument hence we can add only String type of objects to the List.Hence through generics, we are getting type safety.
At the time of retrieval, it is not required to perform any typecasting.

How can we create a custom generic class?
class Student<T>{}

Bonded Types
We can bound the type parameter for a particular range by using the extends keyword. such types are called bounded types.
Example
class Test<T>{}
Test<Integer> t1 = new Test<>();
Test<String> t2 = new Test<>();
As the type parameter we can pass any type there is no restriction hence it is unbounded type.
Example
class Test<T extends X>{}
If X is a class then as the type parameter we can pass either X or its child classes.
If X is an interface then as the type parameter we can pass either X or its implementation classes.
Example
class Test<T extends Number>{}
class Test1{
public static void main(String[] args){
Test<Integer> t1 = new Test<>();
Test<String> t1 = new Test<>();// Compilation Error
}
}
Example
class Test<T extends Runnable>{}
class Test1{
public static void main(String[] args){
Test<Thread> t1 = new Test<>();// Thread class is implementation class of Runnable interface.
Test<String> t1 = new Test<>();// Compilation Error
}
We can't define bounded types by using implements and super keyword.
Example
class Test<T implements Runnable>{}//invalid
class Test<T super String>{}//invalid
But implements keyword purpose we can replace with extends keyword.
As the type parameter, we can use any valid java identifier but it is recommended to use
T for Type
E for Element
K for Key
V for Value
Example
class Test<X>{}//valid
class Test<Anu>{}//valid
We can pass any number of type parameters, there is no restriction at all.
Example
class Map<K,V>{}
class Test<A,B,C,D,E....>{}
We can also define bounded types in combination.
Example
class Test<T extends Number & Runnable>{}//valid
As the type parameter, we can pass any type which extends Number class and implements Runnable interface.
class Test<T extends Number & String>{}// invalid, we can't extend more than one class at a time.
class Test<T extends Runnable & Comparable>{}//valid
class Test<T extends Runnable & Number>{}//invalid, we have to take 1st class followed by interface.

Generic methods and wild card character(?)
public void methodOne(ArrayList<String> list){
list.add("Anu");
list.add(null);
list.add(10);// invalid, only string type and null is allowed.}

public void methodOne(ArrayList<?> list){};We can use this method for ArrayList of any type but within method we can't
add anything except null.
Example
list.add(null);//valid
list.add("Anu");// invalid
list.add(10);//invalid
This method is useful whenever we are performing only read operation.

public void method(ArrayList<? extends X> list):

If X is a class then this method is applicable for ArrayList of either X type or its child classes.
If X is an interface then this method is applicable for ArrayList of either X type or its implementation classes.
Within the method we can add only null value.

public void methodOne(ArrayList<? super X> list):

If X is a class then this method is applicable for ArrayList of either X type or its super-types.
If X is an interface then this method is applicable for ArrayList of either X type or its super-types.
But within the method, we can add X type objects and null to the List.
If X is a class then within the method we can add only X type or its sub-types.
If X is an interface then within the method we can add only implementation classes of X.

Below example will help you to understand the above concept.

class A{}

class B extends A{}

class C extends B{}

class D extends C{}

interface X{}

interface Y extends X{}

class P implements Q, Y{}

interface Q {}

class R extends P{}

import java.util.ArrayList;
import java.util.List;
class GenericAtMethod {
public static void m1(List<? extends B> list) {
// We can add only null value
list.add(null);
}
public static void m2(List<? extends Y> list) {
//we can add only null value
list.add(null);
}
public static void m3(List<? super B> list) {
// we can add only either B type or its sub-types(C,D) or null
list.add(null);
list.add(new C());
list.add(new D());
}
public static void m4(List<? super Y> list) {
//we can add only either implementation classes of Y(P,R) or null
list.add(null);
list.add(new P());
list.add(new R());
}
public static void main(String[] args) {
//method m1() will accept only B type or its sub-types(C,D)
List<A> l1= new ArrayList<>();
List<B> l2= new ArrayList<>();
List<C> l3=new ArrayList<>();
List<D> l10=new ArrayList<>();
List<Object> l9=new ArrayList<>();
//m1(l1); invalid because A is super type of B
m1(l2);
m1(l3);
m1(l10);
//method m2() will accept only Y type or its implementation classes(P,R)
List<Y> l4 = new ArrayList<>();
List<P> l5 = new ArrayList<>();
List<R> l6 = new ArrayList<>();
List<X> l7 = new ArrayList<>();
List<Q> l8 = new ArrayList<>();
m2(l4);
m2(l5);
m2(l6);
// m2(l7) invalid
// m2(l8); invalid
//method m3() will accept only List of either B type or its super-types(A,Object)
m3(l1);
m3(l2);
m3(l9);
//m3(l3); invalid
//m3(l10); invalid
//method m4() will accept only List of either Y type or its super types(Y,Object)
m4(l4);
m4(l7 );
m4(l9);
}
}

Which of the following declarations are valid?
ArrayList<String> l1 = new ArrayList<String>();//valid
ArrayList<String> l2= new ArrayList<>();//valid
ArrayList<?> l3 = new ArrayList<Integer>();//valid
ArrayList<?> l4 = new ArrayList<String>();//valid
ArrayList<? extends Number> l5 = new ArrayList<Integer>();//valid
ArrayList<? extends Number> l6 = new ArrayList<String>();// invalid
ArrayList<?> l7 = new ArrayList<? extends Number>();// invalid
ArrayList<?> l8 = new ArrayList<?>();// invalid

We can declare the type parameter either at the class level or method level.
Declaring type parameter at class level:
class Test<T>{
//we can use T anywhere
}

Declaring type parameter at the method level
We must declare just before return type.
Example
public <T> void methodOne(T t){};//valid
public <T extends Number> void methodOne(T t){};//valid
public <T extends Number & Runnable> void method(T t){};//valid
public <T extends Number & Runnable & Comparable> void methodOne(T t){}//valid
public <T extends Number & Thread> void methodOne(T t){}//invalid
public <T extends Runnable & Thread> void methodOne(T t){}//invalid

Conclusion
The generic concept is applicable only at compile time.Hence the following declarations are equal
ArrayList<String> list = new ArrayList<>();
ArrayList<Integer> list1 = new ArrayList<I>();

You will get compiler Error, because method methodOne have same erasure type.
public void methodOne(ArrayList<String> l){}
public void methodOne(ArrayList<Integer> l){}

How compiler works w.r.t Generic code.

The compiler first checks type and value is added the same type or not. If not give you Compilation Error.
If the type and added values are of the same type, then it erasure the type and again validate the source file, if found any violation then give you Compilation Error.

Limitation of Generic Type

1.You cannot instantiate a generic type using a new operator. For example,

T t = new T(); //compiler error

2.You cannot instantiate an array of a generic type. For example,

T[] t = new T[3]; //compiler error

3.You can declare instance fields of type T, but not of static fields of type T. For example,

Class A<T>{

T t;

static T t1; //compiler error

}

4.It is not possible to have generic exception classes. For example,

Class GenericException<T> extends Throwable{} // compiler error

5.You cannot instantiate a generic type with primitive types. For example,

List<int> list; // compiler error.

Exception handling

2019-09-17T17:47:00.002-07:00

Agenda

Exception
Exception Handling
Benefits of Exception Handling
Hierarchy of Exception
Keywords related to exception
Default exception handling in java
The possible combination of try, catch and finally
Multi-catch block
Try-with resources
Custom Exception
Assertions

Exception
An event that disturbs the normal flow of the program is called an exception.
Examples:
NullPointerException
ArrayIndexOutOfBoundException
FileNotFoundException
IOException
If an exception raised at any particular line, then the program will terminate abnormally. This means the remaining lines of the program will not be executed.

Q. How can you stop abnormal termination of the program?
Ans: Exception Handling mechanism, using keywords try, catch.

Exception Handling
Put the risky codes inside a try block and handle it in the catch block.
Risky codes are those which cause the abnormal termination of the program.
Example:

public class Test {
public static void print() {
int a=10;
int b=0;
System.out.println(a/b);// This is risky code, cause it will throw ArithmeticException
}
public static void main(String[] args) {
print();
}
}

To solve the above problem put the risky code in a try block and handle it in a catch block like below.

class Solution{
public static void print() {
int a=10;
int b=0;
try {
System.out.println(a/b);
}catch(ArithmeticException e) {
System.out.println("Denominator must not be zero");
}
}
public static void main(String[] args) {
print();
}
}

Benefits Of Exception Handling
Abnormal termination of the program is solved.

Exception: It is caused by our program and these are recoverable.
Error: It is not caused by our program, these are due to lack of system resources and these are not recoverable.

Hierarchy of Exception

Checked vs Unchecked Exceptions
The exceptions which are checked by the compiler are called checked exceptions
Example:
FileNotFoundException
IOException
InterruptedException
The exceptions which are not checked by the compiler are called unchecked exception.
Example:
NullPointerException
ArrayIndexOutOfBoundException

Note 1: RuntimeException and its child classed, Error and its child classes are unchecked and all the remaining are checked exceptions
Note 2: Whether the exception is checked or unchecked compulsory it should occur at runtime only. There is no chance of occurring any exception at compile time.

Keywords related to exception handling:
try: Put all risky code inside the try block.
catch: Handle exception inside the catch block.
finally: Put resource clean up code inside finally block
throw: To handover our created exception object to the JVM manually.
throws: To delegate the responsibility of exception handling to the caller method.

Default exception handling in java
1. If an exception is raised inside any method then the method is responsible to create an Exception object with the following information.
Name of the exception
Description of the exception
Location of the exception
2. After creating the exception object the method handovers the object to the JVM.
3.JVM checks whether the method contains any exception handling code or not. If the method won't contain any exception handling code then JVM terminates that method abnormally and remove the corresponding entry from the stack.
4.JVM identifies the caller method and checks whether the caller method contains any handling code or not. If the caller method also not contain any exception handling code then JVM terminates that caller also abnormally and removes the corresponding entry from the stack. This process will continue until the main() method. If the main() method also doesn't contain any exception handling code then JVM terminates main() method and removes the corresponding entry from the stack.
5. Then JVM handovers the responsibility to exception handling to the default exception handler.
6.Default exception handler print exception information to the console in the following formats and terminates the program abnormally.
Name of the exception: description
Location of exception(stack trace)

The possible combination of try, catch and finally

import java.io.FileNotFoundException;
public class PossibleCombination {
public void method() {
try {}catch(NullPointerException e) {}
try {}catch(RuntimeException e) {}
try {}catch(Error e) {}
try {}catch(Exception e) {}
try {}catch(Throwable e) {}
try {}catch(FileNotFoundException e) {}//CE For checked exception it must be raised in the try block then only you can handle it.
try {}catch(RuntimeException e) {}catch(Exception e) {}
try {}catch(NullPointerException e) {}catch(NullPointerException e) {}//CE you can't handle same exception two times.
try{}catch(Exception e) {}finally{}
try{}finally{}catch(Exception e) {}//CE in catch, finally series finally block should be the last block.
try {}catch(RuntimeException e) {}catch(NullPointerException e) {}//CE if there is a relation between the exceptions then first child exception should be handled first then parent.
try {}catch(NullPointerException e) {}catch(RuntimeException e) {}
try {}finally {}
try {}finally {}finally {}//CE atmost one finally block is allowed.
}
}

Multi-catch block
In a multi-catch block, you cannot combine catch handlers for two exceptions that share a parent-child relationship. You can only combine catch handlers for exceptions that don't share the parent-child relationship between them.
For example:
try {
throw new FileNotFoundException();
}catch(FileNotFoundException |IOException ex) {
}

Try with Resources
Until 1.6v, it is a programmer nagging to close all open resources(BufferReader, Connection) explicitly.
What's happen, If the programmer will forget to close the resources, It causes a memory leak and therefore effects the performance of the application.
To overcome this problem Java people introduce try-with resource
concept in 1.7v which closes all the open resources automatically. But only those resources which are the child of AutoCloseable or Closeable interface.
All resoure reference variables should be final or effectively final, therfore we can't do reassignment within the try block like below
try(BufferReader br = new BufferReader(new FileReader("test.txt"))){
br = new BufferReader(new FileReader("test.txt"));// invalid, CE
}
Note: We can declare any number of resources but all these resources must be separeted with ";" and finally block is not required . Like below
try(Resource1;Resource2;Resource3){}

Try-with Resources enhancement
Until 1.8v, the resource reference variables which are created outside of the try block can't be used directly in try-with-resources like below
BufferReader br = new BufferReader(new FileReader("test.txt"))
try(br){
// invalid until 1.8v, Resource reference variables must be local to try block
}

But valid in Java 1.8v onwards
try(BufferReader br1=br){
// valid in 1.8v or higher version
}

But in Java 1.9v onwards
try(br){
// valid in 1.9v or higher version, but make sure resources should be either final or effectively final, means we should not perform reassignment.
}

Custom Exception
You can create a custom exception by extending Exception or RuntimeException as per your business requirement.
If you want to force the caller to handle it, then create your custom exception by extending Exception otherwise create custom exception using RuntimeException.
You can also create by extending Throwable but it is not recommended.

Example
class RecordNotFoundException extends Exception{}
or
class RecordNotFoundException extends RuntimeException{}

Assertions
When creating application programs, you assume many things. However, often it happens that assumptions don't hold, resulting in an erroneous condition.
The assert statement is used to check your assumptions about the program. If assumption test gets fail then JVM will throw AssertionError
For Example:
public class AssertionExample {
public static void main(String[] args) {
int i=Integer.MIN_VALUE;
if(i<0) {
//If negative value, convert into positive value
i=-i;
}
System.out.println("the value of i is :"+i);
assert(i>=0):"impossible i is negative!";
}
}
Note: You have to enable assertion before executing the above program like below
java -ea AssertionExample
the value of i is :-2147483648
Exception in thread "main" java.lang.AssertionError: impossible i is negative!
at AssertionExample.main(AssertionExample.java:9)