Government Engineering College

Bilaspur, (C.G.)

Session :- 2021-22
Semester :- 4th

Lab Report
Subject :- Object Oriented Programming
(with JAVA) Laboratory

Submitted To - Submitted By -
Ms. Sonia Wadhwa Name- Gaurav Thawait
Branch – CSE
Roll No.- 300702220014
 INDEX

S.N. Name of Experiment P.N.

1. Introduction to JAVA, History of java, Principle, 3 - 13
Features, Installation of JAVA.
2. Write a program in Java to read from console 14 - 15
employee details with following details: Employee Id,
Name of employee, Salary. Print the details of every
employee.
3. Write a program to show the use 'this' keyword to call 16 - 17
the default and parameterized constructors.

4. Create a Shape Interface which has a member method 18 - 19

area(). Derive two subclasses Circle and Triangle from
it. Using reference of Shape class fill the required
members in Circle and Triangle also display the area
of Circle and Triangle. Take input from user while
filling data members.

5. Write a program to demonstrate the effect of access 20 - 23

modifiers (default, protected, public and private) on
members with and without inheritance within a
package and outside a package.

6. Write a program to show inbuilt and user defined: 24 - 25

checked and unchecked exceptions.
7. Write a program to show the use of various member 26 - 27
methods of String class.

8. Develop a Java program to demonstrate the use of 28 - 30

HashSet, Tree Set, Array List, LinkedList classes.

[1]
9. Develop a Java program to demonstrate the use of 31
generics.

10. Create and run an executable JAR. 32 - 33

11. A Java program for a Client side and Server side. 34 - 38

[2]
 Introduction to JAVA
Java is a high-level, class-based, object-oriented programming language
that is designed to have as few implementation dependencies as
possible. It is a general-purpose programming language intended to let
programmers write once, run anywhere (WORA), meaning that
compiled Java code can run on all platforms that support Java without
the need to recompile. Java applications are typically compiled to
bytecode that can run on any Java virtual machine (JVM) regardless of
the underlying computer architecture. The syntax of Java is similar to C
and C++, but has fewer low-level facilities than either of them. The Java
runtime provides dynamic capabilities (such as reflection and runtime
code modification) that are typically not available in traditional compiled
languages. As of 2019, Java was one of the most popular programming
languages in use according to GitHub.

History of JAVA
James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java
language project in June 1991. Java was originally designed for
interactive television, but it was too advanced for the digital cable
television industry at the time. The language was initially called Oak after
an oak tree that stood outside Gosling’s office. Later the project went by
the name Green and was finally renamed Java.

Sun Microsystems released the first public implementation as Java 1.0

in 1996. It promised write once, run anywhere (WORA) functionality,
providing no-cost run-times on popular platforms.

The Java 1.0 compiler was re-written in Java by Arthur van Hoff to
comply strictly with the Java 1.0 language specification. With the advent
of Java 2 (released initially as J2SE 1.2 in December 1998 – 1999), new
versions had multiple configurations built for different types of
[3]
platforms. J2EE included technologies and APIs for enterprise
applications typically run in server environments, while J2ME featured
APIs optimized for mobile applications. The desktop version was
renamed J2SE. In 2006, for marketing purposes, Sun renamed new J2
versions as Java EE, Java ME, and Java SE, respectively

Principles
There were five primary goals in the creation of the Java language:
• It must be simple, object-oriented, and familiar.
• It must be robust and secure.
• It must be architecture-neutral and portable.
• It must execute with high performance.
• It must be interpreted, threaded, and dynamic.

Versions
As of September 2021, Java 8, 11 and 17 are supported as Long-Term
Support (LTS) versions. Major release versions of Java, along with their
release dates:

Version Date
JDK 1995

JDK 1.0 January 23, 1996

JDK 1.1 February 19, 1997

J2SE 1.2 December 8, 1998

J2SE 1.3 May 8, 2000

J2SE 1.4 February 6, 2002

J2SE 5.0 September 30, 2004

[4]
 Java SE 6 December 11, 2006

Java SE 7 July 28, 2011

Java SE 8 (LTS) March 18, 2014

Java SE 9 September 21, 2017

Java SE 10 March 20, 2018

Java SE 11 (LTS) September 25, 2018

Java SE 12 March 19, 2019

Java SE 13 September 17, 2019

Java SE 14 March 17, 2020

Java SE 15 September 15, 2020

Java SE 16 March 16, 2021

Java SE 17 (LTS) September 14, 2021

Java SE 18 March 22, 2022

Features of JAVA
Following are the notable features of java :
Object Oriented
Java is an object-oriented programming language. Everything in Java is
an object. Object-oriented means we organize our software as a
combination of different types of objects that incorporate both data and
behavior.
Object-oriented programming (OOPs) is a methodology that simplifies
software development and maintenance by providing some rules.
[5]
Basic concepts of OOPs are:
• Object: Any entity that has state and behavior is known as an
object. For example, a chair, pen, table, keyboard, bike, etc. It can
be physical or logical. An Object can be defined as an instance of a
class. An object contains an address and takes up some space in
memory. Objects can communicate without knowing the details of
each other's data or code. The only necessary thing is the type of
message accepted and the type of response returned by the
objects.
• Class: Collection of objects is called class. It is a logical entity. A
class can also be defined as a blueprint from which you can create
an individual object. Class doesn't consume any space.
• Inheritance: When one object acquires all the properties and
behaviors of a parent object, it is known as inheritance. It provides
code reusability. It is used to achieve runtime polymorphism.
• Polymorphism: If one task is performed in different ways, it is
known as polymorphism. For example: to convince the customer
differently, to draw something, for example, shape, triangle,
rectangle, etc. In Java, we use method overloading and method
overriding to achieve polymorphism. Another example can be to
speak something; for example, a cat speaks meow, dog barks woof,
etc.
• Abstraction: Hiding internal details and showing functionality is
known as abstraction. For example, phone call, we don't know the
internal processing.
• Encapsulation: Binding (or wrapping) code and data together into
a single unit are known as encapsulation. For example, a capsule, it
is wrapped with different medicines. A java class is the example of
encapsulation. Java bean is the fully encapsulated class because all
the data members are private here.

[6]
Platform Independent
Java is platform independent because it is different from other
languages like C, C++, etc. which are compiled into platform specific
machines while Java is a write once, run anywhere language. A platform
is the hardware or software environment in which a program runs.
There are two types of platforms software-based and hardware-based.
Java provides a software-based platform.
The Java platform differs from most other platforms in the sense that it
is a software-based platform that runs on top of other hardware-based
platforms. It has two components:
• Runtime Environment
• API (Application Programming Interface)
Java code can be executed on multiple platforms, for example,
Windows, Linux, Sun Solaris, Mac/OS, etc. Java code is compiled by the
compiler and converted into bytecode. This bytecode is a platform-
independent code because it can be run on multiple platforms, i.e.,
Write Once and Run Anywhere (WORA).
Simple
Java is designed to be easy to learn. If you understand the basic concept
of OOP Java, it would be easy to master.
Secure
Java is best known for its security. With Java, we can develop virus-free
systems. Java is secured because:
• No explicit pointer
• Java Programs run inside a virtual machine sandbox
• Classloader: Classloader in Java is a part of the Java Runtime
Environment (JRE) which is used to load Java classes into the Java
Virtual Machine dynamically. It adds security by separating the
[7]
 package for the classes of the local file system from those that are
imported from network sources.
• Bytecode Verifier: It checks the code fragments for illegal code that
can violate access rights to objects.
• Security Manager: It determines what resources a class can access
such as reading and writing to the local disk.
Java language provides these securities by default. Some security can
also be provided by an application developer explicitly through SSL,
JAAS, Cryptography, etc.
Architecture-neutral
Java is architecture neutral because there are no implementation
dependent features, for example, the size of primitive types is fixed.
In C programming, int data type occupies 2 bytes of memory for 32-bit
architecture and 4 bytes of memory for 64-bit architecture. However, it
occupies 4 bytes of memory for both 32 and 64-bit architectures in Java.
Portable
Being architecture-neutral and having no implementation dependent
aspects of the specification makes Java portable. The compiler in Java is
written in ANSI C with a clean portability boundary, which is a POSIX
subset.
Robust
The English mining of Robust is strong. Java is robust because:
• It uses strong memory management.
• There is a lack of pointers that avoids security problems.
• Java provides automatic garbage collection which runs on the Java
Virtual Machine to get rid of objects which are not being used by a
Java application anymore.

[8]
 • There are exception handling and the type checking mechanism in
Java. All these points make Java robust.
Multithreaded
With Java's multithreaded feature it is possible to write programs that
can perform many tasks simultaneously. This design feature allows the
developers to construct interactive applications that can run smoothly.
Interpreted
Java byte code is translated on the fly to native machine instructions and
is not stored anywhere. The development process is more rapid and
analytical since the linking is an incremental and light-weight process.
High Performance
Java is faster than other traditional interpreted programming languages
because Java bytecode is "close" to native code. It is still a little bit
slower than a compiled language (e.g., C++). Java is an interpreted
language that is why it is slower than compiled languages, e.g., C, C++,
etc.
Distributed
Java is distributed because it facilitates users to create distributed
applications in Java. RMI and EJB are used for creating distributed
applications. This feature of Java makes us able to access files by calling
the methods from any machine on the internet.
Dynamic
Java is considered to be more dynamic than C or C++ since it is designed
to adapt to an evolving environment. Java programs can carry an
extensive amount of run-time information that can be used to verify and
resolve accesses to objects at run-time.

[9]
 Installation of Java
JavaFX Environment
We have to set the JavaFX environment on the system in order to run
JavaFX Applications. All the versions of Java after JDK 1.8, supports
JavaFX therefore we must have JDK 1.8 or later installed on our system.
There are various IDE such as Net-beans or Eclipse also supports JavaFX
Library. In this chapter, we will discuss the various ways of executing
JavaFX applications.
Install Java
Verify that it is already installed or not
• Open a command prompt by typing cmd in the search bar and press
Enter.
• Run the following command:
java -version

Download Java for Windows 10

• Using your preferred web browser, navigate to the Oracle Java
Downloads page.
• On the Downloads page, click the x64 Installer download link under
the Windows category. At the time of writing this article, Java
version 17 is the latest long-term support Java version.
Install Java on Windows 10
After downloading the installation file, proceed with installing Java on
your Windows system.
Follow the steps below:
Step 1: Run the Downloaded File
Double-click the downloaded file to start the installation.
[10]
Step 2: Configure the Installation Wizard
After running the installation file, the installation wizard welcome screen
appears.
1. Click Next to proceed to the next step.
2. Choose the destination folder for the Java installation files or stick
to the default path. Click Next to proceed.
3. Wait for the wizard to finish the installation process until the
Successfully Installed message appears. Click Close to exit the
wizard.
Set Environmental Variables in Java
Set Java environment variables to enable program compiling from any
directory. To do so, follow the steps below:
Step 1: Add Java to System Variables
1. Open the Start menu and search for environment variables.
2. Select the Edit the system environment variables result.
3. In the System Properties window, under the Advanced tab, click
Environment Variables…
4. Under the System variables category, select the Path variable and
click Edit
5. Click the New button and enter the path to the Java bin directory
Note: The default path is usually C:\Program Files\Java\jdk-
17.0.1\bin.
6. Click OK to save the changes and exit the variable editing window.
Step 2: Add JAVA_HOME Variable
Some applications require the JAVA_HOME variable. Follow the steps
below to create the variable:
1. In the Environment Variables window, under the System variables
category, click the New… button to create a new variable.
[11]
 2. Name the variable as JAVA_HOME.
3. In the variable value field, paste the path to your Java jdk directory
and click OK.
4. Confirm the changes by clicking OK in the Environment Variables
and System properties windows.

Test the JAVA installation

Run the java -version command in the command prompt to make sure
Java installed correctly:
Running the java command to see Java version on Windows.
If installed correctly, the command outputs the Java version. Make sure
everything works by writing a simple program and compiling it. Follow
the steps below:
Step 1: Write a Test Java Script
1. Open a text editor such as Notepad++ and create a new file.
2. Enter the following lines of code and click Save:

class HelloWorld {
public static void main (String args[]){
System.out.println("Hello world!");
}
}
3. Name the file HelloWorld same as class and save it as a Java source
file (*.java).
Step 2: Compile the Test Java Script
1. In the command prompt, change the directory to the file's location
and use the following syntax to compile the program
javac [filename]
2. Run the program with the following syntax:
[12]
java [filename]
The output shows that the program runs correctly, displaying the
Hello world! message.

[13]
 Experiment - (1)
Write a program in Java to read from console employee details with following
details: Employee Id, Name of employee, Salary. Print the details of every
employee.

import java.util.Scanner;
class Employee {
int id;
String name;
float sal;
}

class Main2 {
public static void main(String args[]) {

Scanner sc = new Scanner(System.in);

System.out.print("Enter How many employee:");
int k = sc.nextInt();

Employee emp[] = new Employee[k];

for (int i = 0; i < k; i++) {

emp[i] = new Employee();

System.out.println("Enter " + (i + 1) + " Employee data :");

System.out.print("Enter employee id :");

emp[i].id = sc.nextInt();
System.out.print("Enter employee name :");
emp[i].name = sc.next();
System.out.print("Enter employee salary :");
emp[i].sal = sc.nextFloat();

System.out.println("\n\n============ All employee details are

:============\n");

[14]
 for (int i = 0; i < k; i++) {
System.out.println("Employee id name and salary :" + emp[i].id + " " +
emp[i].name + " " + emp[i].sal);

}
}
}

Output :-

[15]
 Experiment - (2)
Write a program to show the use 'this' keyword to call the default and
parameterized constructors.

class Student {
int rollno;
String name;
float fee;
Student(int rollno,String name,float fee){
this.rollno=rollno;
this.name=name;
this.fee=fee;
}
void display(){System.out.println(rollno+" "+name+" "+fee);}
}

class TestThis2{
public static void main(String args[]){
Student s1=new Student(111,"ankit",5000f);
Student s2=new Student(112,"sumit",6000f);
s1.display();
s2.display();
}
Output :-

Calling default constructor from parameterized constructor:

class A{
A(){System.out.println("hello a");}
A(int x){
[16]
 this();
System.out.println(x);
}
}
class TestThis5{
public static void main(String args[]){
A a=new A(10);
}
}

Output :-

Calling parameterized constructor from default constructor:

class A{
A(){
this(5);
System.out.println("hello a");
}
A(int x){
System.out.println(x);
}
}
class TestThis6{
public static void main(String args[]){
A a=new A();
}
}
Output :-

[17]
 Experiment - (3)
Create a Shape Interface which has a member method area(). Derive two
subclasses Circle and Triangle from it. Using reference of Shape class fill the
required members in Circle and Triangle also display the area of Circle and
Triangle. Take input from user while filling data members.

import java.util.Scanner;
interface Shape{
public double area();
}
class Circle implements Shape{
Scanner s = new Scanner(System.in);
double radius = s.nextDouble();

public double area(){

return 3.14 * radius * radius;
}
}
class Triangle implements Shape{
Scanner sc = new Scanner(System.in);
double height = sc.nextDouble();
double base = sc.nextDouble();

public double area(){

return (height * base)/2;
}
}

class InterfaceDemo{
public static void main(String args[]){
System.out.println("Enter the Value of Radius=");
Circle c = new Circle();
System.out.println("Area of circle: " + c.area());
System.out.println("Enter the Value of Height=");
System.out.println("Enter the Value of Base=");
Triangle t = new Triangle();
System.out.println("Area of triangle: " + t.area());
[18]
 }
}

Output :-

[19]
 Experiment - (4)
Write a program to demonstrate the effect of access modifiers (default,
protected, public and private) on members with and without inheritance
within a package and outside a package.

Private class A{
private int data=40;
private void msg(){System.out.println("Hello java");}
}
public class Simple{
public static void main(String args[]){
A obj=new A();
System.out.println(obj.data);//Compile Time Error
obj.msg();//Compile Time Error
}
}

Role of Private Constructor :

If you make any class constructor private, you cannot create the instance of that class
from outside the class. For example:

class A{
private A(){}//private constructor
void msg(){System.out.println("Hello java");}
}
public class Simple{
public static void main(String args[]){
A obj=new A();//Compile Time Error
}
}

2) Default :
If you don't use any modifier, it is treated as default by default. The default modifier is
accessible only within package. It cannot be accessed from outside the package. It
provides more accessibility than private. But, it is more restrictive than protected, and
public.
Example of default access modifier :
[20]
In this example, we have created two packages pack and mypack. We are accessing the
A class from outside its package, since A class is not public, so it cannot be accessed
from outside the package.

//save by A.java
package pack;
class A{
void msg(){System.out.println("Hello");}
}
//save by B.java
package mypack;
Import pack.*;
class B{
public static void main(String args[]){
A obj = new A();//Compile Time Error
obj.msg();//Compile Time Error
}
}
In the above example, the scope of class A and its method msg() is default so it cannot
be accessed from outside the package.

3) Protected :
The protected access modifier is accessible within package and outside the package
but through inheritance only.
The protected access modifier can be applied on the data member, method and
constructor. It can't be applied on the class.
It provides more accessibility than the default modifer.
Example of protected access modifier :
In this example, we have created the two packages pack and mypack. The A class of
pack package is public, so can be accessed from outside the package. But msg method
of this package is declared as protected, so it can be accessed from outside the class
only through inheritance.

//save by A.java
package pack;
public class A{
protected void msg(){System.out.println("Hello");}
}
[21]
 //save by B.java
package mypack;
import pack.*;
class B extends A{
public static void main(String args[]){
B obj = new B();
obj.msg();
}
}
Output :- Hello

4) Public :
The public access modifier is accessible everywhere. It has the widest scope among all
other modifiers.
Example of public access modifier :

//save by A.java
package pack;
public class A{
public void msg(){System.out.println("Hello");}
}
//save by B.java
package mypack;
import pack.*;
class B{
public static void main(String args[]){
A obj = new A();
obj.msg();
}
}

Output :- Hello

Java Access Modifiers with Method Overriding :

If you are overriding any method, overridden method (i.e. declared in subclass) must
not be more restrictive.

[22]
 class A{
protected void msg(){System.out.println("Hello java");}
}
public class Simple extends A{
void msg(){System.out.println("Hello java");}//C.T.Error
public static void main(String args[]){
Simple obj=new Simple();
obj.msg();
}
}

The default modifier is more restrictive than protected. That is why, there is a compile-
time error.

[23]
 Experiment - (5)
Write a program to show inbuilt and user defined: checked and unchecked
exceptions.

Checked Exception :
import java.io.*;
class Example {
public static void main(String args[])
{
FileInputStream fis = null;
/*This constructor FileInputStream(File filename)
* throws FileNotFoundException which is a checked
* exception */
fis = new FileInputStream("B:/myfile.txt");
int k;

/* Method read() of FileInputStream class also throws

* a checked exception: IOException */

while(( k = fis.read() ) != -1)

{
System.out.print((char)k);
}
/*The method close() closes the file input stream
* It throws IOException*/
fis.close();
}
}

Output :-

Exception in thread "main" java.lang.Error: Unresolved compilation problems:

Unhandled exception type FileNotFoundException
Unhandled exception type IOException
Unhandled exception type IOException

[24]
 Unchecked Exceptions :

public class Unchecked_Demo {

public static void main(String args[]) {
Int num[] = {1, 2, 3, 4};
System.out.println(num[5]);
}
}

Output :- Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5

at Exceptions.Unchecked_Demo.main(Unchecked_Demo.java:8)

[25]
 Experiment - (6)
Write a program to show the use of various member methods of String
class.

class StringMethodsDemo {
public static void main(String[] args) {
String targetString = "Java is fun to learn";
String s1= "JAVA";
String s2= "Java";
String s3 = " Hello Java ";

System.out.println("Char at index 2(third position): " + targetString.charAt(2));

System.out.println("After Concat: "+ targetString.concat("-Enjoy-"));
System.out.println("Checking equals ignoring case: " +s2.equalsIgnoreCase(s1));
System.out.println("Checking equals with case: " +s2.equals(s1));
System.out.println("Checking Length: "+ targetString.length());
System.out.println("Replace function: "+ targetString.replace("fun", "easy"));
System.out.println("SubString of targetString: "+ targetString.substring(8));
System.out.println("SubString of targetString: "+ targetString.substring(8, 12));
System.out.println("Converting to lower case: "+ targetString.toLowerCase());
System.out.println("Converting to upper case: "+ targetString.toUpperCase());
System.out.println("Triming string: " + s3.trim());
System.out.println("searching s1 in targetString: " + targetString.contains(s1));
System.out.println("searching s2 in targetString: " + targetString.contains(s2));

char [] charArray = s2.toCharArray();

System.out.println("Size of char array: " + charArray.length);
System.out.println("Printing last element of array: " + charArray[3]);
}
}

[26]
Output :-

[27]
 Experiment - (7)
Develop a Java program to demonstrate the use of HashSet, TreeSet,
ArrayList, LinkedList classes.

Array list :
import java.util.*;
public class ArrayListExample1{
public static void main(String args[]){
ArrayList<String> list=new ArrayList<String>();//Creating arraylist
list.add("Mango");//Adding object in arraylist
list.add("Apple");
list.add("Banana");
list.add("Grapes");
//Printing the arraylist object
System.out.println(list);
}
}
Output :- Compile by: javac ArrayListExample1.java
Run by: java ArrayListExample1
[Mango, Apple, Banana, Grapes]

Linkedlist :
import java.util.*;
public class LinkedList1{
public static void main(String args[]){
LinkedList<String> al=new LinkedList<String>();
al.add("Ravi");
al.add("Vijay");
al.add("Ravi");
al.add("Ajay");

Iterator<String> itr=al.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
}
}
[28]
Output :- Ravi
Vijay
Ravi
Ajay

Hashset :
import java.util.*;
class HashSet1{
public static void main(String args[]){
//Creating HashSet and adding elements
HashSet<String> set=new HashSet();
set.add("One");
set.add("Two");
set.add("Three");
set.add("Four");
set.add("Five");
Iterator<String> i=set.iterator();
while(i.hasNext())
{
System.out.println(i.next());
}
}
}
Output :- Five
One
Four
Two
Three

TreeSet :
import java.util.*;
class TreeSet1{
public static void main(String args[]){
//Creating and adding elements
TreeSet<String> al=new TreeSet<String>();
al.add("Ravi");
al.add("Vijay");
[29]
 al.add("Ravi");
al.add("Ajay");
//Traversing elements
Iterator<String> itr=al.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
}
}

Output :- Ajay
Ravi
Vijay

[30]
 Experiment - (8)
Develop a Java program to demonstrate the use of generics.

public class TestGenerics4{

public static < E > void printArray(E[] elements) {
for ( E element : elements){
System.out.println(element );
}
System.out.println();
}
public static void main( String args[] ) {
Integer[] intArray = { 10, 20, 30, 40, 50 };
Character[] charArray = { 'J', 'A', 'V', 'A', 'T','P','O','I','N','T' };

System.out.println( "Printing Integer Array" );

printArray( intArray );
System.out.println( "Printing Character Array" );
printArray( charArray );
}
}
Output :- Printing Integer Array
10
20
30
40
50

Printing Character Array

J
A
V
A
T
P
O
I

[31]
 Experiment - (9)
Create and run an executable JAR.
Creating manifest file
To create manifest file, you need to write Main-Class, then colon, then space, then
classname then enter. For example:
myfile.mf
Main-Class: First
Creating executable jar file using jar tool
The jar tool provides many switches, some of them are as follows:
-c creates new archive file
-v generates verbose output. It displays the included or extracted resource on the
standard output.
-m includes manifest information from the given mf file.
-f specifies the archive file name
-x extracts files from the archive file
Now, let's write the code to generated the executable jar using mf file.
You need to write jar then swiches then mf_file then jar_file then .classfile as given
below:
jar -cvmf myfile.mf myjar.jar First.class
It is shown in the image given below:

Now it will create the executable jar file. If you double click on it, it will call the main
method of the First class.

First.java
import javax.swing.*;
public class First{
First(){
JFrame f=new JFrame();

[32]
JButton b=new JButton("click");
b.setBounds(130,100,100, 40);

f.add(b);

f.setSize(300,400);
f.setLayout(null);
f.setVisible(true);

f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String[] args) {
new First();
}
}

[33]
 Experiment - (10)
A Java program for a Client side and Server side.

Client side
// A Java program for a Client
import java.net.*;
import java.io.*;

public class Client

{
// initialize socket and input output streams
private Socket socket = null;
private DataInputStream input = null;
private DataOutputStream out = null;

// constructor to put ip address and port

public Client(String address, int port)
{
// establish a connection
try
{
socket = new Socket(address, port);
System.out.println("Connected");

// takes input from terminal

input = new DataInputStream(System.in);

// sends output to the socket

out = new DataOutputStream(socket.getOutputStream());
}
catch(UnknownHostException u)
{
System.out.println(u);
}
catch(IOException i)
{
System.out.println(i);
[34]
 }

// string to read message from input

String line = "";

// keep reading until "Over" is input

while (!line.equals("Over"))
{
try
{
line = input.readLine();
out.writeUTF(line);
}
catch(IOException i)
{
System.out.println(i);
}
}

// close the connection

try
{
input.close();
out.close();
socket.close();
}
catch(IOException i)
{
System.out.println(i);
}
}

public static void main(String args[])

{
Client client = new Client("127.0.0.1", 5000);
}
}

[35]
Server side
// A Java program for a Server
import java.net.*;
import java.io.*;

public class Server

{
//initialize socket and input stream
private Socket socket = null;
private ServerSocket server = null;
private DataInputStream in = null;

// constructor with port

public Server(int port)
{
// starts server and waits for a connection
try
{
server = new ServerSocket(port);
System.out.println("Server started");

System.out.println("Waiting for a client ...");

socket = server.accept();
System.out.println("Client accepted");

// takes input from the client socket

in = new DataInputStream(
new BufferedInputStream(socket.getInputStream()));

String line = "";

// reads message from client until "Over" is sent

while (!line.equals("Over"))
{
try
{
line = in.readUTF();
[36]
 System.out.println(line);

}
catch(IOException i)
{
System.out.println(i);
}
}
System.out.println("Closing connection");

// close connection
socket.close();
in.close();
}
catch(IOException i)
{
System.out.println(i);
}
}

public static void main(String args[])

{
Server server = new Server(5000);
}
}

Output :-

To run on Terminal or Command Prompt

Open two windows one for Server and another for Client
1. First run the Server application as ,
$ java Server
Server started
Waiting for a client …
2. Then run the Client application on another terminal as,
$ java Client
It will show – Connected and the server accepts the client and shows,
Client accepted
[37]
3. Then you can start typing messages in the Client window. Here is a sample input
to the Client
Hello
I made my first socket connection
Over
Which the Server simultaneously receives and shows,
Hello
I made my first socket connection
Over
Closing connection

[38]