Java Basics

Basic JAVA
Write once run any where

Basic Language Elements
Identifiers, Keywords, Literals, White Spaces and Comments
Identifiers
 A name in a program is called an identifier.
 An identifier in java is composed of a sequence of characters, where
each character can be either a letter or digit or connecting symbol($,_).
 The first character in an identifier can’t be a digit.
 Identifiers in java are case sensitive.
Keywords
 Key words are reserved identifiers.
 In java, all keywords are in lower case.
Literals
A literal denotes a constant value of a particular data type, the value a
literal represents remains unchanged in the program.

Primitive Data Types
DataType Bit Depth
1. boolean jvm specific
2. byte 8 bits
3. short 16 bits
4. int 32 bits
5. long 64 bits
6. char 16 bits
7. float 32 bits
8. double 64 bits
 All numeric data types except char are
signed data types.
 The default data type of an integer
(byte, short, int, long) literal is always
int.
long can be specified by appending L
or l as a suffix.There’s no way to
represent a byte or short literal.
 The dafault data type of floating point
literal is double.
float can be specified by appending F
or f as a suffix.

Java’s Keywords
boolean byte char short int long float double
public private protected abstract static final native synchronized
transient volatile strictfp if else do while for
switch case default break continue assert class interface
extends implements import package new instanceof super this
try catch finally throw throws void return enum
Java’s Reserved words
const goto
Java’s reserved Literals
true false null
ХJava doesn’t allow us to use any of the above as an identifier.
Q] /* // */ is it legal ?
Q] which of the following are keywords in java ?
a) instaceof b) object c) void d) main e) String f) enum g) null h) thrown
i)finalize j) native

Java Source file structure
» An optional package declaration
» Zero or more import declarations
» Any no.of top level classes and interface declarations
 At the most one public class definition per source class can be defined.
If a public class is defined, the file name must match this class name.
 Except for package and import statements, all code is encapsulated in
classes and interfaces.
 like any other method, the main method can also be overloaded and
overrided.
Q] which of the following are valid main() method declarations in order to
start the execution of java application ?
a) Public static void main(String args) throws Exception
b) static public void main(String[] args)
c) final public static void main(String args[])

Class (a user defined data type)
 class is a logical construct upon which the entire java language is built.
 Objects are basic run time entities in java. class acts as a blue print for
similar type of objects.
 when you design a class, think about the objects that will be created from
that class, think about
1. Things the object knows (state)
2. Things the object does (behavior)
Alarm
alarmTime
setAlarmTime()
getAlarmTime()
isAlarmSet()
Things an object knows itself are called
instance variables.
Things an object can do are called
methods.
 classes give modularity in java.

[class modifiers] class <class name> [extends clause] [implements clause]
{
[variable declarations]
[method declarations]
[constructor declarations]
[initializer blocks]
[nested class declarations]
[nested interface declarations]
}
class Syntax

Java Variables
 A variable stores a value of a particular type.
 in java variables come in two flavors
1. primitive
2. reference
Variables that store references to objects are called reference variables.
 java has three types of variables
1. instance variables
2. static variables
3. local variables

Instance variables
» Every object of the class will have its own copies of these variables, which
are local to object
» The values of these variables at any given time constitute the state of the
object
» Instance variables exist as long as object they belong to exist
Static variables
» Belong only to the class, but not created for only object of the class
» All objects of the class share the same copy of this variable
» Class variables exist as long as class exist
Local Variables
» Variables declared in methods including parameters or blocks are called
Local variables
» After execution of the method or block completes local variables are no
longer accessible

 Local variables must be explicitly initialized before being used.
The compiler will report attempt to use un initialized local variables.
 if no initialization is provided for static or instance variable they
are initialized by default value of their type.
Default values of static/instance variables
Data Type Default Value
boolean false
char ‘u0000’
int or short or byte 0
long 0L
float 0.0f
double 0.0
reference types null

Java operators
() [] .
++ -- ~ !
* / %
+ -
<< >> >>>
>= < <=
== !=
&
^
|
&&
||
?:
= op=
Precedence table
Precedence rules are used to determine which
operator should be applied first if there are two
operators with different precedence.
The associative rules are used to determine
which operator should be applied first if there are
more than one operand with the same precedence.
the precedence and associative rules together
determine the evolution order of operators in an
expression.
All binary operators, except for the assignment
operator associate from left to right
Except for unary postfix increment and
decrement operators, all unary operators, all
assignment operator and ternary conditional
operator associate from right to left.

new operator is used to create objects and declare array
sizes.
 instanceof operator is used to test an object’s type.
<source reference type> instanceof <destination type>
Q] int x=3;
x<<4;
s.o.p(x);
Q] int i=--4*2--;
s.o.p(i);

Type Conversions
 Java being a strongly typed language , checks for compatibility at compile
time. How ever some checks are only possible at runtime.
 Java demands that a cast be used to explicitly indicate the
type conversion (narrowing or downcasting)
(<type>) expression;
 Casting the value of a super class reference to a subclass type is
downcasting and the reverse is called upcasting.
Casting between primitive types and reference types is not possible
Boolean values can’t be cast to other data types and vice versa
Widening and upcasting are implicit conversions
Narrowing typically requires explicit casting.
widening
byte short char int long float double

Numeric promotions
 Numeric promotion is implicitly applied on the operands to convert them
to permissible types.
Unary numeric promotion
 if the single operand of the operator has a type narrower than int, it is
converted to int by an implicit widening primitive conversion;
Binary numeric promotion
 Given T to be the broadest numeric type of two operands the operands are
promoted as follows
If( T is broader than int)
both operands are converted to T
else
both operands are converted to int

Implicit narrowing conversions
implicit narrowing conversions on assignment can occur in cases where all
of the following conditions are full filled
1. The source is a constant expression of either byte, short, char, or int type
2. The destination type is either byte, short or char type
3. The value of the source is determined to be in the range of the destination
type at compile time
Type conversion contexts
 Assignments
 Method invocation involving parameters
 Arithmetic expression involving numeric types
 String Concatenation involving String objects and other data types
Q] byte b=17;
b=b+2; //illegal
b+=2; //legal

Arrays
 In java, arrays are objects
Array declaration
<element type>[] <array name>
(or)
<element type> <array name>[]
<array name> =new <element type>[size];
 when the array is constructed, all its elements are initialized to the default
value of their element type. This is true for both members and local arrays.
 Java supports declaring , constructing, and explicitly initializing an array
in one stmt.
eg: int[] a={4,3,78,3};
Anonymous array
new <element type>[] {array list}
eg:new int[] {4,7,3,8,9};
Multi dimensional arrays

Method
[method modifiers] <return type> <method name> ([formal parameters]) [throws
clause]
{
[local variable declarations]
[statements]
[nested class declarations]
}
Parameter passing
 The parameter strategy in java is pass-by-value regardless of the type of
the parameter.
 The order of the evolution in actual parameter list is always from left to
right.
 if the actual parameter is a reference to an object then the reference value is
passed and not the object itself.

Method Over Loading
Several methods may have the same name, as long as the method
signatures differ.
For the over loading method,
 The arguments list must be different
 The return types can be different
 You can vary access levels in any direction
<There’s no polymorphism with over loading methods>

Method Overriding
For the overriding method ,
 Signature must be same as original method.
 Return type must be compatible with original method return type
 The new method definition can’t narrow the accessibility
 The new method definition can only specify all or none or a subset of
exception classes in the throws clause.
 An instance method in a sub class can’t override a static method in the
super class and vice versa.
 We can’t override static methods rather we can hide them

Interfaces
[access modifier] interface <interface name> <extends interface clause>
{
[constant declarations]
[method prototype declarations]
}
 The methods in an interface are implicitly abstract and public and the
constants are implicitly public, static and final.
 An interface can extend other interfaces
 An interface which has no methods to implement is known as Marker or
tag or ability interface.

Inheritance
 It allows new classes to be derived from existing classes. And it is the
main thing in Java for code reuse.
 private members of a class are not inherited and also members that have a
package accessibility in the super class are also not inherited by sub classes
in other packages.
 Since constructors and initializer blocks are not members of a class they
are not inherited by a sub class.
 To avoid D3(Deadly Diamond of Death) problem java doesn’t support
multiple inheritance. So a class in java can extend at most one other class.
 java gives multiple interface inheritance through interfaces. So a class can
implement many interfaces.
Any class that doesn’t explicitly extend another class, implicitly extends
<Object> class.
So any class in java, either directly or indirectly extends Object class.

 classes up the inheritance hierarchy are more generalized and classes down
the hierarchy are more specialized.
Inheritance defines the is-a relationship between a super class and its sub
class. This means that an object of a sub class can be used where ever an
object of the super class can be used.
 It is not possible for two classes to be the super classes of each other
If A extends B then A is-a B
Aggregation
Aggregation defines has-a relationship between objects.
If A has a reference to B then A has-a B

Polymorphism
The ability of a super class or super type reference to denote objects of its
own class and its sub classes at runtime is called polymorphism.
 polymorphism is achieved through inheritance and interface
implementation
 The instance method invocation is dependent on the type of the actual
object denoted by the reference at runtime.
 Field access and static method access is determined by the reference
type not by the actual object.
 you can call a method on an object only if the class of the reference
variable has that method.

Static Block
static
{
//code
}
 The code in a static block is executed once only when the class is loaded .
 These are primarily used for initializing static fields.
 Static block is not contained in any method
 A class can have more than one static block. In this case the blocks are
executed in the order of their declarations in the class.

Instance Block
{
//code
}
 The code in an instance block is executed every time an object is created.
 Instance block is not contained in any method
 A class can have more than one instance block. In this the blocks are
executed in the order of their declarations in the class.
 An instance initializer block can be used to factor out common
initialization code that will be executed regardless of which constructor is
invoked.

Control Flow stmts
Control flow statements govern the flow of control in a program during
execution.
There are three categories of control flow stmts
1. Selection stmts [if, if-else, switch]
2. Iteration stmts [for, while, do-while]
3. Transfer stmts [break, continue, return, throw, try-catch-flow and
assert]

Packages
A package in java is an encapsulation mechanism that can be used to group
related classes, interfaces and sub packages.
package <fully qualified package name>
 At most one package declaration can appear in a source file, and it must
be the first statement.
 The package name is saved in java byte code for the types contained in
the package.
 If a package stmt is omitted in a source file, then respective class files
are placed in a unnamed package (current working directory)
 packages prevent class name conflicts.
 (java convention) preface your packages with your reverse domain name
to prevent package name conflicts.
 To put your class in package, The package hierarchy must match the
directory structure

Using packages,
we can use the existing package in two ways
1. Using the fully qualified name of the type.
2. Using import declarations.
Import
import <fully qualified name> // single type import
import <fully qualified name>.* //import on demand
 An import declaration doesn’t recursively import sub packages.

Modifiers
1. Access modifiers
 public
 protected
 no modifier (package access)
 private
2. static
3. final
4. abstract
5. synchronized
6. native
7. transient
8. volatile
9. threadsafe

Top level classes and
interfaces
public, no modifier
abstract and final
Inner classes All Access modifiers
abstract, static and final
Fields All access modifiers
static, final, transient and volatile
Methods All access modifiers
abstract, static, final, synchronized and native
Member Type Possible modifiers

Modifier Class Package Sub class
(out side
package)
World
public Y Y Y Y
protected Y Y Y N
default Y Y N N
private Y N N N
Access modifiers
 Use most restrictive access level that makes sense for a particular
member.
 Avoid public fields accept for constants
public fields limit your flexibility in changing your code.

Abstract method
 An abstract method has no implementation (no body) it just specifies
method prototype
 You can’t have an abstract method in a non abstract class
 If you put even a single abstract method in a class, you have to make the
class abstract.
 Only an instance method can be declared as abstract (we can’t override a
static method)
 A final method can’t be abstract

Abstract class
 Abstract class means, The class which is partially implemented
 We can’t instantiate an abstract class. We can still use the abstract type as
a reference type, for the purpose of polymorphism
 If you put even a single abstract method in a class you have to make the
class abstract.
 Even if there are no abstract methods you can declare class as abstract
just make it as a non concrete class.
 You can mix both abstract and non-abstract methods in an abstract class.
 The sub class which extends abstract class must implement all the
abstract methods or declare it also as abstract.

static
 Static members belong to the class in which they are declared.
 We can access static members through class name or through object
reference of that class.
 We can’t access non-static members in static context.
Static context =>static initializer expression
static initializer blocks
static methods
static inner classes
 Object needn’t be instantiated to access its static members.
 Only inner classes can be declared as static
 static variables are not part of a object state
 we can’t override static methods in sub classes, rather we can hide them

Final variable
 A final variable of primitive data type can’t change its value
once it has been initialized
 A final variable of a reference type can’t change its reference
value once it has been initialized but the state of the object it
denotes can still be changed.
 Applicable to instance, static, and local variables.
 Blank finals
Final method
 We can’t override a final method in sub classes.
Final class
 A Final class can’t be extended
 only a class whose definition is complete can be declared final.

 Make a class that doesn’t extends any thing when your new classes
doesn’t passes is-a test for any other type.
 Make a sub class only when you need to make a more specific version
of a class and need to override or add new behavior
 Use an abstract class when you want to define a template for a group
classes and at least you have some implementation that all classes could
use.
Use an interface when you want to define a role that other classes can
play regardless of where those classes are in the inheritance tree.

This was my first KT.
Given in honing solutions in 2006.

Java Basics

More Related Content

What's hot (20)

Viewers also liked (9)

Similar to Java Basics (20)

Java Basics