Review Of Fundamental Concepts (Drinking from a Fire hose 101) Object Oriented Programming and Java

Transcription

1 Review Of Fundamental Concepts (Drinking from a Fire hose 101) 1 Object Oriented Programming and Java 2 1

2 Java OOP Review Topics 3 Object resuability Inheritance Composition Aggregation Encapsulation Public/Private/Protected member variables and methods Public/Package Protected classes Polymorphism (late/runtime binding) Upcasting *** Abstract classes and Interfaces (no multiple inheritance in Java) Method overloading Java constructor life cycle Java Packages and the classpath Java Object Reuse 4 public class Shape { BASE CLASS // mv1 is available to everyone public data-type mv1; // mv2 is available only to this class private data-type mv2; // mv3 is available only to this class // and its children (see inheritance) protected data-type mv3; // mv4 is available to this class and any // other in the same package (see Java // packages) data-type membervariable4; public void draw() { //statements for implementation public void erase() { // statements for implementation public void move() { // statements for implementation public void area() { // statements for implementation OVERRIDES FUNCTIONALITY public class Circle extends Shape { public void draw() { //statements for implementation public void erase() { // statements for implementation public void move() { // statements for implementation public void area() { // statements for implementation public class Rectangle extends Shape { EXTENDS FUNCTIONALITY public class Triangle extends Shape { public void fliphorizontal() { // statements for implementation public void flipvertical() { // statements for implementation 2

3 Upcasting Any derived class from a base class may be treated as if it is of type base class. Derived class has the interface of the base class (and possibly other methods as well) If upcasting will only recognize interface of base class (additional methods will not be recognized) Shape[] shapes = new Shape[3]; shapes[1] = new Circle(radius); shapes[2] = new Rectangle(width, height); shapes[3] = new Triangle(base, height); For (int i = 0; i < 3; i++) { System.out.println( Area of shape + i + is + shapes[i].area()); 5 Abstract Classes and Interfaces Abstract class is a base class that presents an interface for derived classes Compiler prevents direct implementation of class Implemented by uniqued subclasses which can be referenced by upcasting to common type abstract methods define stubs for methods in abstract classes that require implementations in subclasses In java, abstract class has at least one method that has not been implemented Interface extends the idea of abstract classes Defines only method stubs and implements NO code Objects that implement interfaces must provide code for EVERY method stub Implementing methods may be upcasted to interface type 6 3

4 Abstract Classes and Interfaces public abstract class Shape { private Color color; public abstract void draw(); public abstract void resize(float s); public Color getcolor() { return color; public class Circle extends Shape { // implementation required public void draw() { // implementation here // implementation required public void resize(double scale) { // implementation here // other methods and variables 7 public interface IShape { // Stubs only public void draw(); public void resize(float s); Public class Circle2 implements IShape { // implementation required public void draw() { // implementation here // implementation required public void resize(double scale) { // implementation here // other methods and variables Multiple Inheritance Any java class can only extend one base class public class derclass extends class1, class2 COMPILER ERROR!!!! Java classes can implement numerous interfaces public class derclass extends class1 implements i1, i2 ACCEPTABLE Use interfaces to inherit multiple java types 8 4

5 Inherited constructors and super(...) When you instantiate an object of a subclass, the system will automatically call the superclass constructor first By default, the zero-argument superclass constructor is called unless a different constructor is specified Access the constructor in the superclass through super(args) If super( ) is used in a subclass constructor, then super( ) must be the first statement in the constructor Constructor life-cycle Each constructor has three phases 1. Invoke the constructor of the superclass 2. Initialize all instance variables based on their initialization statements 3. Execute the body of the constructor 9 Java Packages 10 A collection of related classes and interfaces providing access protection and namespace management Package protection of variables and methods Class name resolution across packages (avoid name conflicts) Creating a package Create a subdirectory with the same name as the desired package and place the source files in that directory Java source file must begin with package keyword and name of package (first statement), then any classes/interfaces in file will be in that package Source file package packagename; public class classname { class nextclassname { 5

6 Java Packages (cont) 11 Using packaged classes Only public members of a packaged class are universally available outside of its package Explicitly protected members (user defined) of a packaged class are available outside its package only to subclasses Accessing packaged classes/objects from an object outside the class Refer to member in code by qualified name Qualified name = packagename.classname Example java.sql.date d = new java.sql.date(); Import member or package containing member import statement * = all classes in package (not a wildcard) package packagename; import otherpackagename1.classname; import otherpackagename2.*; public class classname { Java Packages (cont) If a package statement is omitted from a file, then the code is part of the default package that has no name The package hierarchy reflects the file system directory structure Package java.math The root of any package must be accessible through a Java system default directory or through the CLASSPATH environment variable 12 6

7 Java Built In Packages java javax applet awt io lang event font image sql swing xml border event plaf table namespace parsers transform validation tree math net util Note java.lang.* included in code by default. Others must be explicitly imported 13 CLASSPATH Environment variable and/or switch to inform java compiler and runtime where to find classes, packages, etc. Default = current directory and system libraries Setting the CLASSPATH Environment variable Windows set CLASSPATH =.;C\java;D\cwp\echoserver.jar Unix setenv CLASSPATH.~/java/home/cwp/classes/ Command line switch Compiler javac classpath.;c\java;d\cwp\code.jar client.java Interpreter java classpath.;c\java;d\cwp\code.jar client 14 7

8 CLASSPATH (cont) Default classpath includes current directory and java.lang package CLASSPATH and packages Package naming convention period delimited package.subpackage.sub-subpackage jhuapl jhuapl.edu jhuapl.edu.graphics Qualified class name maps to path to source/class file jhuapl.edu.graphics.myobject located in jhuapl/edu/graphics directory CLASSPATH must point to directory containing the package root, or to the jar file containing the package 15 Java Getting Started and Basic Syntax

9 Basic Java Highlights Immutable objects and the java String class Short circuit evaluation in conditional expressions Java Containers Collections Maps Upcasting Generics in Java Handling Exceptions In Java 17 Strings 18 java.lang.string is a real class in Java, not an array of characters as in C and C++. The String class has a shortcut method to create a new object just use double quotes String s = This is a string ; This differs from normal objects, where you use the new construct to build an object Java String objects are immutable Once initialized they cannot be changed Reassignment of Strings actually creates new objects and throws out originals Inefficient use java StringBuffer objects to create modifiable strings and convert to String as needed StringBuffer sb = new StringBuffer(String s1); sb.append(string s2).append(string s3); String result = sb.tostring(); // result = s1 + s2 + s3 9

10 Java Containers 19 Hold references to objects, no primitives Collection A group of elements with some rule applied to them One item in each location Map A group of key-value object pairs Containers can be accessed via java.util.iterator objects Objects that enable you to move through the objects in a container, select and/or remove each object without information about the details of the stored objects or structure of the sequence java.util.collection Store references to elements as java.lang.objects For primitives (int, boolean, float, etc) must use object wrapper classes java.lang.integer, java.lang.boolean, etc. Variable length, can grow or shrink public void add(java.lang.object) public void remove(java.lang.object) public int size() public Iterator iterator() Java 1.4 and earlier - type information of elements is not preserved, objects must be cast to type upon retrieval from collection public java.lang.object get(int) java.lang.object o = list.get(i); MyClass mc = (MyClass)list.get(j); Java 1.5 uses generics to do type checking at compile time Set HashSet SortedSet TreeSet Collection List ArrayList LinkedList Vector 20 10

11 Collection Hierarchy 21 Collection Interface for holding groups of objects Set Group of objects containing no duplicates Ordering of elements is governed internally HashSet fast lookup LinkedHashSet fast lookup and maintains insertion order SortedSet Set of objects (no duplicates) stored in ascending order Order is determined by a Comparator TreeSet backed by tree structure for ordered access List Physically (versus logically) ordered sequence of objects (ordered as input) ArrayList fast access but slow insert/delete LinkedList fast sequential access (insert/delete) but slow random access java.util.map Stores references in key-value pairs of java.lang.object references public Object put(object key, Object val) public Object get(object key) public int size() public Collection values() public Set keyset() Iterators for walking through collection or map Map HashMap Hashtable SortedMap TreeMap 22 11

12 Map Interfaces Map Stores objects (unordered) identified by unique keys HashMap constant performance for insertion and lookup LinkedHashMap maintains insertion order SortedMap Objects stored in ascending order based on their key value Neither duplicate or null keys are permitted TreeMap backed by trees for keys and values 23 java.util.iterator 24 Objects that enable you to move through the objects in a container, select and/or remove each object without information about the details of the stored objects or structure of the sequence Walking through a Collection or Map Import java.util.*; List l = getlist(); for (Iterator i = list.iterator(); i.hasnext();) { Float f = (Float)i.next(); System.out.println(3 * f.floatvalue()); i.remove(); For Maps, use values() or keyset() method to convert to Collection (Set) and then user iterator() to get Iterator object 12

13 25 Collections & Generics Overview Traditionally compiler can only guarantee that an Object will be returned by Collections API accessors Left to programmer to ensure specific types through casting that is not checked until runtime Generics provides way for programmer to communicate types so compiler will not permit alternatives Generics are usually more restrictive to eliminate ANY possibility of unexpected types Generics syntax results in more readable code without casts Collections & Generics Syntax Designate a collection of type TYPE Collection<TYPE> cvar = new Collection<TYPE>(); for (int i = 0; i < cvar.size(); i++) { TYPE tvar = cvar.get(i); // no casting Example List<String> cvar = new ArrayList<String>(); for (int i = 0; i < cvar.size(); i++) { String tvar = cvar.get(i); // no casting!!! 26 13

14 Collections & Generics Pitfalls Generics forces programmer to be more aware of type relationships. Example Is a List of String also a List of Object??? Since Strings are children of Objects, one would think so, however following example WILL NOT compile List<String> ls = new ArrayList<String>(); List<Object> lo = ls; If permitted then we could add an Object to lo and retrieveit through ls as a String. 27 lo.add(new Object()); String s = ls.get(0); Collections and Generics More Definitions More general types <?> wildcard representing UNKOWN type <? Extends ParentClass> An UNKNOWN type that is a child of ParentClass Restrictions Can access elements as Object using <?> since all java objects subclass Object void printcollection(collection<?> c) { for (Object e c) { System.out.println(e); Cannot assign elements the type or subtype of element is unknown by definition Collection<?> c = new ArrayList<String>(); c.add(new Object()); compile time error 28 14

15 Exceptions An event that occurs during the execution of a program that disrupts its normal flow Access elements of an array beyond its range Attempt to access an object that is null (does not exist) Invalid input Memory exhausted Disk crash Java stores relevant information in a Throwable object and finds code to handle it Searches through the method call stack Default handler provided by Java Runtime Outputs description of exception Outputs hierarchy of methods where exception occurred Terminates program IOException Throwable Exception Error RuntimeException 29 When an Exception Occurs 30 When an exception occurs in a method, that method creates an exception object and hands it to the Java runtime The method throws an exception Object includes information about the error that occurred Runtime searches the call stack (hierarchy of methods) until it finds method with an appropriate exception handler, and passes exception object to that hander If no such handler is found, runtime uses default hander 15

16 Why handle exceptions? Separation of error-handling code from the normal flow of instructions Propogate errors up the stack Group and distinguish different types of exceptions by cause 31 Throwable Types Error A non-recoverable problem occurring outside the standard java libraries or your own code that should not be caught (OutOfMemoryError, StackOverflowError, ) Exception An abnormal condition that should be caught and handled by the programmer RuntimeException Special case; does not have to be caught Usually the result of a poorly written program (integer division by zero, array out-of-bounds, etc.) A RuntimeException is considered a bug 32 16

17 Handling Exceptions 33 Java methods can catch and handle exceptions locally Catches should be ordered from subclass (more specific) to superclass (less specific) Code in Finally is always excecuted regardless of program flow try { catch (SpecificException e1) { catch (LessSpecificException e2) { catch (Exception e3) { finally { Throwing Exceptions Java methods can throw exceptions up the call stack public int divide(int a, int b) throws DivideByZeroException { if (b == 0) { throw new DivideByZeroException( divide by 0 error ); else return a/b; Calling code catches the exception and handles it or passes it further try { int x = object.divide(a, b); catch (DivideByZeroException d) { System.out.println( Exception caught + d.getmessage()); 34 17

18 Multiple Catch Clauses A single try can have more that one catch clause try {... catch (ExceptionType1 var1) { // Do something catch (ExceptionType2 var2) { // Do something else If multiple catch clauses are used, order them from the most specific to the least specific If no appropriate catch is found, the exception is handed to any outer try blocks If no catch clause is found within the method, then the exception is thrown by the method 35 Try-Catch, Example... BufferedReader in = null; String linein; try { in = new BufferedReader(new FileReader("book.txt")); while((linein = in.readline())!= null) { System.out.println(lineIn); in.close(); catch (FileNotFoundException fnfe ) { System.out.println("File not found."); catch (EOFException eofe) { System.out.println("Unexpected End of File."); catch (IOException ioe) { System.out.println("IOError reading input " + ioe); ioe.printstacktrace(); // Show stack dump 36 18

19 The finally Clause After the final catch clause, an optional finally clause may be defined The finally clause is always executed, even if the try or catch blocks are exited through a break, continue, or return try {... catch (SomeException somevar) { // Do something finally { // Always executed 37 Questions? 38 19

20 Further Reading Core Web Programming, Hall and Brown Chapters 6 and 7 Core Java 2, Volume 1 Fundamentals, Horstmann and Cornell Free Resources Thinking In Java Eckel http// The Java Tutorial http//java.sun.com/docs/books/tutorial/index.html 39 Further Reading Thinking In Java, Eckel Chapters 9 and 11 http// Core Web Programming, Hall and Brown Chapters 6 and 8 Effective Java, Bloch Core Java 2, Volume 1 Fundamentals, Horstmann and Cornell Ant The Definitive Guide, Tilly and Burke Free Resources The Java Tutorial http//java.sun.com/docs/books/tutorial/index.html Generics in the Java Programming Language http//java.sun.com/j2se/1.5/pdf/generics-tutorial.pdf 40 20