slides created by Marty Stepp

Slides:



Advertisements
Similar presentations
INTERFACES IN JAVA 1.Java Does not support Multiple Inheritance directly. Multiple inheritance can be achieved in java by the use of interfaces. 2.We need.
Advertisements

CSE 143 Lecture 22: Advanced List Implementation (ADTs; interfaces; abstract classes; inner classes; generics; iterators)
Building Java Programs Chapter 16 Linked Lists. 2 A swap method? Does the following swap method work? Why or why not? public static void main(String[]
CSE 143 Lecture 3 Inheritance slides created by Marty Stepp
Building Java Programs Inner classes, generics, abstract classes reading: 9.6, 15.4,
CSE 143 Lecture 14 Interfaces; Abstract Data Types (ADTs) reading: 9.5, 11.1; 16.4 slides created by Marty Stepp
Building Java Programs Interfaces, Comparable reading: , 16.4, 10.2.
Copyright 2008 by Pearson Education Building Java Programs Chapter 9 Lecture 9-4: Interfaces reading: self-check: exercises: #11.
1 CSE 331 Introduction; Review of Java and OOP slides created by Marty Stepp based on materials by M. Ernst, S. Reges, D. Notkin, R. Mercer, Wikipedia.
CS305j Introduction to Computing Inheritance and Polymorphism 1 Topic 26 Introduction to Inheritance and Polymorphism "One purpose of CRC cards [a design.
CSE 143 Lecture 20 Binary Search Trees continued; Tree Sets read slides created by Marty Stepp and Hélène Martin
CSE 143 Lecture 9 Interfaces; Stacks and Queues slides created by Marty Stepp
Data Design and Implementation. Definitions of Java TYPES Atomic or primitive type A data type whose elements are single, non-decomposable data items.
CSE 143 Lecture 24 Advanced collection classes (ADTs; abstract classes; inner classes; generics; iterators) read 11.1, 9.6, , slides.
CSE 143 Lecture 6 Interfaces; Complexity (Big-Oh) reading: 9.5, 11.1, slides created by Marty Stepp
EE 422C Interfaces Day 5. 2 Announcements SVN has Project 2. –Partly due next week. –SVN update to get it in your repository. See Piazza for Grocery List.
CSE 143 Lecture 20 Abstract classes. 2 Circle public class Circle { private double radius; public Circle(double radius) { this.radius = radius; } public.
CSE 143 Lecture 3 Implementing ArrayIntList reading: slides created by Marty Stepp and Hélène Martin
Building Java Programs Interfaces reading: , 16.4.
Building Java Programs Chapter 9 Interfaces Copyright (c) Pearson All rights reserved.
Lecture 21: Interfaces and Abstract classes
CSE 143 Lecture 14 Interfaces; Abstract Data Types (ADTs)
Lecture 23:More on Interfaces
Lecture 13: Interfaces, Comparable reading: , 16.4, 10.2
Web Design & Development Lecture 9
Sixth Lecture ArrayList Abstract Class and Interface
Building Java Programs Chapter 16
CSE 143 Lecture 20 Binary Search Trees continued; Tree Sets
Building Java Programs
Software Development Java Collections
Interfaces.
Building Java Programs Chapter 16
A tree set Our SearchTree class is essentially a set.
Wednesday Questions How do I debug? We love to teach this at IPL/OH!
Wednesday Notecards What’s your credit card number?
Lecture 1: Welcome to CSE 373
Interfaces EE 422C.
Linked node problem 3 What set of statements turns this picture:
CSE 143 Lecture 9 References and Linked Nodes reading: 3.3; 16.1
Interfaces CS163 Fall 2018.
CSE 143 Lecture 6 Interfaces; Complexity (Big-Oh)
Building Java Programs
CSE 143 Lecture 27: Advanced List Implementation
Lecture 26: Advanced List Implementation
A tree set Our SearchTree class is essentially a set.
CSE 143 Lecture 2 Collections and ArrayIntList
Review: Classes, Inheritance, and Collections
Shapes Consider the task of writing classes to represent 2D shapes such as Circle, Rectangle, and Triangle. Certain operations are common to all shapes:
slides created by Ethan Apter
ArrayLists 22-Feb-19.
Collections Framework
Binary Search Trees continued; Tree Sets
slides created by Marty Stepp
Lecture 8: Complex Linked List Code reading: 16.2 – 16.3
Building Java Programs Chapter 16
Based on slides by Alyssa Harding & Marty Stepp
CSE 143 Lecture 25 Advanced collection classes
Binary search (13.1) binary search: Locates a target value in a sorted array/list by successively eliminating half of the array from consideration. How.
CSE 142 Lecture Notes Inheritance, Interfaces, and Polymorphism
CSE 143 Lecture 3 Implementing ArrayIntList reading:
CSE 373 Implementing a Stack Reading: Weiss Ch. 3; 3.6; 1.5
Lecture 20: Interfaces and Abstract classes
slides created by Alyssa Harding
Building Java Programs
Lecture 7: Linked List Basics reading: 16.2
CSE 143 Lecture 6 interfaces; eclipse; testing
slides created by Marty Stepp
CSE 143 Lecture 21 Advanced List Implementation
slides created by Marty Stepp
slides created by Marty Stepp and Hélène Martin
Presentation transcript:

slides created by Marty Stepp CSE 143 Lecture 12 (A) Interfaces reading: 9.5, 11.1 slides created by Marty Stepp http://www.cs.washington.edu/143/

Related classes Consider the task of writing classes to represent 2D shapes such as Circle, Rectangle, and Triangle. Certain operations are common to all shapes: perimeter: distance around the outside of the shape area: amount of 2D space occupied by the shape Every shape has these, but each computes them differently.

Shape area and perimeter Circle (as defined by radius r ): area =  r 2 perimeter = 2  r Rectangle (as defined by width w and height h ): area = w h perimeter = 2w + 2h Triangle (as defined by side lengths a, b, and c) area = √(s (s - a) (s - b) (s - c)) where s = ½ (a + b + c) perimeter = a + b + c r w h a b c

Common behavior Suppose we have 3 classes Circle, Rectangle, Triangle. Each has the methods perimeter and area. We'd like our client code to be able to treat different kinds of shapes in the same way: Write a method that prints any shape's area and perimeter. Create an array to hold a mixture of the various shape objects. Write a method that could return a rectangle, a circle, a triangle, or any other kind of shape. Make a DrawingPanel display many shapes on screen.

Interfaces (9.5) interface: A list of methods that a class can promise to implement. Inheritance gives you an is-a relationship and code sharing. A Lawyer can be treated as an Employee and inherits its code. Interfaces give you an is-a relationship without code sharing. A Rectangle object can be treated as a Shape but inherits no code. Analogous to non-programming idea of roles or certifications: "I'm certified as a CPA accountant. This assures you I know how to do taxes, audits, and consulting." "I'm 'certified' as a Shape, because I implement the Shape interface. This assures you I know how to compute my area and perimeter."

Interface syntax public interface name { public type name(type name, ..., type name); ... } Example: public interface Vehicle { public int getSpeed(); public void setDirection(int direction);

Shape interface abstract method: A header without an implementation. // Describes features common to all shapes. public interface Shape { public double area(); public double perimeter(); } Saved as Shape.java abstract method: A header without an implementation. The actual bodies are not specified, because we want to allow each class to implement the behavior in its own way.

Implementing an interface public class name implements interface { ... } A class can declare that it "implements" an interface. The class promises to contain each method in that interface. (Otherwise it will fail to compile.) Example: public class Bicycle implements Vehicle {

Interface requirements public class Banana implements Shape { // haha, no methods! pwned } If we write a class that claims to be a Shape but doesn't implement area and perimeter methods, it will not compile. Banana.java:1: Banana is not abstract and does not override abstract method area() in Shape ^

Interfaces + polymorphism Interfaces benefit the client code author the most. they allow polymorphism (the same code can work with different types of objects) public static void printInfo(Shape s) { System.out.println("The shape: " + s); System.out.println("area : " + s.area()); System.out.println("perim: " + s.perimeter()); System.out.println(); } ... Circle circ = new Circle(12.0); Triangle tri = new Triangle(5, 12, 13); printInfo(circ); printInfo(tri);

Linked vs. array lists We have implemented two collection classes: ArrayIntList LinkedIntList They have similar behavior, implemented in different ways. We should be able to treat them the same way in client code. index 1 2 3 value 42 -3 17 9 data next 42 data next -3 data next 17 data next 9 front

An IntList interface // Represents a list of integers. public interface IntList { public void add(int value); public void add(int index, int value); public int get(int index); public int indexOf(int value); public boolean isEmpty(); public void remove(int index); public void set(int index, int value); public int size(); } public class ArrayIntList implements IntList { ... public class LinkedIntList implements IntList { ...

Redundant client code public class ListClient { public static void main(String[] args) { ArrayIntList list1 = new ArrayIntList(); list1.add(18); list1.add(27); list1.add(93); System.out.println(list1); list1.remove(1); LinkedIntList list2 = new LinkedIntList(); list2.add(18); list2.add(27); list2.add(93); System.out.println(list2); list2.remove(1); }

Client code w/ interface public class ListClient { public static void main(String[] args) { IntList list1 = new ArrayIntList(); process(list1); IntList list2 = new LinkedIntList(); process(list2); } public static void process(IntList list) { list.add(18); list.add(27); list.add(93); System.out.println(list); list.remove(1);

ADTs as interfaces (11.1) abstract data type (ADT): A specification of a collection of data and the operations that can be performed on it. Describes what a collection does, not how it does it. Java's collection framework uses interfaces to describe ADTs: Collection, Deque, List, Map, Queue, Set An ADT can be implemented in multiple ways by classes: ArrayList and LinkedList implement List HashSet and TreeSet implement Set LinkedList , ArrayDeque, etc. implement Queue They messed up on Stack; there's no Stack interface, just a class.

When using Java's built-in collection classes: Using ADT interfaces When using Java's built-in collection classes: It is considered good practice to always declare collection variables using the corresponding ADT interface type: List<String> list = new ArrayList<String>(); Methods that accept a collection as a parameter should also declare the parameter using the ADT interface type: public void stutter(List<String> list) { ... }

Why use ADTs? Why would we want more than one kind of list, queue, etc.? Answer: Each implementation is more efficient at certain tasks. ArrayList is faster for adding/removing at the end; LinkedList is faster for adding/removing at the front/middle. HashSet can search a huge data set for a value in short time; TreeSet is slower but keeps the set of data in a sorted order. You choose the optimal implementation for your task, and if the rest of your code is written to use the ADT interfaces, it will work.