Data Structures and Algorithms in JAVA Chapter 2

Object Oriented Design Goals Objects : a well defined entity which is a specification of the data fields, also called instance variables, as well as the methods (operations) that the object can execute. Classes : are an excellent example of an object This view of computing is intended to fulfill several goals and incorporate several design principles, which we discuss in this chapter.

Object-Oriented Design Goals Robustness : Correct program is not enough, it has to be robust. ( handling unexpected errors) Adaptability : Programs needs to be able to evolve over time in response to changing conditions in its environment portability, ability of software to run with minimal change on different hardware and operating system platforms.using Java is a key to fulfill this goal. Reusability : same code should be usable as a component of different systems in various applications. Reduce the cost

Object-Oriented Design Principles Abstraction : distill a complicated system down to its most fundamental parts and describe these parts in. - Defines function but not implementation - Abstract Data Type (ADT) ! Data and operations on that data ! Operations are specified with a defined interface ! Specify what and not how You will use classes to design ADTs this quarter

Encapsulation : different components of a software system should not reveal the internal description Information hiding User does not need to know how something is done, just that it is done. Objects encapsulate data and operations Functions encapsulate actions tails of their respective implementations. Modularity : Modularity refers to an organizing principle for code in which different components of a software system are divided into separate functional units

Benefits of Modularity Program construction - Team work - Easier to manage Debugging - Isolates errors - Debug each module as you go easy to locate bugs Reading the program Modifying the program Eliminating redundant code

Hierarchical Organization

Design Patterns It describes the main elements of a solution in an abstract way that can be specialized for a specific problem at hand. Pattern Components: 1. Name; which identifies the pattern. 2. Context; which describes the scenarios for which this pattern can be applied. 3. Template; which describes how the pattern is applied 4. Result; which describes and analyzes what the pattern produces.

Groups of Patterns: 1. Patterns for solving algorithm design problems. - Recursion - Divide-and-conquer 2. Patterns for solving software engineering problems. - Iterator - Adapter - Template method

Inheritance and Polymorphism ◦ Inheritance: Java allows related classes to be organized in a hierarchical manner using the extends keyword.

Polymorphism: Same code behaves differently at different times during execution. This is due to dynamic binding. S x = new S (); x.a(); // call the S version of this method x= new T(); x.a(); // call the T version of this method, object x took more than one meaning - Object Creation and Referencing S x = new S(); // x reference to object of type S x.a(); // call a method using dot operator

Using Inheritance in Java There are two primary ways of using inheritance of classes in Java, specialization and extension Specialization : specializing a general class to particular subclasses class shape{ area(); // general formula}; class oval extends shape { area () // special formula to calculate oval area} class rectangle extends shape { area() // special formula to calculate rectangle area } Extension : add new methods that are not present in the super class class person{ getName();}; class student extends person{ getGPA () ; // extended method to student class }

Types of Method Overriding Refinement : add additional functionality to the code ( constructor of subclasses calls the constructor of superclass using super key word and then adds additional functionality to it) Replacement : completely replaces the method of the superclass that it is overriding ( area () methods for oval and rectangle class are totally different from area() method belongs to superclass Shape)

The Keyword this When this program is executed, it prints the following: The dog local variable =5.0 The dog field = 2

Review of inheritance class Employee { protected String name; protected double payRate; public Employee(String name, double payRate) { this.name = name; this.payRate = payRate; } public String getName() {return name;} public void setPayRate(double newRate) { payRate = newRate; } public double pay() {return payRate;} public void print() { System.out.println("Name: " + name); System.out.println("Pay Rate: "+payRate); }

class HourlyEmployee extends Employee { private int hours; public HourlyEmployee(String hName, double hRate) { super(hName, hRate); hours = 0; } public void addHours(int moreHours) {hours += moreHours;} public double pay() {return payRate * hours;} public void print() { super.print(); System.out.println("Current hours: " + hours); }

Exceptions An Exception is a condition that is caused by a run- time error in the program. The purpose of exception handling mechanism is to provide a means to detect and report an “exceptional circumstances” so that appropriate action can be taken. Exception handling mechanism 1. Find the problem (Hit the exception) 2. Inform that an error has occurred (Throw the exception) 3. Receive the error information (Catch the exception) 4. Take corrective actions (Handle the exception)

Common Java Exceptions Exception TypeCause of Exception ArithmeticExceptionionCaused by math errors such as division by zero ArrayIndexOutOfBoundsExceptionCaused by array indexes ArrayStoreExceptionCaused when a program tries to store the wrong type of data in an array IOExceptionCaused by general I/O failures,such as inability to read from file NullPointerExceptionCaused by referencing a null object

Try Block Statement that causes an exception Try Block Statement that causes an exception Catch Block Statement that handles the exception Catch Block Statement that handles the exception Exception Object Creator Exception handler Throws exception object

---- try { statements; // generate an exception } catch (Exception-type e) { statements; // processes the exception } ----

Example : Class Error3 { public static void main(string args[]) { int a=10; int b=5; int c= 5; int x, y; try { x= a / (b-c); // Exception Here } Catch (ArithemticException e) { System.Out.println( “Division by Zero”); } y = a / (b+c); System.Out.println( “y = ” + y); } }

Interfaces and Abstract Classes The main structural element in Java that enforces an API is the interface. An interface is a collection of method declarations with no data and no bodies.

Multiple Inheritance in Interfaces extending from more than one class is known as multiple inheritance. In JAVA, multiple inheritance is allowed for interfaces but not for classes Multiple Inheritance causes confusion. Class A Void Area(int a); Class B Void Area(int a); Class C C x = new C(); x. Area(3); // this will arise a problem, which area to bind?

Mixin : Unlike Java, some object-oriented languages, such as Smalltalk and C++, allow for multiple inheritance of concrete classes, not just interfaces. In such languages, it is common to define classes, called mixin classes, that are never intended to be created as stand-alone objects, but are instead meant to provide additional functionality to existing classes

Abstract Classes and Strong Typing Abstract Classes and Strong Typing An abstract class: a class that contains empty method declarations (that is, declarations of methods without bodies). An abstract class may not be instantiated, that is, no object can be created from an abstract class. subclass of an abstract class must provide an implementation for the abstract methods of its superclass, unless it is itself abstract. No matter the inheritance hierarchy, at the end we must define the methods in the abstract class.

Example: Abstract class // A Simple demonstration of abstract. abstract class A { abstract void callme(); // concrete methods are still allowed in abstract classes void callmetoo() { System.out.println("This is a concrete method."); } } class B extends A { void callme() { System.out.println("B's implementation of callme."); } } class AbstractDemo { public static void main(String args[]) { B b = new B(); b.callme(); b.callmetoo(); } }

Strong Typing By enforcing that all variables be typed and that methods declare the types they expect and return, Java uses the technique of strong typing to help prevent bugs.

Casting and Generics Widening Casting : A widening conversion occurs when a type T is converted into a "wider" type U. T and U are class types and U is a superclass of T T and U are interface types and U is a superinterface of T T is a class that implements interface U. Example: Integer i = new Integer(3); Number n = i; // widening conversion from Integer to Number Java.lang.Number Narrowing Conversions: A narrowing conversion occurs when a type T is converted into a "narrower" type S. T and S are class types and S is a subclass of T T and S are interface types and S is a subinterface of T T is an interface implemented by class S. Example: Number n = new Integer(2); // widening conversion from Integer to Number Integer i = (Integer) n; // narrowing conversion from Number to Integer

Casting Exception Number n; Integer i; n = new Integer(3); if (n instanceof Integer) i = (Integer) n; // This is legal n = new Double(3.1415); if (n instanceof Integer) i = (Integer) n; // This will not be attempted

Generics A generic type is a type that is not defined at compilation time, but becomes fully specified at run time.