1 / 68

Fundamentals of Data Abstraction in Software Systems

Understand software object nature, Java types, classes, object functionality, data maintenance, and state in Chapter 1. Learn to classify objects, components, and responsibilities in object-oriented systems. Explore the concepts of mutable and immutable objects, object properties, and functionality through queries and commands.

goering
Download Presentation

Fundamentals of Data Abstraction in Software Systems

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Chapter 1: Data Abstraction. Introductory concepts.

  2. Objectives • After studying this chapter you should understand the following: • the nature of a software object – its properties, functionality, data, and state; • the notions of query and command; • values and collection of values called types; • Java’s built-in types; • variables, and the relationship between values, variables, and types; • classes as collections of related objects; • the syntactic layout of a class as defined in Java; • reference values and reference types. NH-Chapter X

  3. Objectives • Also, you should be able to: • classify an object as immutable or mutable; • describe the components of a system developed using objects; • describe the values comprising the built-in Java types; • describe literals of the built-in Java types; • form legal Java identifiers and name the role of identifiers in programming. NH-Chapter X

  4. Objects • Fundamental abstractions to build software systems. • Objects are often abstractions of real-world entities: • students, • employees, • rooms, • passageways, • chess pieces. NH-Chapter X

  5. Objects • System functionality: set of tasks it must perform. • Tasks system must perform are allocated to objects. • A given object has responsibility for performing certain specific tasks of the system. • A critical part of system design is allocating responsibilities to objects. NH-Chapter X

  6. Data and State • An object is responsible for maintaining relevant data about the thing it models. • Example: Given object Student as part of a registration system. Data it maintains: • Name, • address, • number of credit hours the student is enrolled in, • student’s course schedule, • whether or not the student has paid fees, etc. NH-Chapter X

  7. Data and State • An object contains a number of data items, • Each data item consists of • a data description • an associated value. NH-Chapter X

  8. Data and State • The data descriptions are the properties of the object. • Example: Properties of a student object include • Name, • address, • number of credit hours the student is enrolled in, • student’s course schedule, • whether or not the student has paid fees, etc. • If we are modeling a playing card, object properties will include suit and rank. NH-Chapter X

  9. Data and State • Each property of an object has an associated value. • Examples: • The student’s name is Stephen Dadelus, • the playing card’s rank is Jack, • the window’s width is 100 pixels. NH-Chapter X

  10. Data and State • Instancevariables: variables for object’s values. • A portion of computer memory reserved for storing a particular value. • Memory space used to store an object’s instance variables allocated to object when created. • An instance variable is allocated for each property of the object. • Instance variable contains the data value associated with that property. NH-Chapter X

  11. Data and State • The set of properties of an object is fixed. • The associated values can often change over time: • a student can change address or even name; • a computer user can change the width and height of a window on the screen. • Object’s state: set of object’s instance variables and associated values at any given time. NH-Chapter X

  12. Mutable and Immutable objects • Immutable object: object whose state cannot be changed. • An object whose state can be changed is mutable. NH-Chapter X

  13. Mutable and Immutable objects • Example of mutable objects: • Student, • Computer screen window • Examples of immutable objects: • A playing card • A Calendar date • A color. NH-Chapter X

  14. Functionality: Queries and Commands • An object maintains data in order to support its functionality. • Object functionality: actions the object performs in response to requests from other objects. NH-Chapter X

  15. Functionality: Queries and Commands • Two kinds of requests an object can serve: • Query: request for data • Command: request to change its state. • Object’s features: collection of queries and commands. NH-Chapter X

  16. Queries • A request for data maintained by the object. • Object responds by providing a value. NH-Chapter X

  17. Queries • Examples: • a student object might be queried for the student’s name, • a playing card object for the card’s suit, • a chess piece for its position. • Queries are used to gather information about an object’s state. NH-Chapter X

  18. Queries • An object might support queries for data it does not explicitly store. • Example: object modeling a window maintains length and width. Design query for the window’s area. • Area is not explicitly stored in an object’s instance variables. NH-Chapter X

  19. Queries • An object might not support queries for data it does store. • Example: an object representing a computer user contains the user’s name and password. • The object is not likely to support a query for the password. NH-Chapter X

  20. Commands • Instructs object to perform some action resulting in value stored in one or more of the object’s instance variables to be changed. NH-Chapter X

  21. Commands • Examples: • a student object might be instructed to drop a course, changing the credit hours and course schedule properties of the object; • a chess piece might be told to move to a different square; • or a solitaire playing card object might be instructed to turn over, changing its “is face up” property. NH-Chapter X

  22. Commands • An immutable object supports no commands to change its state. NH-Chapter X

  23. Student name R. Raskolnikov address S. Place, Petersburg socialSecurityNumber 000-00-0001 creditHours 9 feesPaid no Ethics 1001 courseSchedule Law 6592 Comp Sci 1583 Objects change in response to commands drop course (Ethics 1001) SolitairePlayingCard SolitairePlayingCard turnOver suit Heart suit Heart 10 10 rank rank isFaceUp true isFaceUp false state before command command state after command NH-Chapter X

  24. Values and Types • Values: abstractions used to represent, or model, properties of objects. NH-Chapter X

  25. Values and Types • Integers model problem features we count: • the number of students in a class, or • the number of words on a page. • Real numbers model problem features we measure: • the width of a table, • the voltage drop across a line. NH-Chapter X

  26. Values and Types • Values are grouped together according to the operations we perform with them. • Type: A set of values along with the operations that can be performed with them. NH-Chapter X

  27. Java’s built-in primitive types • Integer types: • byte, short, int, long. • Real types: • float, double. • The operations for these types include: • addition, subtraction, multiplication, and division. NH-Chapter X

  28. Java’s built-in primitive types • char: • values include the upper and lower case letters, digits, punctuation marks, and spaces that constitute text. • boolean. • contains only the two values true and false. NH-Chapter X

  29. Ranges of integer type values NH-Chapter X

  30. Types and variables • A variable can contain values of only one type. • An int variable contains a single int value; • a double variable contains a double value, etc. NH-Chapter X

  31. Types and variables • The type of value a variable contains is • “type of the variable” and • fixed when the object is designed. • Example: The width of a window might be 100 pixels at one time, and 150 pixels some time later. • Value will always be an integer, and instance variable modeling it is of type int NH-Chapter X

  32. Classes • Class: collection of similar objects, that is, objects supporting the same queries and commands. • Every object is an instance of some class, which determines the object’s features. NH-Chapter X

  33. /** 1 * A simple integer counter. */ public class Counter { privateint count; /** * Create a new Counter, with * the count initialized to 0 */ public Counter () { count = 0; } /** * The number of items counted */ publicint currentCount () { return count; } /** 2 * Increment the count by 1. */ publicvoid incrementCount () { count = count + 1; } /** * Reset the count to 0. */ publicvoid reset () { count = 0; } } // end of class Counter Example: A class modeling a counter NH-Chapter X

  34. Reference values: Objects as properties of objects • Know how to model object’s properties such as numbers, or characters. • How to model properties like the name, address, and course schedule or birthday of a student? NH-Chapter X

  35. Reference values: Objects as properties of objects • Example: to model birthday, we first model a date with an object, via the class Date: NH-Chapter X

  36. Student Date … 2 int month Date birthday int day 2 … int year 1982 Reference values • The student’s value for property “birthday” denotes or refers to a Date object. • Value is a reference value. • Type is reference-to-Date • reference value: a value that denotes an object. NH-Chapter X

  37. String value "S. Place, Petersburg" int length 20 String value "R. Raskolnikov" int length 14 Modeling students name, address: Java’s class String • String instance: immutable object that contains a sequence of characters. • A String can be queried for length and for individual characters that comprise it. • Class contains no state-changing commands. NH-Chapter X

  38. Overview of a complete system • Set of objects comprising system can be divided into: • Model: objects that cooperate to solve the problem. • external interface: or user interface and • data management: objects that maintain problem’s data. NH-Chapter X

  39. Overview of a complete system • Example: • We build a very simple system to test a Counter. • The model : only a single class Counter. • The user interface: only a single class CounterTester. • Data management: none. NH-Chapter X

  40. //A simple tester for the class Counter. • public class CounterTester { • private Counter counter; • // Create a new CounterTester. • public CounterTester () { • counter = new Counter(); • } • // Run the test. • publicvoid start () { • System.out.println("Starting count:"); • System.out.println(counter.currentCount()); • counter.incrementCount(); • counter.incrementCount(); • counter.incrementCount(); • System.out.println("After 3 increments:"); • System.out.println(counter.currentCount()); • counter.reset(); • System.out.println("After reset:"); • System.out.println(counter.currentCount()); • } • } NH-Chapter X

  41. Getting it all started • We need one more class containing a method named main, as shown • /** • * Test the class Counter. • */ • public class Test { • /** • * Run a Counter test. • */ • public static void main (String[] args) { • CounterTester tester = new CounterTester(); • tester.start(); • } • } NH-Chapter X

  42. Running a program • It depends on the computing system and environment used. We must identify class containing method main to the Java run-time system. For instance, • Running the program will produce six lines of output: $ java Test Starting count: 0 After 3 increments: 3 After reset: 0 NH-Chapter X

  43. Identifiers • We use identifiers to name things in Java. • A Java identifier is a sequence of characters consisting of letters, digits, dollar signs($), and/or underscores(_). An identifier can be of any length, and cannot begin with a digit. X Abc aVeryLongIdentifier b29 a2b A_a_x b$2 $_ $$$ IXLR8 • Not legal identifiers. 2BRnot2B a.b Hello! A-a Test.java NH-Chapter X

  44. Identifiers • Java identifiers are case sensitive. This means that upper and lower case characters are different. For example, the following are all different identifiers. total Total TOTAL tOtAl NH-Chapter X

  45. Identifiers • There are a number of keywords and identifier literals reserved for special purposes. • Cannot be used as identifiers. • Identifier literals: true, false,null NH-Chapter X

  46. Guidelines in choosing identifiers • Use lower-case characters, with upper-case characters inserted for readability. • Capitalize class names. • Choose descriptive identifiers • Avoid overly long identifiers. • Avoid abbreviations. • Be as specific as possible. • Take particular care to distinguish closely related entities. • Don’t incorporate the name of its syntactic category in the name of an entity NH-Chapter X

  47. Literals • A literal is a representation of a value. NH-Chapter X

  48. Integer Literals • Integer literals look like ordinary decimal numbers, and denote values of the type int. • Integer literals can’t contain commas and shouldn’t have leading zeros. 25 0 1233456 289765 7 NH-Chapter X

  49. Floating point Literals • Numbers that include a decimal point denote values of type double. 0.5 2.67 0.00123 12.0 2. .6 NH-Chapter X

  50. Floating point Literals • Exponential notation can also be used for double literals. The following are legal double literals: 0.5e+3 0.5e-3 0.5E3 5e4 2.0E-27 NH-Chapter X

More Related