JAVA Introduction

1. JAVA Introduction • One of the main JAVA design goal is reducing complexity for programmer • Development time is half or less comparing to equivalent C++ programs • Language support for multi-threading and network programming • Cross-platform programs, dynamic code change, security • Java programs run in a Virtual Machine environment • Programs are compiled to an intermediate form • Intermediate code is run by VM

2. Introduction to Object Orientation • Why OO? • What is wrong with non OO programming languages like C? • Is it really needed to learn OO? • What are the differences of making a program using OO than non OO way?

3. Progress of abstraction • Programming languages makes abstractions • Assembly language is abstraction of the machine language • Fortran, Basic, C and many others were abstractions for assembly language • The above languages makes abstractions for machines • They don't provide abstraction of problem space • Object orientation • Provides abstractions of problem space • Elements of problem space are represented as Objects

4. Object? • Characteristic of Smalltalk by Alan Kay • Everything is an object • A program is a bunch of objects telling each other what to do by sending messages • Each object has its own memory made up of other objects • Every object has a type (what messages can send to it?) • All object of a particular type can receive the same messages • Booch: • An object has state, behavior and identity

5. An object has interface • A Type or Class of an object • Describes a set of objects with identical characteristics (data elements) and behaviors (functionality) Light lt = new Light(); lt.on();

6. Objects as service providers • A program is a set of objects that provide services to other objects • Program design then is a process of finding or creating objects that solve the problem • Service provider view helps making High Cohesive objects • This view also helps others understand program

7. Hidden implementation • Regarding an object we can distinguish two roles: • Creator of the object: wants to expose only what is necessary for the client programmer • Users of the object (client programmer): Only wants to know what an object does for him/her • Enforce client programmers to not access those parts of an object that they should not • Makes it possible to change internal structure of an object without worrying of effects on clients • Java uses public, private and protected for these access controls

8. Reusing the implementation • Code reuse is one of the main advantages that OO languages provide • One way of reusing an object is to place it inside another object: Creating a member object (composition)

9. Inheritance: Reusing the interface • Creating a class based on a similar already implemented class

10. Inheritance: Reusing the interface • With inheritance you create a new type • The new type includes all the members of base type • It also has same interface of base type • If we inherit a new class from a base class and don't implement methods, then methods have same behavior as base class • Differentiating between derived class and base class: • Adding new methods to the derived class • Overriding existing methods

11. Inheritance: Reusing the interface • Overriding existing methods IS-A relationship

12. Inheritance: Reusing the interface • Adding new methods IS-LIKE-A relationship

13. Interchangeable objects with polymorphism • Sometimes it is much convenient to treat objects in a type hierarchy all as base class objects • It allows to write code that does not depend on the specific type of objects: For all shape object O { o.draw(); } • But what happens when one shape object is actually a circle or a triangle or a square? • The key is late binding: runtime binding

14. Interchangeable objects with polymorphism • Suppose we have: void doStuff(Shape s) { s.erase(); // ... s.draw(); } • and we have: Circle circle = new Circle(); Triangle t = new Triangle(); dostuff(c); dostuff(t);

15. Interchangeable objects with polymorphism • Calls to dostuff works correctly. At runtime draw() and erase() methods of correct object is called. • The process of treating a derived type as a base type is called upcasting

16. Abstract base class and interfaces • Often it is needed that base class only represent a common interface for its derived classes. One main usage is for upcasting. • This is done by making the class abstract. An abstract class can't be instantiated • It is also possible to have an abstract method (which means it is not implemented yet) • Interface is like abstract class, but in interface there is no method definition at all • One of the big differences between C++ and Java is that C++ doesn't have interface concept, and Java does not have multiple inheritance

17. Object creation, use and lifetimes • Technically OOP is just about abstract data typing, inheritance and polymorphism. But some other issues are also important in writing OO programs. • One important issue is object lifetime: • C++ approach: Programmer controls memory allocation and disposal • Memory leaks is a major headache for programmers • Java approach: System controls memory allocation and disposal. Garbage collector takes care of removing objects that are no longer in use. • Programmers are not worrying about memory leaks

18. Containers • In many useful programs it is needed to store a collection of objects. The number of objects are not known at the program development time • Every OO language has facilities to store collection of objects • Java has several different type of Lists, Maps and Sets used as containers • Containers provides methods to: • Put elements in • Get elements out

19. Iterators • One of the standard ways to traverse all elements of a container is by the use of iterators • An iterator hides the details of a container from the code that is accessing that container • An iterator provides a SEQUENCE view of container • It does not matter if the container is a ArrayList, LinkedList or Stack. An iterator provides a sequence access to the elements of the container • So it is possible to change a data structure (if needed) without disturbing the client's code

20. The singly rooted hierarchy • Java has a single rooted base class which is named Object • All objects inherits from Object class • Therefore all the Objects share a common interface • One usage is toString() method, which all the objects inherits from Object class • Another usage is for garbage collection

21. Downcasting vs. templates/generics • Containers in Java stores and retreive objects of type Objects.When adding a object to a container it is upcasted to Object. When retrieving an object from container it is of type Object and normally is casted again but down the hierarchy to a specific type. This is named downcasting • But you should know the exact type of the object for downcasting • Another approach is what is in C++. It is named templates. When creating a container we specify the type of objects that is stored there. Next version of Java supports this with the name generics

22. Object clean up and garbage collector • Java keeps track of object references and if all references to an objects is deleted, garbage collector delete the object from memory • In C++ there is no garbage collector. • The Java way is much convenient for programmers • But for some application areas (like real time systems), CPU time wasted by garbage collector is not acceptable

23. Exception handling • Exceptions are thrown when an error occurs • Exceptions can be caught by an exception handler • It simplifies writing programs by enabling to treat exception as alternative path to normal program execution • Exceptions provides some mechanism to reliably recover from a bad situation • Java provides a solid exception handling that forces the programmers to write code to handle exceptions • Exceptions are a kind of object in Java

24. Concurrency (multi-threading) • Java simplifies writing multi-threading programs • It shares CPU time between threads • However, shared resources should be managed by programmers • Synchronized keyword is used for controlling access shared resources

25. Persistence • Normally when a program terminates, all objects are destroyed • Sometime it is needed to have objects even after program terminates • Java provides a way to store and retrieve objects on non-volatile memory. • This is named Serialization in Java

26. Java and the internet • Web? Client-Server programming. • Client-side programming: HTML, Javascript, Plug-ins, Java applets • Server-side programming: CGI, Java web applications, .Net and C# • Java applications: Standalone applications, Server-side applications, client-side applets