1

 Functional programming is a paradigm where the basic

unit of computation is a function. 
 A style of programming that treats computation as the

evaluation of mathematical functions

 Here functions are not the methods we write in

programming.
 Methods are procedures where we write a sequence of

instructions to tell the computer what to do.

 In functional programming, functions are treated like

mathematical functions where we map inputs to

outputs to produce a result. Eg. f(x)=3x.
2
 In functional programming, the software is developed
around the evaluation of functions.
 The functions are isolated and independent, and

they depend only on the arguments passed to them

and do not alter the program's state like modifying
a global variable.
 Treats data as being immutable
 Functions can take functions as arguments and return

functions as results

3
 Java contains many predefined classes that are grouped
into categories of related classes called packages.
 A great strength of Java is the Java API’s thousands of

classes.
 Some key Java API packages are described in Fig. 6.5.
 Overview of the packages in Java SE 6:
 download.oracle.com/javase/6/docs/api/
overview-summary.html
 Java API documentation
 download.oracle.com/javase/6/docs/api/

© Copyright 1992-2012 by Pearson

Education, Inc. All Rights Reserved.
 package: A collection of related classes.

 Uses of Java packages:

group related classes together
as a namespace to avoid name collisions
provide a layer of access / protection
keep pieces of a project down to a manageable size

8
 package directory (folder)
 class  file

 A class named D in package a.b.c should reside in this file:

a/b/c/D.class

 (relative to the root of your project)

9
package name;
public class name { ...

Example:
package pacman.model;
public class Ghost extends Sprite {
...
}

 File Sprite.java should go in folder pacman/model .

10
import packageName.*; // all classes

Example:
package pacman.gui;
import pacman.model.*;
public class PacManGui {
...
Ghost blinky = new Ghost();
}
 PacManGui must import the model package in order to use it.

11
import packageName.className; // one class

 Importing single classes has high precedence:

 if you import .*, a same-named class in the current dir will override

Referring to packages


packageName.className
Example:
java.util.Scanner console =
new java.util.Scanner(java.lang.System.in);

12
 Compilation units (files) that do not declare a package are put
into a default, unnamed, package.

 Classes in the default package:

 Cannot be imported
 Cannot be used by classes in other packages

 Many editors discourage the use of the default package.

 Package java.lang is implicitly imported in all programs by

default.
 import java.lang.*;
13
 Java provides the following access modifiers:
 public : Visible to all other classes.
 private : Visible only to the current class (and any nested types).
 protected : Visible to the current class, any of its subclasses, and
any other types within the same package.
 default (package): Visible to the current class and any other types
within the same package.
 To give a member default scope, do not write a modifier:

package pacman.model;
public class Sprite {
int points; // visible to pacman.model.*
String name; // visible to pacman.model.*
14
15
 Java collections framework
◦ prebuilt data structures
◦ interfaces and methods for manipulating those data structures

16
 A collection is a data structure—actually, an object—
that can hold references to other objects.
◦ Usually, collections contain references to objects that are all of
the same type.
 Figure 20.1 lists some of the interfaces of the
collections framework.
 Package java.util.

17
18
 Each primitive type has a corresponding type-wrapper
class (in package java.lang).
◦ Boolean, Byte, Character, Double, Float,
Integer, Long and Short.
 Each type-wrapper class enables you to manipulate
primitive-type values as objects.
 Collections cannot manipulate variables of primitive

types.
◦ They can manipulate objects of the type-wrapper classes,
because every class ultimately derives from Object.

19
 Each of the numeric type-wrapper classes—Byte,
Short, Integer, Long, Float and Double—
extends class Number.
 The type-wrapper classes are final classes, so you

cannot extend them.

 Primitive types do not have methods, so the methods

related to a primitive type are located in the

corresponding type-wrapper class.

20
 A boxing conversion converts a value of a primitive type to an
object of the corresponding type-wrapper class.
 An unboxing conversion converts an object of a type-wrapper
class to a value of the corresponding primitive type.
 These conversions can be performed automatically (called
autoboxing and auto-unboxing).
 Example:
◦ // create integerArray
Integer[] integerArray = new Integer[ 5 ];
// assign Integer 10 to integerArray[ 0 ]
integerArray[ 0 ] = 10;
// get int value of Integer int value =
integerArray[ 0 ];

21
 In this case, autoboxing occurs when assigning an int
value (10) to integerArray[0], because integerArray
stores references to Integer objects, not int values.
 Auto-unboxing occurs when assigning integerArray[0]

to int variable value, because variable value stores an

int value, not a reference to an Integer object.
 Boxing conversions also occur in conditions, which can

evaluate to primitive boolean values or Boolean objects

22
 Interface Collection is the root interface from which
interfaces Set, Queue and List are derived.
 Interface Set defines a collection that does not contain
duplicates.
 Interface Queue defines a collection that represents a waiting
line.
 Interface Collection contains bulk operations for adding,
clearing and comparing objects in a collection.
 A Collection can be converted to an array.
 Interface Collection provides a method that returns an
Iterator object, which allows a program to walk through the
collection and remove elements from the collection during the
iteration.
 Class Collections provides static methods that search,
sort and perform other operations on collections.

23
 A List (sometimes called a sequence) is a Collection
that can contain duplicate elements.
 List indices are zero based.
 In addition to the methods inherited from Collection,
List provides methods for manipulating elements via their
indices, manipulating a specified range of elements,
searching for elements and obtaining a ListIterator to
access the elements.
 Interface List is implemented by several classes, including
ArrayList, LinkedList and Vector.
 Autoboxing occurs when you add primitive-type values to
objects of these classes, because they store only references
to objects.

24
 List method add adds an item to the end of a list.
 List method size return the number of elements.
 List method get retrieves an individual element’s value from the
specified index.
 Collection method iterator gets an Iterator for a
Collection.
 Iterator- method hasNext determines whether a Collection
contains more elements.
◦ Returns true if another element exists and false otherwise.
 Iterator method next obtains a reference to the next element.
 Collection method contains determine whether a
Collection contains a specified element.
 Iterator method remove removes the current element from a
Collection.

25
26
27
28
 New in Java SE 7: Type Inference with the <> Notation
◦ Lines 14 and 21 specify the type stored in the ArrayList
(that is, String) on the left and right sides of the
initialization statements.
◦ Java SE 7 supports type inferencing with the <> notation in
statements that declare and create generic type variables and
objects. For example, line 14 can be written as:

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

◦ Java uses the type in angle brackets on the left of the

declaration (that is, String) as the type stored in the
ArrayList created on the right side of the declaration.

29
 Anonymous class is an inner class without a name,
which means that we can declare and instantiate class
at the same time.
 An anonymous class is used primarily when we want to

use the class declaration once.

 Anonymous classes usually extend a subclass or

implement an interface.

30
import java.util.ArrayList; import java.util.Arrays;
import java.util.Comparator; import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(1, 3, 4, 5, 2) );
Comparator<Integer> comparator = new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
};
list.sort(comparator);
System.out.println(Arrays.toString(list.toArray()));
}
} 31
 Output: [1, 2, 3, 4, 5]
 In this example, we created an anonymous inner class

i.e. new Comparator<Integer>() {} that implements

the Comparator interface and overrides
the compare() method.
 Lambda Expression
 Lambda expression is an anonymous function that takes

in parameters and returns a value. It is called an

anonymous function because it doesn't require a name.
 Syntax: (parameter1, parameter2, ...) -> expression

(parameter1, parameter2, ...) -> { body }

32
 The Syntax of Lambda Expression in Java consists of
three components.
 Arguments-list: It is the first portion of the Lambda

expression in Java. It can also be empty or non-empty.

In the expression, it is enclosed by a round bracket.
 Lambda operator ->: It's an arrow sign that appears

after the list of arguments. It connects the arguments-

list with the body of the expression.
 Body: It contains the function body of lambda

expression. It is surrounded by curly brackets.

33
import java.util.ArrayList; import java.util.Arrays;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
int sum = list.stream().reduce(0, (a, b) -> a + b);
System.out.println(sum);
}
}
Output: 15

34
Object Serialization

35
 Object serialization in Java refers to the process of
converting an object's state (its data and behavior) into a
byte stream, which can then be stored on disk or
transmitted over a network.
 The reverse process, in which an object is reconstructed

from its serialized byte stream, is called deserialization.

 To read an entire object from or write an entire object to a

file, Java provides object serialization.

 After a serialized object has been written into a file, it can

be read from the file and deserialized to recreate the

object in memory.
In Java, object serialization is achieved through the use of
the java.io.Serializable interface, which is a marker
interface that indicates that a class can be serialized.
To make a class serializable, you simply need to implement
the Serializable interface, like this:

import java.io.Serializable;
public class Person implements Serializable {
private String name;
private int age;
// other fields and methods
}
Once a class is serializable, you can serialize and deserialize
instances of that class using the ObjectOutputStream and
ObjectInputStream classes, respectively.
Here is an example of how to serialize an object:

Person person = new Person("Alice", 25);

try (FileOutputStream fos = new FileOutputStream("person.ser");
ObjectOutputStream oos = new ObjectOutputStream(fos)) {
oos.writeObject(person);
} catch (IOException e) {
e.printStackTrace();
}
In this example, we create a Person object and then use an
ObjectOutputStream to write the object to a file named person.ser.
To deserialize the object, we would use an ObjectInputStream:

try (FileInputStream fis = new FileInputStream("person.ser");

ObjectInputStream ois = new ObjectInputStream(fis)) {
Person person = (Person) ois.readObject();
System.out.println(person.getName()); // "Alice"
System.out.println(person.getAge()); // 25 }
catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
In this example, we read the serialized Person object from the file
using an ObjectInputStream and then cast the result to a Person
object.
Once we have the Person object, we can use its methods to access its
state.
Object serialization in Java is a powerful feature that allows you to
save the state of an object to disk or transmit it over a network,
making it a useful tool for many types of applications.
However, it is important to note that serialization can also be a
security risk, since a malicious user could potentially use a serialized
object to execute arbitrary code.
As a result, you should take care to properly validate any serialized
objects that your code receives.
Declarative programming

41
Declarative programming and imperative programming are
two different paradigms of programming, each with its own
approach to writing code.
Declarative programming is a programming paradigm
emphasizes what the program should accomplish, rather than

how it should accomplish it.

the programmer specifies the rules, constraints, or logic that

describe the desired outcome.

That use a higher-level of abstraction, which enables the

programmer to write more concise and expressive code.

Examples of declarative programming in Java include

functional programming, the Stream API, and SQL.

42
Imperative programming, on the other hand, is a
programming paradigm that emphasizes how the program
should accomplish the task at hand.
Imperative programming,
the programmer specifies a series of step-by-step

instructions for the computer to execute.

are often low-level and closer to the hardware, making

them more efficient for certain types of tasks.

Java is primarily an imperative programming language,

although Java 8 introduced functional programming features

that allow for a more declarative style of programming.
43
 Overall, declarative programming is a useful approach for
tasks that require a higher-level of abstraction,
 while imperative programming is a better choice for tasks that
require low-level control over the computer's hardware
resources.
 Both paradigms can be used effectively in Java, depending on
the specific requirements of the task at hand.

44
1.Functional programming: In Java 8 and later versions, you can
write functions as lambda expressions and pass them around as
arguments.
This approach emphasizes what the code should do, rather than

how it should do it.

For example, the following code uses a lambda expression to

sort a list of strings in descending order:

List<String> names = Arrays.asList("John", "Alice", "Bob");

names.sort((s1, s2) -> s2.compareTo(s1));

45
2. Stream API: The Stream API in Java provides a declarative
way to process collections of data.
You can chain together a series of operations, such as filter,
map, and reduce, to specify what you want to do with the data.
For example, the following code uses the Stream API to count
the number of even integers in a list:

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9);

long count = numbers.stream()
.filter(n -> n % 2 == 0)
.count();

46
3. SQL queries: You can use Java Database Connectivity (JDBC) to write
declarative SQL queries to interact with databases.
The SQL queries specify what data you want to retrieve or modify, rather
than how to retrieve or modify it.
For example, the following code retrieves all records from a database
table:
String sql = "SELECT * FROM employees";
try (Connection conn = DriverManager.getConnection(url,
user,password);
Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql)) {
// process the results
}
catch (SQLException e) {
// handle the exception
} 47