UNIT 1

1.1 Components Of Java Programming Language

A Java Programmer writes a program in a human-readable language, called Source
Code. The CPU or Central Processing Unit or Chips do not understand the source
code written in any programming language. These chips or computers understand
only one thing: Machine Code or Machine Language. These machine codes run at
CPU level; hence, it would be different machine codes for different models of CPU.

We need not to worry about the machine code, as programming for us is all about the
source code.  To help the machine to understand the source code, it needs to be
converted into a machine level language which is an executable code.

All these functionalities happen inside following 3 components of Java Programming

Language:

 Java Virtual Machine (JVM)

 Java Runtime Environment (JRE)
 Java Development Kit (JDK).

Let us discuss these 3 components of Java programming language in detail

What is JVM?

JVM stands for Java Virtual Machine and it is the center of Java programming
language and Java platform. Java Virtual Machine (JVM) is an engine that provides a
runtime environment to drive the Java Code or applications. It performs the operation
of converting Java bytecode into machine language. JVM is a part of JRE. It cannot
be separately installed, to install JVM you need to install JRE.

Usage of JVM:

 JVM is platform independent and this factor helps the developer to create Java Programs on
one machine and execute them on another machine.
 JVM provides numerous libraries, tools and frameworks
 JVM comes up with JIT (Just-In-Time) compiler that converts Java source code into low-level
machine language. It is the reason that JVM is faster as a regular application.

Did You Know? There are 3 billion phones and counting number of mobile
phones that are running help of the platform built using Java

What is JRE?

JRE stands for Java Runtime Environment. It is a runtime environment that is

required to execute Java programs and applications. JRE contains JVM and binaries
and other classes to successfully execute Java programs. It does not have tool for Java
development like a debugger, compiler etc.

If anyone wants to run Java programs in their machines then it is must that you have
JRE installed on your machine. It’s a platform dependent, it means you need to
download and install JRE that are compatible with your Operating System and
architecture.

What is JDK?
JDK is the core component of Java environment. It contains JRE (Java Runtime
Environment) along with Java compiler, Java debugger, and other classes. JDK is
used for Java development as it provides the entire executable and binaries as well as
tools required to compile, debug a Java program. JDK is a superset of JRE as it
contains JRE and development tools.

Now that we have discussed the 3 main components of Java language along with their
functionalities and how they are related to each other, we are ready to download Java
Development Kit here and start writing Java programs.

With so many different Java terms around it is always to have a Java Glossary handy,
which you can refer here.

Programmers write programs to communicate with the computer. However,  each of

the many programming languages comes with its own unique features and provides
different kinds of applications. As each programming language is different, a
particular one might be best suited for a specific purpose or for specific industries.

In continuation of our discussion, now, let us look at some of the applications Java
provides.

Some of the applications of Java programs:

 1. Mobile applications: One of the prominent applications of Java is developing Mobile
applications. Java platform, Micro Edition is a cross-platform framework which is used to
develop applications across all the Java supporting devices. This framework is used to
develop the features of smartphones. Applications for the popular mobile operating system
android are developed using Java, using the Android Software Development Kit (SDK) or
other environments.

 Desktop GUI applications: The other important application of Java is that it  provides GUI
development through various means like Abstract Windowing Toolkit(AWT), JavaFX and
Swing.
 Web applications: Java provides many web applications through Servlets, Struts and JSP’s.
With the flexibility that Java provides, one can easily develop web applications as per the
customer requirements.
 Enterprise applications: Java programming language would be the first choice of developers
when it comes to developing enterprise applications because of its features that match the
requirements. The application which is distributed in nature such as banking application is
the example of enterprise applications. Java EE platform is designed in such a way that
reduces the complexity of enterprise application development.
 Scientific applications: Java is the preferred programming language for developing scientific
applications. Most of the scientific software are written in Java.

Difference Between JVM VS JRE VS JDK

The major differences between JVM VS JRE VS JDK are as follows:

JVM JRE JDK

The acronym of JVM The acronym of JRE The acronym of JDK is Java
is Java Virtual is Java Runtime Development Kit
Machine Environment
JVM is platform JRE is platform
JDK is platform dependent
independent independent
JVM is a subset of JRE is subset of
JDK is a superset of JDK
JRE JDK
JVM is a Java The JDK enables  the
JRE is a part of
Platform Component developers to create Java
Java that creates
that executes programs which can be executed
the JVM
source code and run by JRE and JVM.
JVM bundled in both JRE only contain
software JDK and environment to JDK comes with the installer
JRE execute source code

Conclusion:  This has been a guide to discuss about What is Java, Features of Java
Programming Language, 3 Components of Java Programming such as JVM,
JRE and JDK and also about the Differences between JVM VS JDK VS JRE.

Here we have discussed about Java Development Kit which contains Java Runtime
Environment (JRE) and Java compiler. JRE in turn, contains JVM that is responsible
for converting byte code generated by Java compiler into machine-specific code.

If you think some more information needed to be added here or have any questions
related to any of the topic discussed above, then please share your feedback in the
comment section below.

In supplement to all the information discussed above, now we recommend you to go

through these online courses that contain a bundle of Java courses that can be of very
useful to you.

1.2 Event Handling In Java

Event handling in Java explains you how to handle the external events.

Event handling in Java explains you how to handle the external

events.

Event Handling In Java

In this section you will learn about how to handle events in Java. Events in any
programming language specifies the external effects that happens and your
application behaves according to that event. For example, an application produce an
output when a user inputs some data, or the data received from the network or it may
be something else. In Java when you works with the AWT components like button,
textbox, etc (except panel, label ) generates an event. This event is handled by the
listener. Event listener listens the event generated on components and performs the
corresponding action.

In Java event handling may comprised the following four classes :

 Event Sources : Sources for generating an event may be the components. In Java
java.awt.Component specifies the components that may or may not generate events. These
components classes are the subclass of the above class. These event sources may be the
button, combobox, textbox etc.
 
 Event Classes : Event Classes in Java are the classes defined for almost all the components
that may generate events. These events classes are named by giving the specific name such
as for the component source button the event class is ActionEvent. Following are the list of
Event Classes :
o ActionEvent : Button, TextField, List, Menu
o WindowEvent : Frame
o ItemEvent : Checkbox, List
o AdjustmentEvent : Scrollbar
o MouseEvent : Mouse
o KeyEvent : Keyboard
 
 Event Listeners : Event Listeners are the Java interfaces that provides various methods to use
in the implemented class. Listeners listens the event generated by a component. In Java
almost all components has its own listener that handles the event generated by the
component. For example, there is a Listener named ActionListener handles the events
generated from button, textfield, list, menus.
 
 Event Adapters : Event Adapters classes are abstract class that provides some methods used
for avoiding the heavy coding. Adapter class is defined for the listener that has more than
one abstract methods.

Example

Here I am giving a simple example which will demonstrate you about how to handle
an event. In this example we will give a simple example into which you will see how
an event generated after clicking on the button is handled. To handle the event you
would have to implement a corresponding listener and add the listener on the
component i.e. button. Then you have to override the method declared in the listener.

You can add the listener by following ways :

b.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent ae)
{
b = (JButton)ae.getSource();
sayHi();
}
});

In the second way you can add listener as follows :

b.addActionListener(this)

publi void actionPerformed(ActionEvent ae){

b = (JButton)ae.getSource();
sayHi();
}

EventHandlingExample.java

import javax.swing.*;
import java.awt.event.*;

public class EventHandlingExample implements ActionListener{

JFrame f;
JButton b=new JButton("Say Hi");
public void createUI()
{
f = new JFrame();
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setLayout(null);
JLabel tbLabel = new JLabel("Click On Button");
b.addActionListener(this);

tbLabel.setBounds(75, 50, 100, 20);

b.setBounds(75,75,150,20);

f.add(tbLabel);
f.add(b);
f.setVisible(true);
f.setSize(300,200);
}
public static void main(String[] args){
EventHandlingExample dd = new EventHandlingExample();
dd.createUI();
}

@Override
public void actionPerformed(ActionEvent e) {
b = (JButton)e.getSource();
sayHi();
}

public void sayHi()

{
JOptionPane.showMessageDialog(f, "Hi, To All.", "Say
Hi", JOptionPane.INFORMATION_MESSAGE);
}
}
Output :

When you will execute the above example you will get the output as follows :

1.3 Thread Concept in Java

Before introducing the thread concept, we were unable to run more than one task in
parallel. It was a drawback, and to remove that drawback, Thread Concept was
introduced.

A Thread is a very light-weighted process, or we can say the smallest part of the
process that allows a program to operate more efficiently by running multiple tasks
simultaneously.

In order to perform complicated tasks in the background, we used the Thread

concept in Java. All the tasks are executed without affecting the main program. In a
program or process, all the threads have their own separate path for execution, so each
thread of a process is independent.
Another benefit of using thread is that if a thread gets an exception or an error at the
time of its execution, it doesn't affect the execution of the other threads. All the
threads share a common memory and have their own stack, local variables and
program counter. When multiple threads are executed in parallel at the same time, this
process is known as Multithreading.

In a simple way, a Thread is a:

 Feature through which we can perform multiple activities within a single process.
 Lightweight process.
 Series of executed statements.
 Nested sequence of method calls.

Thread Model
Just like a process, a thread exists in several states. These states are as follows:
1) New (Ready to run)

A thread is in New when it gets CPU time.

2) Running

A thread is in a Running state when it is under execution.

3) Suspended

A thread is in the Suspended state when it is temporarily inactive or under execution.

4) Blocked

A thread is in the Blocked state when it is waiting for resources.

5) Terminated

A thread comes in this state when at any given time, it halts its execution
immediately.

Creating Thread
A thread is created either by "creating or implementing" the Runnable Interface or
by extending the Thread class. These are the only two ways through which we can
create a thread.

Let's dive into details of both these way of creating a thread:

Thread Class
A Thread class has several methods and constructors which allow us to perform
various operations on a thread. The Thread class extends the Object class. The
Object class implements the Runnable interface. The thread class has the following
constructors that are used to perform various operations.

 Thread()
 Thread(Runnable, String name)
 Thread(Runnable target)
 Thread(ThreadGroup group, Runnable target, String name)
 Thread(ThreadGroup group, Runnable target)
 Thread(ThreadGroup group, String name)
 Thread(ThreadGroup group, Runnable target, String name, long stackSize)

Runnable Interface(run() method)

The Runnable interface is required to be implemented by that class whose instances

are intended to be executed by a thread. The runnable interface gives us the run()
method to perform an action for the thread.

start() method

The method is used for starting a thread that we have newly created. It starts a new
thread with a new callstack. After executing the start() method, the thread changes
the state from New to Runnable. It executes the run() method when the thread gets
the correct time to execute it.

Let's take an example to understand how we can create a Java thread by extending the
Thread class:

ThreadExample1.java

1. // Implementing runnable interface by extending Thread class  
2. public class ThreadExample1 extends Thread {  
3.      // run() method to perform action for thread.   
4.      public void run()  
5.      {    
6.         int a= 10;  
7.         int b=12;  
8.         int result = a+b;  
9.         System.out.println("Thread started running..");  
10.         System.out.println("Sum of two numbers is: "+ result);  
11.      }  
12.      public static void main( String args[] )  
13.      {  
14.       // Creating instance of the class extend Thread class  
15.         ThreadExample1 t1 = new  ThreadExample1();  
16.         //calling start method to execute the run() method of the Thread class  
 17.         t1.start();  
18.      }  
19. }  

Output:

Creating thread by implementing the runnable interface

In Java, we can also create a thread by implementing the runnable interface. The
runnable interface provides us both the run() method and the start() method.

Let's takes an example to understand how we can create, start and run the thread using
the runnable interface.

ThreadExample2.java

1. class NewThread implements Runnable {  
2.     String name;  
3.     Thread thread;  
4.     NewThread (String name){  
5.         this.name = name;   
6.         thread = new Thread(this, name);  
7.         System.out.println( "A New thread: " + thread+ "is created\n" );  
8.         thread.start();  
9.     }  
10.     public void run() {  
11.     try {  
12.         for(int j = 5; j > 0; j--) {  
13.             System.out.println(name + ": " + j);  
14.             Thread.sleep(1000);  
15.         }  
16.     }catch (InterruptedException e) {  
17.         System.out.println(name + " thread Interrupted");  
18.     }  
 19.      System.out.println(name + " thread exiting.");  
20.     }  
21. }  
22. class ThreadExample2 {    
23.     public static void main(String args[]) {  
24.         new NewThread("1st");  
25.         new NewThread("2nd");  
26.         new NewThread("3rd");  
27.         try {  
28.             Thread.sleep(8000);  
29.         } catch (InterruptedException excetion) {  
30.             System.out.println("Inturruption occurs in Main Thread");  
31.         }  
32.         System.out.println("We are exiting from Main Thread");  
33.     }  
34. }  

Output:
In the above example, we perform the Multithreading by implementing the runnable
interface.

Java - Networking
Advertisements

Previous Page
Next Page  

The term network programming refers to writing programs that execute across
multiple devices (computers), in which the devices are all connected to each other
using a network.

The java.net package of the J2SE APIs contains a collection of classes and interfaces
that provide the low-level communication details, allowing you to write programs that
focus on solving the problem at hand.

The java.net package provides support for the two common network protocols −

TCP − TCP stands for Transmission Control Protocol, which allows for
reliable communication between two applications. TCP is typically used over
the Internet Protocol, which is referred to as TCP/IP.




UDP − UDP stands for User Datagram Protocol, a connection-less protocol

that allows for packets of data to be transmitted between applications.

This chapter gives a good understanding on the following two subjects −

Socket Programming − This is the most widely used concept in Networking

and it has been explained in very detail.




URL Processing − This would be covered separately. Click here to learn

about URL Processing in Java language.


Socket Programming
Sockets provide the communication mechanism between two computers using TCP.
A client program creates a socket on its end of the communication and attempts to
connect that socket to a server.

When the connection is made, the server creates a socket object on its end of the
communication. The client and the server can now communicate by writing to and
reading from the socket.

The java.net.Socket class represents a socket, and the java.net.ServerSocket class

provides a mechanism for the server program to listen for clients and establish
connections with them.

The following steps occur when establishing a TCP connection between two
computers using sockets −

The server instantiates a ServerSocket object, denoting which port number

communication is to occur on.

The server invokes the accept() method of the ServerSocket class. This
method waits until a client connects to the server on the given port.

After the server is waiting, a client instantiates a Socket object, specifying the
server name and the port number to connect to.

The constructor of the Socket class attempts to connect the client to the
specified server and the port number. If communication is established, the
client now has a Socket object capable of communicating with the server.

On the server side, the accept() method returns a reference to a new socket on
the server that is connected to the client's socket.

After the connections are established, communication can occur using I/O streams.
Each socket has both an OutputStream and an InputStream. The client's OutputStream
is connected to the server's InputStream, and the client's InputStream is connected to
the server's OutputStream.

TCP is a two-way communication protocol, hence data can be sent across both
streams at the same time. Following are the useful classes providing complete set of
methods to implement sockets.

ServerSocket Class Methods

The java.net.ServerSocket class is used by server applications to obtain a port and
listen for client requests.
The ServerSocket class has four constructors −

Sr.No. Method & Description

public ServerSocket(int port) throws IOException
1
Attempts to create a server socket bound to the specified port. An exception
occurs if the port is already bound by another application.
public ServerSocket(int port, int backlog) throws IOException
2
Similar to the previous constructor, the backlog parameter specifies how many
incoming clients to store in a wait queue.
public ServerSocket(int port, int backlog, InetAddress address) throws
IOException

3 Similar to the previous constructor, the InetAddress parameter specifies the

local IP address to bind to. The InetAddress is used for servers that may have
multiple IP addresses, allowing the server to specify which of its IP addresses
to accept client requests on.
public ServerSocket() throws IOException
4
Creates an unbound server socket. When using this constructor, use the bind()
method when you are ready to bind the server socket.

If the ServerSocket constructor does not throw an exception, it means that your
application has successfully bound to the specified port and is ready for client
requests.

Following are some of the common methods of the ServerSocket class −

Sr.No. Method & Description

public int getLocalPort()

1 Returns the port that the server socket is listening on. This method is useful if
you passed in 0 as the port number in a constructor and let the server find a
port for you.
public Socket accept() throws IOException

Waits for an incoming client. This method blocks until either a client connects
2
to the server on the specified port or the socket times out, assuming that the
time-out value has been set using the setSoTimeout() method. Otherwise, this
method blocks indefinitely.
public void setSoTimeout(int timeout)
3
Sets the time-out value for how long the server socket waits for a client during
the accept().
4 public void bind(SocketAddress host, int backlog)

Binds the socket to the specified server and port in the SocketAddress object.
Use this method if you have instantiated the ServerSocket using the no-
 argument constructor.

When the ServerSocket invokes accept(), the method does not return until a client
connects. After a client does connect, the ServerSocket creates a new Socket on an
unspecified port and returns a reference to this new Socket. A TCP connection now
exists between the client and the server, and communication can begin.

Socket Class Methods

The java.net.Socket class represents the socket that both the client and the server use
to communicate with each other. The client obtains a Socket object by instantiating
one, whereas the server obtains a Socket object from the return value of the accept()
method.

The Socket class has five constructors that a client uses to connect to a server −

Sr.No. Method & Description

public Socket(String host, int port) throws UnknownHostException,
IOException.
1
This method attempts to connect to the specified server at the specified port. If
this constructor does not throw an exception, the connection is successful and
the client is connected to the server.
public Socket(InetAddress host, int port) throws IOException
2
This method is identical to the previous constructor, except that the host is
denoted by an InetAddress object.
public Socket(String host, int port, InetAddress localAddress, int
localPort) throws IOException.
3
Connects to the specified host and port, creating a socket on the local host at
the specified address and port.
public Socket(InetAddress host, int port, InetAddress localAddress, int
localPort) throws IOException.
4
This method is identical to the previous constructor, except that the host is
denoted by an InetAddress object instead of a String.
public Socket()
5
Creates an unconnected socket. Use the connect() method to connect this
socket to a server.

When the Socket constructor returns, it does not simply instantiate a Socket object but
it actually attempts to connect to the specified server and port.

Some methods of interest in the Socket class are listed here. Notice that both the client
and the server have a Socket object, so these methods can be invoked by both the
client and the server.
Sr.No. Method & Description
public void connect(SocketAddress host, int timeout) throws IOException
1
This method connects the socket to the specified host. This method is needed
only when you instantiate the Socket using the no-argument constructor.
public InetAddress getInetAddress()
2
This method returns the address of the other computer that this socket is
connected to.
public int getPort()
3
Returns the port the socket is bound to on the remote machine.
public int getLocalPort()
4
Returns the port the socket is bound to on the local machine.
public SocketAddress getRemoteSocketAddress()
5
Returns the address of the remote socket.
public InputStream getInputStream() throws IOException
6
Returns the input stream of the socket. The input stream is connected to the
output stream of the remote socket.
public OutputStream getOutputStream() throws IOException
7
Returns the output stream of the socket. The output stream is connected to the
input stream of the remote socket.
public void close() throws IOException
8
Closes the socket, which makes this Socket object no longer capable of
connecting again to any server.

InetAddress Class Methods

This class represents an Internet Protocol (IP) address. Here are following usefull
methods which you would need while doing socket programming −

Sr.No. Method & Description

static InetAddress getByAddress(byte[] addr)
1
Returns an InetAddress object given the raw IP address.
static InetAddress getByAddress(String host, byte[] addr)
2
Creates an InetAddress based on the provided host name and IP address.
static InetAddress getByName(String host)
3
Determines the IP address of a host, given the host's name.
4 String getHostAddress()
 Returns the IP address string in textual presentation.
String getHostName()
5
Gets the host name for this IP address.
static InetAddress InetAddress getLocalHost()
6
Returns the local host.
String toString()
7
Converts this IP address to a String.

Socket Client Example

The following GreetingClient is a client program that connects to a server by using a
socket and sends a greeting, and then waits for a response.

Example

// File Name GreetingClient.javaimport java.net.*;import java.io.*;

public class GreetingClient {

public static void main(String [] args) {

String serverName = args[0];
int port = Integer.parseInt(args[1]);
try {
System.out.println("Connecting to " + serverName + " on port
" + port);
Socket client = new Socket(serverName, port);

System.out.println("Just connected to " +

client.getRemoteSocketAddress());
OutputStream outToServer = client.getOutputStream();
DataOutputStream out = new DataOutputStream(outToServer);

out.writeUTF("Hello from " +

client.getLocalSocketAddress());
InputStream inFromServer = client.getInputStream();
DataInputStream in = new DataInputStream(inFromServer);

System.out.println("Server says " + in.readUTF());

client.close();
} catch (IOException e) {
e.printStackTrace();
}
}}

Socket Server Example

The following GreetingServer program is an example of a server application that uses
the Socket class to listen for clients on a port number specified by a command-line
argument −

Example

// File Name GreetingServer.javaimport java.net.*;import java.io.*;

public class GreetingServer extends Thread {
private ServerSocket serverSocket;

public GreetingServer(int port) throws IOException {

serverSocket = new ServerSocket(port);
serverSocket.setSoTimeout(10000);
}

public void run() {

while(true) {
try {
System.out.println("Waiting for client on port " +
serverSocket.getLocalPort() + "...");
Socket server = serverSocket.accept();

System.out.println("Just connected to " +

server.getRemoteSocketAddress());
DataInputStream in = new
DataInputStream(server.getInputStream());

System.out.println(in.readUTF());
DataOutputStream out = new
DataOutputStream(server.getOutputStream());
out.writeUTF("Thank you for connecting to " +
server.getLocalSocketAddress()
+ "\nGoodbye!");
server.close();

} catch (SocketTimeoutException s) {
System.out.println("Socket timed out!");
break;
} catch (IOException e) {
e.printStackTrace();
break;
}
}
}

public static void main(String [] args) {

int port = Integer.parseInt(args[0]);
try {
Thread t = new GreetingServer(port);
t.start();
 } catch (IOException e) {
e.printStackTrace();
}
}}

Compile the client and the server and then start the server as follows −

$ java GreetingServer 6066

Waiting for client on port 6066...

Check the client program as follows −

Output

$ java GreetingClient localhost 6066

Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!