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