COSC1030

COSC1030 DATA STRUCTURES IN JAVA

Important Notes • Final drop date – July 13 • Web site is our information center • Check web site before raising questions • Enrollment or change session – go to office • Read Ch. 1 before next lecture

Course Plan • 11 1/2 Lectures • May have quiz in class • 4 Assignments worth 5% each • Expect Reports plus programs • Midterm Exam worth 30% • Common Midterm • Final 50% • Common Final

Lectures • May 29 – Java Review • June 5 – SE Concepts & Comp Complexity • June 12 – Object Reference (A1 Due) • June 19 – Recursion • June 26 – Linear Data Structure (A2 Due) • July 3 – Midterm • July 10 – Modularity & Data Abstraction July 17 – List, String and DMA (A3 Due)

Lecture (continued) • July 24 – Trees • July 31 – Hash Table (A4 Due) • August 7 – Sorting 1 • August 14 – Sorting (2) • Final Exam

JAVA Review • Main Features of JAVA • JAVA Language entities • Name and Scope • Data Types • Operations & Expression • Control Flows • Classes and Objects • Fields and Methods

Main Features of JAVA • JAVA Platform • Portable, Byte Code, Interpreter • Network Enabled • Applets, URL • Security • Signed Jars, Sandbox Model • Multi Thread • Concurrent, Synchronized Method

Main Features of JAVA • Strong Typed • Type Checking at Compilation Time • Dynamic Checking for Casting • Exception Handling • Garbage Collection • Thin Core + Expandable Library • OOP

JAVA Language Entities • Literatures • Variables • Expressions • Statements • Labels • Methods • Types • Classes and Interfaces • Packages

Literal • Atomic values without a name • 27, 033, 0x1B, 1L • 3.1415 1. .1 1.0E-10 10F • ‘A’, ‘á’,‘\n’ • “This is a literature.” • true, false • static final int ZERO = 0 • ZERO is not a literature, it’s a named constant

Identifier • A simple name of a • package, type, variable or method • Declaration • Specifies the kind of entity that the Id denotes • Definition • Implements the entity it specifies • Declare before use

package com.ibm.anything; public interface IFace { // com.ibm.anyting.IFace public static final int ZERO = 0; public void foo(); } import com.ibm.anything.IFace; public class Biz implements IFace { private int i = 0; private Object obj = new String(“A string object”); public Biz() { i = (obj == “A String object”) ? 0 : 1; } public void foo() { System.out.print(“foo()”); } public void main(String args) {…} }

Names • Denote to a language entity • Simple Form and Dot-form • Duplicated Names • Have the same dot-form • Not allowed • Variable names – field, local, formal parameter • Method Names • Type names – Primitive, Class & Interface • Package Names

Scope of names • Scope – a part of a program text in which the entity can be referenced by its simple name • Hidden Scope Due to Overridden • A Name May Visible Outside Its Scope • Use its dot-name notation. • a.b.c; • this.c; super.c; • …foo().c;

class Test extends Base { // public int var = 0 is defined in Base int var = 1; public Test foo(int var) { var = 2; // Which var is changed? try { int var = 3; // Is this legal? } catch (Throwable ex) { int var = 4; // No, both are syntax errors } // What are values of super.var, this.var, and var respectively? // They are 0, 1 and 2 respectively. } public void bar() { int var = 5; } } Scope of name

Variables • Field variables • Class Fields • Instance Fields • Local variables • Formal Parameters • Variable Attributes • Public, Protected, Private • Static, • Final, Transient, Volatile

Visibility of Variables • Visibility – where it can be referenced • A variable is visible within its scope. • Field variables • The scope is the whole class • Public field is visible via object reference • Protected field is visible in sub-classes • Private field can only be accessed in the class

Expression • Expression calculates value • Each expression has a static type • The value generated is of the (sub) type • Create a new object – constructor • Method call is an expression of the return type

Precedence of Operators • Postfix ops : . [exp] (args)exp++ exp-- • Unary ops: ++exp –exp +exp –exp !exp ~exp • Creation and typecast: new exp (type)exp • Multiplicative: * / % • Additive ops: + - • Shifting ops: << >> >>> • Relational ops: < > >= <= instanceof • Equality ops: == != • Bitwise and, or, and xor: & ^ | • Logical and && • Logical or || • Conditional operation: ? : • Assignment ops: = += -= *= /= %= >>= <<= >>>=

Control Flow • Atomic statement – assignment • Composition – S1; S2 • Branching – if-then-else, switch • Looping – for, while, do-while • Exception handling – try-catch-final • Communication between objects – Method invocation

Type • Primitive Types • void, int, long, float, double, char, boolean • Reference Types • Array – hosts indexed elements of the same type • String – non mutable sequence of characters • Interface – contract • Class – implementation of a type • Abstract class – customizable common structure, partially implemented

Array Type • Initialize an array int[] ia = new int[3]; System.out.println(ia[0]); // what is the output Shape[] shapes = new Shape[3]; System.out.println(shapes[0]); // what is the output for( int i = 0; i < shapes.length; i++ ) { shapes[i]= new Rectangle(……); } • One dimensional array in Java int[][] iaa = new int[3][]; for (int i = 0; i < iaa.length; i++ ) { iaa[i] = new int[i+1]; }

String & StringBuffer • String is non-mutable String abc = “abc”; abc = “aBc”; // did not change the string “abc” String def = “This is ” + abc + “ string”; • StringBuffer sBuff = new StringBuffer(); StringBuffer sBuff = new StringBuffer(); sBuff.append(“This is ”); sBuff.append(abc); sBuff.append(“ string”); sBuff.setCharAt(8, ‘A’);

Class • Building block of Java • One class one file • Extends super class – Object the root of all classes • Implements interfaces • Template of objects constructed from it • A class may declare: • Fields • Constructors • Methods • Static initialization block

Constructors • Rectangle(int x1, int y1, int x2, int y2) {…} • Default constructor – no parameter • new Rectangle(0.0, 0.0, 1.0,1.0) • Implementation of a constructor • Initialize all field variables • Call another constructor – this(…) • Call super constructor – super(…) as its first statement • Canonical constructor – do the real job • Other constructors transform parameters and then call the canonical

Class Rectangle extends Shape { Point upLeft, buttomRight; Rectangle (int x1, int y1, int x2, int y2) { Point p1 = new Point(x1, y1); Point p2 = new Point(x2, y2); this(p1, p2); // call canonical constructor } Rectangle(Point anUpLeft, Point aButtomRight) { super(); // call super first upLeft = anUpLeft; buttomRight = aButtomRight; } }

Methods • Method header - Signature • Return type • Method name • Parameters • Exceptions • Overloading methods – same name but different parameters • Overriding methods – defined in subclass with the same signature in the super • Abstract method • Canonical method

Summary of Java Review • Features of Java • Platform independent, network enabled, multi threaded, interpret, object oriented programming language • Language entities • Name and scope • Primitive & reference types • Classes – Methods, Constructors, Fields & Static block • Arrays – one dimensional array • String and string buffer

Object vs. Class • Class is a description of objects – static • Class specifies behavior of objects • Object only exists at run time – dynamic • Objects differ in types – construction class • Objects differ in state – value of their fields

Interface • A contract between user and implementer • Loosen couple between components • Different Implementations from different vendors • Hide implementation details to users • Parallel development of a project

Abstract Class • Partial implementation • Provide important concepts • Hide implementation details • Customizable Structure • Customize by sub-classing • A sub-class only needs to implement unfinished parts

Inheritance • class SubClass extends SuperClass • The SubClass inherits all fields and methods from the super • Fields and methods can be overridden • Overridden fields and methods still visible via super • Add subclass specific fields and methods • Reuse super class

Overloading & Overriding • Overloading • A name used for different meanings • 3 + 5 and “A string” + “another” • Methods with different signatures • Overriding • Re-implement method in sub class • Overridden the method in super class • The method in super still visible • Dynamic binding and polymorphism

class Shape { …… void draw() { // be overridden in sub classes System.out.println(“Don’t know how to draw a shape”); } } class Rectangle extends Shape { …… void draw() { // overriding drawLine(…); drawLine(…); drawLine(…); drawLine(…); } void draw(Device device) { // overloading method drawLine(…, device); … }

Polymorphism • Select method to be invoked at run time based on dynamic type of the requesting object. • The actual behavior of a name denoted is dynamically determined • Most specific method is invoked

class Shape { void draw() {…} } class Rectangle extends Shape{ void draw(){…}} class Circle extends Shape { void draw() {…}} Shape myShape = null; myShape = new Rectangle(); myShape.draw(); // draw rectangle myShape = new Circle(); myShape.draw(); // draw circle

Important OO Concepts • Interface and class • Contract vs. implementation • Inheritance • Single inheritance in Java • Method overloading • Different signatures to the same method (name) • Method overriding • Provide specific method implementation in subclass • Polymorphism • Determine which method to invoke at run time

COSC1030

COSC1030

Presentation Transcript