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