Download Introduction to Java..

Introduction to Java
Prepared by:
Ahmed Hefny
Outline
•
•
•
•
•
•
•
•
•
Classes
Access Levels
Member Initialization
Inheritance and Polymorphism
Interfaces
Inner Classes
Generics
Exceptions
Reflection
Access Levels
• Private
• Protected
• Default
– Accessed by other classes in the same package
– Simply do not write an access modifier
• Public
Member Initialization
• Default Initialization (For class members only.
Locals are not initializaed)
– Numbers  0
– References  null
– Boolean  false
• Explicit initialization
– E.g. Private int x = 0;
Member Initialization (Cont.)
• Static Initialization Block
static
{
/* You can write any code here !!!. It will be
executed when the class is loaded */
}
• In the constructor
Member Initialization (Cont.)
• A constructor can invoke other constructors
• Example:
Public MyClass(int i) {}
Public MyClass()
{
this(5);
//Extra code
}
Inheritance and Polymorphism
• Similar to C++
• Only single public inheritance
public class Child extends Parent
{
}
Inheritance and Polymorphism (Cont.)
• In Java, all methods are virtual by default.
• Declaring a method in a child class with the same
signature of a method in the base class overrides
it.
• Explicitly use @override attribute (why ?)
@override public void f()
Inheritance and Polymorphism (Cont.)
• To define an abstract method, use abstract
keyword. The whole class must be declared
abstract if it contains an abstract method.
public abstract MyClass
{
public abstract void abstractMethod();
}
Inheritance and Polymorphism (Cont.)
• To define a sealed method, use final keyword.
Sealed methods cannot be overridden
public MyClass
{
public final void sealedMethod();
}
Inheritance and Polymorphism (Cont.)
• To call the base class constructor
public Child extends Parent
{
public Child()
{
super(i);
//Extra Code
}
}
Interfaces
• An interface represents some behavior or
functionality shared among multiple classes.
• For example, Strings, dates and students can
be compared but that does not justify
defining a common base class for them.
• Because they can also be serialized.
Interfaces
• Although a class can extend one class. It can
implement any number of interfaces.
• An interface defines a set of functions without
implementation and it contains no data
member (why ?)
Interfaces
public interface SampleInterface
{
void f();
//No modifier, no code
}
public class MyClass implements SampleInterface
{
void f() {/*Implementation*/}
}
Interfaces
Can use the interface as follows
SampleInterface t = new MyClass();
t.f();
You can check whether an object o implements
interface I (or of class I or subclass thereof)
using instanceOf
if(c instanceOf I)
Inner Classes
• Like C++, we can define a class nested in
another one.
• In Java, we can define local inner classes in a
function.
• We can define anonymous inner classes on
the fly.
Inner Classes
• Example:
public interface Comparator
{
bool isLessThan(Object o1, Object o2);
}
Inner Classes
• Example:
class MyColl
{
public void getMin(Comparator c) {}
}
Inner Classes
• Without Inner classes:
class MyComparator implements Comparator
{
bool compare(Object o1, Object o2) {}
}
MyColl m = new MyColl();
m.sort(new MyComparator());
Inner Classes
• With Inner classes:
MyColl m = new MyColl();
Comaprator c = new Comparator()
{
bool compare(Object o1, Object o2) {}
}
m.sort(c);
Inner Classes
• Or Even:
MyColl m = new MyColl();
m.sort( new Comparator()
{
bool compare(Object o1, Object o2) {}
}
);
Generics
•
•
•
Similar to STL classes
Defined in java.util package
Example
LinkedList<Integer> l = new LinkedList<Integer>();
l.add(new Integer(3));
l.add(new Integer(4));
l.add(new Integer(5));
Iterator<Integer> it = l.iterator();
while(it.hasNext())
{
Integer i = it.next();
System.out.print(i.toString());
}
Generics
• Similar to STL classes
• Defined in java.util package
• Example
LinkedList<Integer> l = new LinkedList<Integer>();
l.add(new Integer(3));
l.add(new Integer(4));
l.add(new Integer(5));
for(Integer i : l)
{
System.out.print(i.toString());
}
Exceptions
• Similar to C++ with two major additions
– finally block
• Code executes whether a method terminates normally
or due to an exceptions
• Good place for releasing resources
– Exception handling is obligatory
• Either handle the exception (catch)
• Or let the caller handle it (throws)
Reflection
• Allows for invoking classes and methods
known only at run time.
Class c = class.forName(“Name”);
The obtained object allows you to query
methods and invoke them.