JavaTutorials

Views:
 
Category: Education
     
 

Presentation Description

If you are looking for real time and experienced faculty – Sun Trainings is the one who will provide you the best and highly experienced & professional trainers for CORE JAVA. Our trainers feed you with the best training materials , online sessions and a real time scenario. Feel free to send your queries on: [email protected] / (M) 9642434362 .

Comments

Presentation Transcript

Modern Compiler Design:

Modern Compiler Design Java Tutorial

Object-Oriented Programming:

Object-Oriented Programming

Different Programming Paradigms:

Different Programming Paradigms Functional/procedural programming: program is a list of instructions to the computer Object-oriented programming program is composed of a collection objects that communicate with each other

Main Concepts:

Main Concepts Object Class Inheritance Encapsulation

Objects:

Objects identity – unique identification of an object attributes – data/state services – methods/operations supported by the object within objects responsibility to provide these services to other clients

Class:

Class “type” object is an instance of class class groups similar objects same (structure of) attributes same services object holds values of its class’s attributes

Inheritance:

Inheritance Class hierarchy Generalization and Specialization subclass inherits attributes and services from its superclass subclass may add new attributes and services subclass may reuse the code in the superclass subclasses provide specialized behaviors (overriding and dynamic binding) partially define and implement common behaviors (abstract)

Encapsulation:

Encapsulation Separation between internal state of the object and its external aspects How ? control access to members of the class interface “type”

What does it buy us ?:

What does it buy us ? Modularity source code for an object can be written and maintained independently of the source code for other objects easier maintainance and reuse Information hiding other objects can ignore implementation details security (object has control over its internal state) but shared data need special design patterns (e.g., DB) performance overhead

Slide10:

mainly for c++ programmer JAVA

Why Java ?:

Why Java ? Portable Easy to learn [ Designed to be used on the Internet ]

JVM:

JVM JVM stands for J ava V irtual M achine Unlike other languages, Java “executables” are executed on a CPU that does not exist.

Slide13:

OS/Hardware machine code C source code myprog.c gcc myprog.exe Platform Dependent JVM bytecode Java source code myprog.java javac myprog.class OS/Hardware Platform Independent

Primitive types:

Primitive types int 4 bytes short 2 bytes long 8 bytes byte 1 byte float 4 bytes double 8 bytes char Unicode encoding (2 bytes) boolean {true,false} Behaviors is exactly as in C++ Note: Primitive type always begin with lower-case

Slide15:

Constants 37 integer 37.2 float 42F float 0754 integer (octal) 0xfe integer (hexadecimal) Primitive types - cont.

Wrappers:

Wrappers                  Java provides Objects which wrap primitive types and supply methods. Example: Integer n = new Integer(“4”); int m = n.intValue();

Hello World:

Hello World class Hello { public static void main(String[] args) { System.out.println(“Hello World !!!”); } } Hello.java C:\javac Hello.java C:\java Hello ( compilation creates Hello.class ) (Execution on the local JVM)

More sophisticated:

More sophisticated class Kyle { private boolean kennyIsAlive_; public Kyle() { kennyIsAlive_ = true; } public Kyle(Kyle aKyle) { kennyIsAlive_ = aKyle.kennyIsAlive_; } public String theyKilledKenny() { if (kennyIsAlive_) { kennyIsAlive_ = false; return “You bastards !!!”; } else { return “?”; } } public static void main(String[] args) { Kyle k = new Kyle(); String s = k.theyKilledKenny(); System.out.println(“Kyle: “ + s); } } Default C’tor Copy C’tor

Results:

Results javac Kyle.java ( to compile ) java Kyle ( to execute ) Kyle: You bastards !!!

Arrays:

Arrays Array is an object Array size is fixed Animal[] arr; // nothing yet … arr = new Animal[4]; // only array of pointers for(int i=0 ; i < arr.length ; i++) { arr[i] = new Animal(); // now we have a complete array

Arrays - Multidimensional:

Arrays - Multidimensional In C++ Animal arr[2][2] Is: In Java What is the type of the object here ? Animal[][] arr= new Animal[2][2]

Static - [1/4]:

Static - [1/4] Member data - Same data is used for all the instances (objects) of some Class. Class A { public int y = 0; public static int x_ = 1; }; A a = new A(); A b = new A(); System.out.println(b.x_); a.x_ = 5; System.out.println(b.x_); A.x_ = 10; System.out.println(b.x_); Assignment performed on the first access to the Class. Only one instance of ‘x’ exists in memory Output : 1 5 10 a b y y A.x_ 0 0 1

Static - [2/4]:

Static - [2/4] Member function Static member function can access only static members Static member function can be called without an instance. Class TeaPot { private static int numOfTP = 0; private Color myColor_; public TeaPot(Color c) { myColor_ = c; numOfTP++; } public static int howManyTeaPots() { return numOfTP; } // error : public static Color getColor() { return myColor_; } }

Static - [2/4] cont.:

Static - [2/4] cont. Usage: TeaPot tp1 = new TeaPot(Color.RED); TeaPot tp2 = new TeaPot(Color.GREEN); System.out.println(“We have “ + TeaPot . howManyTeaPots()+ “Tea Pots”);

Static - [3/4]:

Static - [3/4] Block Code that is executed in the first reference to the class. Several static blocks can exist in the same class ( Execution order is by the appearance order in the class definition ). Only static members can be accessed. class RandomGenerator { private static int seed_; static { int t = System.getTime() % 100; seed_ = System.getTime(); while(t-- > 0) seed_ = getNextNumber(seed_); } } }

String is an Object:

String is an Object Constant strings as in C, does not exist The function call foo (“Hello”) creates a String object, containing “Hello”, and passes reference to it to foo . There is no point in writing : The String object is a constant. It can’t be changed using a reference to it. String s = new String(“Hello”);

Flow control:

Flow control Basically, it is exactly like c/c++. if/else do/while for switch If(x==4) { // act1 } else { // act2 } int i=5; do { // act1 i--; } while(i!=0); int j; for(int i=0;i<=9;i++) { j+=i; } char c=IN.getChar(); switch(c) { case ‘a’: case ‘b’: // act1 break; default: // act2 }

Packages:

Packages Java code has hierarchical structure. The environment variable CLASSPATH contains the directory names of the roots. Every Object belongs to a package ( ‘package’ keyword) Object full name contains the name full name of the package containing it.

Access Control:

Access Control public member (function/data) Can be called/modified from outside. protected Can be called/modified from derived classes private Can be called/modified only from the current class default ( if no access modifier stated ) Usually referred to as “Friendly”. Can be called/modified/instantiated from the same package.

Inheritance:

Inheritance Base Derived class Base { Base(){} Base(int i) {} protected void foo() {…} } class Derived extends Base { Derived() {} protected void foo() {…} Derived(int i) { super(i); … super.foo(); } } As opposed to C++, it is possible to inherit only from ONE class. Pros avoids many potential problems and bugs. Cons might cause code replication

Polymorphism:

Polymorphism Inheritance creates an “is a” relation: For example, if B inherits from A, than we say that “B is also an A”. Implications are: access rights (Java forbids reducing access rights) - derived class can receive all the messages that the base class can. behavior precondition and postcondition

Slide32:

Inheritance (2) In Java, all methods are virtual : class Base { void foo() { System.out.println(“Base”); } } class Derived extends Base { void foo() { System.out.println(“Derived”); } } public class Test { public static void main(String[] args) { Base b = new Derived(); b.foo(); // Derived.foo() will be activated } }

Slide33:

Inheritance (3) - Optional class classC extends classB { classC(int arg1, int arg2){ this(arg1); System.out.println("In classC(int arg1, int arg2)"); } classC(int arg1){ super(arg1); System.out.println("In classC(int arg1)"); } } class classB extends classA { classB(int arg1){ super(arg1); System.out.println("In classB(int arg1)"); } classB(){ System.out.println("In classB()"); } }

Slide34:

Inheritance (3) - Optional class classA { classA(int arg1){ System.out.println("In classA(int arg1)"); } classA(){ System.out.println("In classA()"); } } class classB extends classA { classB(int arg1, int arg2){ this(arg1); System.out.println("In classB(int arg1, int arg2)"); } classB(int arg1){ super(arg1); System.out.println("In classB(int arg1)"); } class B() { System.out.println("In classB()"); } }

Abstract:

Abstract abstract member function, means that the function does not have an implementation. abstract class, is class that can not be instantiated. AbstractTest.java:6: class AbstractTest is an abstract class. It can't be instantiated. new AbstractTest(); ^ 1 error NOTE: An abstract class is not required to have an abstract method in it. But any class that has an abstract method in it or that does not provide an implementation for any abstract methods declared in its superclasses must be declared as an abstract class. Example

Abstract - Example:

Abstract - Example package java.lang; public abstract class Shape { public abstract void draw(); public void move(int x, int y) { setColor(BackGroundColor); draw(); setCenter(x,y); setColor(ForeGroundColor); draw(); } } package java.lang; public class Circle extends Shape { public void draw() { // draw the circle ... } }

Interface:

Interface Interfaces are useful for the following: Capturing similarities among unrelated classes without artificially forcing a class relationship. Declaring methods that one or more classes are expected to implement. Revealing an object's programming interface without revealing its class.

Interface:

Interface abstract “class” Helps defining a “usage contract” between classes All methods are public Java’s compensation for removing the multiple inheritance. You can “inherit” as many interfaces as you want. Example

Interface:

Interface interface SouthParkCharacter { void curse(); } interface IChef { void cook(Food food); } interface BabyKicker { void kickTheBaby(Baby); } class Chef implements IChef, SouthParkCharacter { // overridden methods MUST be public // can you tell why ? public void curse() { … } public void cook(Food f) { … } }

When to use an interface ?:

When to use an interface ? Perfect tool for encapsulating the classes inner structure. Only the interface will be exposed

Collections:

Collections Collection/container object that groups multiple elements used to store, retrieve, manipulate, communicate aggregate data Iterator - object used for traversing a collection and selectively remove elements Generics – implementation is parametric in the type of elements

Java Collection Framework:

Java Collection Framework Goal: Implement reusable data-structures and functionality Collection interfaces - manipulate collections independently of representation details Collection implementations - reusable data structures List<String> list = new ArrayList<String>(c); Algorithms - reusable functionality computations on objects that implement collection interfaces e.g., searching, sorting polymorphic: the same method can be used on many different implementations of the appropriate collection interface

Collection Interfaces:

Collection Interfaces Collection Set List Queue SortedSet Map Sorted Map

Collection Interface:

Collection Interface Basic Operations int size(); boolean isEmpty(); boolean contains(Object element); boolean add(E element); boolean remove(Object element); Iterator iterator(); Bulk Operations boolean containsAll(Collection<?> c); boolean addAll(Collection<? extends E> c); boolean removeAll(Collection<?> c); boolean retainAll(Collection<?> c); void clear(); Array Operations Object[] toArray(); <T> T[] toArray(T[] a); }

General Purpose Implementations:

General Purpose Implementations Collection Set List Queue SortedSet Map Sorted Map HashSet HashMap List<String> list1 = new ArrayList<String>(c); ArrayList TreeSet TreeMap LinkedList List<String> list2 = new LinkedList<String>(c);

final:

final final member data Constant member final member function The method can’t be overridden. final class ‘Base’ is final, thus it can’t be extended final class Base { final int i=5; final void foo() { i=10; //what will the compiler say about this? } } class Derived extends Base { // Error // another foo ... void foo() { } } (String class is final)

final:

final final class Base { final int i=5; final void foo() { i=10; } } class Derived extends Base { // Error // another foo ... void foo() { } } Derived.java:6: Can't subclass final classes: class Base class class Derived extends Base { ^ 1 error

IO - Introduction:

IO - Introduction Definition Stream is a flow of data characters read from a file bytes written to the network … Philosophy All streams in the world are basically the same. Streams can be divided (as the name “IO” suggests) to Input and Output streams. Implementation Incoming flow of data (characters) implements “Reader” (InputStream for bytes) Outgoing flow of data (characters) implements “Writer” (OutputStream for bytes –eg. Images, sounds etc.)

Exception - What is it and why do I care?:

Exception - What is it and why do I care? Definition: An exception is an event that occurs during the execution of a program that disrupts the normal flow of instructions. Exception is an Object Exception class must be descendent of Throwable.

Exception - What is it and why do I care?(2):

Exception - What is it and why do I care?(2) By using exceptions to manage errors, Java programs have the following advantages over traditional error management techniques: 1 : Separating Error Handling Code from "Regular" Code 2 : Propagating Errors Up the Call Stack 3 : Grouping Error Types and Error Differentiation

1: Separating Error Handling Code from "Regular" Code (1) :

readFile { open the file; determine its size; allocate that much memory; read the file into memory; close the file; } 1: Separating Error Handling Code from "Regular" Code (1)

1: Separating Error Handling Code from "Regular" Code (2) :

errorCodeType readFile { initialize errorCode = 0; open the file; if (theFileIsOpen) { determine the length of the file; if (gotTheFileLength) { allocate that much memory; if (gotEnoughMemory) { read the file into memory; if (readFailed) { errorCode = -1; } } else { errorCode = -2; } } else { errorCode = -3; } close the file; if (theFileDidntClose && errorCode == 0) { errorCode = -4; } else { errorCode = errorCode and -4; } } else { errorCode = -5; } return errorCode; } 1: Separating Error Handling Code from "Regular" Code (2)

1: Separating Error Handling Code from "Regular" Code (3) :

readFile { try { open the file; determine its size; allocate that much memory; read the file into memory; close the file; } catch (fileOpenFailed) { doSomething; } catch (sizeDeterminationFailed) { doSomething; } catch (memoryAllocationFailed) { doSomething; } catch (readFailed) { doSomething; } catch (fileCloseFailed) { doSomething; } } 1: Separating Error Handling Code from "Regular" Code (3)

2: Propagating Errors Up the Call Stack :

method1 { try { call method2; } catch (exception) { doErrorProcessing; } } method2 throws exception { call method3; } method3 throws exception { call readFile; } 2 : Propagating Errors Up the Call Stack

authorStream Live Help