Java session01

Java Programming Language
Objectives

• In this session, you will learn to:
Describe the key features of Java technology
Write, compile, and run a simple Java technology application
Describe the function of the Java Virtual Machine
Define garbage collection
List the three tasks performed by the Java platform that handle
code security
Define modeling concepts: abstraction, encapsulation, and
packages
Discuss why you can reuse Java technology application code
Define class, member, attribute, method, constructor, and
package
Use the access modifiers private and public as appropriate for
the guidelines of encapsulation

Ver. 1.0 Session 1 Slide 1 of 31

Objectives (Contd.)

Invoke a method on a particular object
Use the Java technology Application Programming Interface
online documentation


Key Features of Java Technology

A programming language
A development environment
An application environment
A deployment environment

Java Technology is used for developing both applets and
applications.


Primary Goals of the Java Technology

Provides an easy-to-use language by:
Avoiding many pitfalls of other languages
Being object-oriented
Enables code streamlining
Provides an interpreted environment for:
Improved speed of development
Code portability
Loads classes dynamically, i.e., at the time they are actually
needed
Supports changing programs dynamically during runtime by
loading classes from distinct sources
Furnishes better security
Enable users to run more than one thread of an activity


Primary Features of the Java Technology

The Java Virtual Machine (JVM™)
Garbage collection
The Java Runtime Environment (JRE)
JVM tool interface


The Java Virtual Machine

JVM provides definitions for the:
Instruction set (Central Processing Unit [CPU])
Register set
Class file format
Runtime stack
Garbage-collected heap
Memory area
Fatal error reporting mechanism
High-precision timing support


Garbage Collection

Garbage collection has the following characteristics:
Checks for and frees memory no longer needed, automatically.
Provides a system-level thread to track memory allocation.


The Java Runtime Environment

• The Java application environment performs as follows:


JVM™ Tasks

The JVM performs three main tasks:
Loads code – Performed by the class loader.
Verifies code – Performed by the bytecode verifier.
Executes code – Performed by the runtime interpreter.


The Class Loader

Loads all classes necessary for the execution of a program.
Maintains classes of the local file system in separate
namespaces.
Avoids execution of the program whose bytecode has been
changed illegally.


The Bytecode Verifier

All class files imported across the network pass through the
bytecode verifier, which ensures that:
The code adheres to the JVM specification.
The code does not violate system integrity.
The code causes no operand stack overflows or underflows.
The parameter types for all operational code are correct.
No illegal data conversions (the conversion of integers to
pointers) have occurred.


Java Technology Runtime Environment


A simple Java Application

Let see how to create a simple Java Application.


The Analysis and Design Phase

Analysis describes what the system needs to do:
Modeling the real-world, including actors and activities, objects,
and behaviors.
Design describes how the system does it:
Modeling the relationships and interactions between objects
and actors in the system.
Finding useful abstractions to help simplify the problem or
solution.


Declaring Java Technology Classes

Basic syntax of a Java class:
<modifier>* class <class_name>
{ <attribute_declaration>*
<constructor_declaration>*
<method_declaration>*
}
Example:
public class MyFirstClass
{ private int age;
public void setAge(int value)
{ age = value;
}
}

Declaring Attributes

Basic syntax of an attribute:
<modifier>* <type> <name> [ =
<initial_value>];
Example:
public class MyFirstClass
{
private int x;
private float y = 10000.0F;
private String name = “NIIT";
}


Declaring Methods

Basic syntax of a method:
<modifier>* <return_type> <name>
( <argument>* ){ <statement>* }
Example:
public class Dog
{ private int weight;
public int getWeight()
{ return weight;
}
public void setWeight(int newWeight)
{ if ( newWeight > 0 )
{ weight = newWeight;
} } }


Accessing Object Members

To access object members, including attributes and
methods, dot notation is used
The dot notation is: <object>.<member>
Examples:
d.setWeight(42);
d.weight = 42; // only permissible if weight is public


Class Representation Using UML

• Class representation of MyDate class:

MyDate Class name

-day : int
-month : int Attributes
-year : int

+getDay()
+getMonth()
+getYear() Methods
+setDay(int) : boolean
+setMonth(int) : boolean
+setYear(int) : boolean


Abstraction

Abstraction means ignoring the non-essential details of an
object and concentrating on its essential details.


Encapsulation

Encapsulation provides data representation flexibility by:
Hiding the implementation details of a class.
Forcing the user to use an interface to access data.
Making the code more maintainable.


Declaring Constructors

• A constructor is a set of instructions designed to initialize an
instance.
• Basic syntax of a constructor:
[<modifier>] <class_name> ( <argument>* )
{ <statement>* }
Example:
public class Dog
{ private int weight;
public Dog()
{ weight = 42;
}
}


The Default Constructor

There is always at least one constructor in every class.
If the programmer does not supply any constructor, the
default constructor is present automatically.
The characteristics of default constructor:
– The default constructor takes no arguments.
– The default constructor body is empty.
– The default constructor enables you to create object instances
with new xyz() without having to write a constructor.


Source File Layout

Basic syntax of a Java source file:
[<package_declaration>]
<import_declaration>*
<class_declaration>+
For example, the VehicleCapacityReport.java file can be
written as:
package shipping.reports;
import shipping.domain.*;
import java.util.List;
import java.io.*;
public class VehicleCapacityReport
{ private List vehicles;
public void generateReport(Writer output)
{...} }


Software Packages

• Packages help manage large software systems.
• Packages can contain classes and sub-packages.


Software Packages (Contd.)

Basic syntax of the import statement:
import
<pkg_name>[.<sub_pkg_name>]*.<class_name>;
or
import <pkg_name>[.<sub_pkg_name>]*.*;
Examples:
import java.util.List;
import java.io.*;
import shipping.gui.reportscreens.*;
The import statement does the following:
Precedes all class declarations
Tells the compiler where to find classes


Deployment

In order to deploy an application without manipulating the
user’s CLASSPATH environment variable, create an
executable Java Archive (JAR) File.
To deploy library code in a JAR file, copy the JAR file into
the ext subdirectory of the lib directory in the main directory
of the JRE.


Using the Java Technology API Documentation

The main sections of a class document include the
following:
– The class hierarchy
– A description of the class and its general purpose
– A list of attributes
– A list of constructors
– A list of methods
– A detailed list of attributes with descriptions
– A detailed list of constructors with descriptions and formal
parameter lists
– A detailed list of methods with descriptions and formal
parameter lists


Summary

In this session, you learned that:
The key features of Java technology include:
• A programming language
• A development environment
• An application environment
• A deployment environment
JVM can be defined as an imaginary machine that is
implemented by emulating it in software on a real machine.
Java source files are compiled, get converted into a bytecode
file. At runtime, the bytecodes are loaded, checked, and run in
an interpreter.
Garbage collector checks for and frees memory no longer
needed, automatically.


Summary (Contd.)

The three main tasks performed by the JVM include:
• Loads code
• Verifies code
• Executes code
There are five primary workflows in a software development
project: Requirement capture, Analysis, Design,
Implementation, and Test.
Abstraction means ignoring the non-essential details of an
object and concentrating on its essential details.
Encapsulation provides data representation flexibility by hiding
the implementation details of a class.
The Java technology class can be declared by using the
declaration:
<modifier> * class <class name>
The declaration of a Java object attribute can be done as:
<modifier> * <type> <name>

Summary (Contd.)

The definition of methods can be done as:
<modifier> * <return type> <name> (<argument>
*)
– The dot operator enables you to access non-private attribute
and method members of a class.
– A constructor is a set of instructions designed to initialize an
instance of a class.
– The Java technology programming language provides the
package statement as a way to group related classes.
– The import statement tells the compiler where to find the
classes which are grouped in packages.
– The Java technology API consists of a set of HTML files. This
documentation has a hierarchical layout, where the home page
lists all the packages as hyperlinks.


Java session01

Recommended

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Java session01 (20)

More from Niit Care (20)

Recently uploaded (20)

Java session01