Designing Classes Chapter 3. 2 Chapter Contents Encapsulation Specifying Methods Java Interfaces Writing an Interface Implementing an Interface An Interface.

Slides:



Advertisements
Similar presentations
Introduction to Java 2 Programming
Advertisements

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.
CS 211 Inheritance AAA.
Inheritance Inheritance Reserved word protected Reserved word super
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 4 Defining Your Own Classes.
Inheritance. Extending Classes It’s possible to create a class by using another as a starting point  i.e. Start with the original class then add methods,
1 Inheritance Reserved word protected Reserved word super Overriding methods Class Hierarchies Reading for this lecture: L&L 8.1 – 8.5.
Inheritance and Class Hierarchies Chapter 3. Chapter 3: Inheritance and Class Hierarchies2 Chapter Objectives To understand inheritance and how it facilitates.
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 4 Defining Your Own Classes.
Aalborg Media Lab 23-Jun-15 Inheritance Lecture 10 Chapter 8.
©The McGraw-Hill Companies, Inc. Permission required for reproduction or display. 4 th Ed Chapter Chapter 4 Defining Your Own Classes.
1 CS1001 Lecture Overview Object Oriented Design Object Oriented Design.
Chapter 10 Classes Continued
OO Analysis and Design CMPS OOA/OOD Cursory explanation of OOP emphasizes ▫ Syntax  classes, inheritance, message passing, virtual, static Most.
Systems Analysis and Design in a Changing World, Fifth Edition
Chapter 6 Class Inheritance F Superclasses and Subclasses F Keywords: super F Overriding methods F The Object Class F Modifiers: protected, final and abstract.
Writing Classes (Chapter 4)
Chapter 3 Introduction to Collections – Stacks Modified
CSC 142 B 1 CSC 142 Java objects: a first view [Reading: chapters 1 & 2]
1 Object-Oriented Software Engineering CS Interfaces Interfaces are contracts Contracts between software groups Defines how software interacts with.
Programming in Java Unit 2. Class and variable declaration A class is best thought of as a template from which objects are created. You can create many.
111 Protocols CS 4311 Wirfs Brock et al., Designing Object-Oriented Software, Prentice Hall, (Chapter 8) Meyer, B., Applying design by contract,
Systems Analysis and Design in a Changing World, 3rd Edition
Object Based Programming Chapter 8. 2 In This Chapter We will learn about classes Garbage Collection Data Abstraction and encapsulation.
Centre for Computer Technology ICT214 Object Oriented Design and Programming Week 02 – Classes, Objects, Instances Richard Salomon and Umesh Patel Centre.
10-Nov-15 Java Object Oriented Programming What is it?
Designing Classes Prelude © 2015 Pearson Education, Inc., Upper Saddle River, NJ. All rights reserved. Data Structures and Abstractions with Java, 4e Frank.
Designing Classes Chapter 3. 2 Chapter Contents Encapsulation Specifying Methods Java Interfaces Writing an Interface Implementing an Interface An Interface.
Peyman Dodangeh Sharif University of Technology Fall 2014.
Topic 1 Object Oriented Programming. 1-2 Objectives To review the concepts and terminology of object-oriented programming To discuss some features of.
Programmeren 1 6 september 2010 HOORCOLLEGE 2: INTERACTIE EN CONDITIES PROGRAMMEREN 1 6 SEPTEMBER 2009 Software Systems - Programming1 Programming.
CSC 142 B 1 CSC 142 Java objects: a first view [Reading: chapters 1 & 2]
Inheritance. Inheritance is a fundamental object-oriented design technique used to create and organize reusable classes Chapter 8 focuses on: deriving.
Introduction to Java Chapter 7 - Classes & Object-oriented Programming1 Chapter 7 Classes and Object-Oriented Programming.
ITEC324 Principle of CS III Chapter 2 (Horstmann’s Book) – Part 1 The Object-Oriented Design Process Hwajung Lee.
Object Oriented Programming
Computer Science 209 Software Development Handing Errors and Creating Documentation.
Application development with Java Lecture 21. Inheritance Subclasses Overriding Object class.
Coming up: Inheritance
Java Classes Chapter 1. 2 Chapter Contents Objects and Classes Using Methods in a Java Class References and Aliases Arguments and Parameters Defining.
1 Inheritance Reserved word protected Reserved word super Overriding methods Class Hierarchies Reading for this lecture: L&L 9.1 – 9.4.
Side effects A side effect is anything that happens in a method other than computing and/or returning a value. Example: public class hello { public int.
Data Design and Implementation. Definitions Atomic or primitive type A data type whose elements are single, non-decomposable data items Composite type.
Inheritance and Class Hierarchies Chapter 3. Chapter 3: Inheritance and Class Hierarchies2 Chapter Objectives To understand inheritance and how it facilitates.
Inheritance and Class Hierarchies Chapter 3. Chapter Objectives  To understand inheritance and how it facilitates code reuse  To understand how Java.
Designing Classes Chapter 3. Contents Encapsulation Specifying Methods Java Interfaces – Writing an Interface – Implementing an Interface – An Interface.
Object orientation and Packaging in Java Object Orientation and Packaging Introduction: After completing this chapter, you will be able to identify.
Defining Classes I Part B. Information hiding & encapsulation separate how to use the class from the implementation details separate how to use the class.
SourceAnatomy1 Java Source Anatomy Barb Ericson Georgia Institute of Technology July 2008.
 Description of Inheritance  Base Class Object  Subclass, Subtype, and Substitutability  Forms of Inheritance  Modifiers and Inheritance  The Benefits.
CSC 243 – Java Programming, Spring, 2014 Week 4, Interfaces, Derived Classes, and Abstract Classes.
Chapter 2 (Horstmann’s Book) – Part 1 The Object-Oriented Design Process Hwajung Lee.
Unit 1 - Introducing Abstract Data Type (ADT) Part 1.
11 Systems Analysis and Design in a Changing World, Fifth Edition.
9.1 CLASS (STATIC) VARIABLES AND METHODS Defining classes is only one aspect of object-oriented programming. The real power of object-oriented programming.
Classes CS 162 (Summer 2009). Parts of a Class Instance Fields Methods.
Object-Oriented Analysis and Design
Inheritance and Polymorphism
Encapsulation and Java Interface
Data Abstraction: The Walls
About the Presentations
Object Based Programming
Object Oriented Analysis and Design
Slides by Steve Armstrong LeTourneau University Longview, TX
Abstract Class As per dictionary, abstraction is the quality of dealing with ideas rather than events. For example, when you consider the case of ,
Outline Anatomy of a Class Encapsulation Anatomy of a Method
ITEC324 Principle of CS III
ITEC324 Principle of CS III
Presentation transcript:

Designing Classes Chapter 3

2 Chapter Contents Encapsulation Specifying Methods Java Interfaces Writing an Interface Implementing an Interface An Interface as a Data Type Type Casts Within an Interface Implementation Extending an Interface Named Constants Within an Interface Interfaces Versus Abstract Classes Choosing Classes Identifying Classes CRC Cards Reusing Classes

3 Encapsulation Hides the fine detail of the inner workings of the class The implementation is hidden Often called "information hiding" Part of the class is visible The necessary controls for the class are left visible The class interface is made visible The programmer is given only enough information to use the class public stuff

4 Encapsulation Fig. 3-1 An automobile's controls are visible to the driver, but its inner workings are hidden.

5 Abstraction A process that has the designer ask what instead of why or how. What is it you want to do with the data What will be done to the data The designer does not consider how the class's methods will accomplish their goals The client interface is the what The implementation is the how goes into the interface

6 Abstraction Fig. 3-2 An interface provides well-regulated communication between a hidden implementation and a client. We are using “interface” in two senses here – public face of a class and a Java Interface. The latter is a “forced” set of rules for the former.

7 Specifying Methods Specify what each method does Precondition Defines responsibility of client code. What must be true before the method is called. Postcondition Specifies what will happen if the preconditions are met. What is true about the data after the method is called. Assertions can be written as comments to identify design logic // Assertion: intVal >= 0 like a precondition

8 Specifying Methods I also add: Overview: A simple, English-language explanation of what the method does. Exception: An explanation of any exceptions a method handles or at least encounters even if the method doesn’t “handle” them. I rename Precondition as Requires I rename Postcondition as Returns

9 Java Interface A program component that contains Public constants Signatures for public methods Comments that describe them Begins like a class definition Use the word interface instead of class public interface someClass { public int someMethod(); } “final” stuff

10 Java Interface Example public interface NameInterface {/** Task: Sets the first and last names. firstName a string that is the desired first name lastName a string that is the desired last name */ public void setName(String firstName, String lastName); /** Task: Gets the full name. a string containing the first and last names */ public String getName(); public void setFirst(String firstName); public String getFirst(); public void setLast(String lastName); public String getLast(); public void giveLastNameTo(NameInterface child); public String toString(); } // end NameInterface javadoc comment. Look in the Javadoc view of Eclipse.

11 Implementing an Interface A class that implements an interface must state so at start of definition public class myClass implements someInterface The class must implement every method declared in the interface Multiple classes can implement the same interface A class can implement more than one interface An interface can be used as a data type public void someMethod (someInterface x) a promise to implement all methods in the interface. Important: someMethod() can be written before any class that implements someInterface

12 Implementing an Interface Fig. 3-3 The files for an interface, a class that implements the interface, and the client.

13 Type Casts Within an Interface Implementation In any class that implements an interface A parameter may be of type Object A type cast would probably be needed within that method public class Pet implements Comparable {private String name; private int age; // in years private double weight; // in pounds /** Task: Compares the weight of two pets. */ public int compareTo(Object other) {Pet otherPet = (Pet)other; return weight - otherPet.weight; } // end compareTo } // end Pet

14 Generic Comparable Interface: package java.lang; public interface Comparable { public int compareTo(T,other); } public class Circle implements Comparable, Measurable { private double radius;... public int compareTo(Circle other) { // notice; no need to cast if ( this.equals(other)) return 0; // other as a Circle; it already if ( radius < other.radius ) return -1; // is a Circle. return 1; }

15 Extending an Interface Use inheritance to derive an interface from another When an interface extends another It has all the methods of the inherited interface Also include some new methods Also possible to combine several interfaces into a new interface Not possible with classes not “implements”

16 Named Constants Within an Interface An interface can contain named constants Public data fields initialized and declared as final Consider an interface with a collection of named constants Then derive variety of interfaces that can make use of these constants public interface ConstantsInterface { public static final int STUNPort = 3478;... }

17 Interfaces Versus Abstract Classes Purpose of interface similar to purpose of abstract class But … an interface is not a base class It is not a class of any kind Use an abstract base class when You need a method or private data field that classes will have in common Otherwise use an interface classes are much more “valuable” than interfaces

18 Choosing Classes Look at a prospective system from a functional point of view Ask What or who will use the system What can each actor do with the system Which scenarios involve common goals Use a case diagram

19 Choosing Classes Fig. 3-4 A use case diagram for a registration system

20 Identifying Classes Describe the system Identify nouns and verbs Nouns suggest classes Students Transactions Customers Verbs suggest appropriate methods Print an object Post a transaction Bill the customer

21 Identifying Classes Fig. 3-5 A description of a use case for adding a course

22 CRC Cards Index cards – each card represents one class Write a descriptive name for class at top List the class's responsibilities The methods Indicate interactions The collaborations These are CRC cards "Class-Responsibility-Collaboration"

23 CRC Cards Fig. 3-6 A class-responsibility-collaboration card

24 Unified Modeling Language Used to illustrate a system's classes and relationships Provides a class diagram Class name Attributes Operations Fig. 3-7 A class representation that can be part of a class diagram.

25 Unified Modeling Language Fig. 3-8 UML notation for a base class Student and two derived classes

26 Unified Modeling Language Fig. 3-9 Part of a UML class diagram with associations.

27 Reusing Classes Much software combines: Existing components New components When designing new classes Plan for reusability in the future Make objects as general as possible Avoid dependencies that restrict later use by another programmer