Building abstractions with data part 2
Download
1 / 90

Building Abstractions with Data (Part 2) - PowerPoint PPT Presentation


  • 135 Views
  • Uploaded on

Building Abstractions with Data (Part 2). CS 21a: Introduction to Computing I First Semester, 2013-2014. Last Time…. Building abstractions for data, analogous to abstractions for procedures The idea of types Algorithm- centered perspective Algorithms are active

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Building Abstractions with Data (Part 2)' - emele


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Building abstractions with data part 2

Building Abstractions with Data (Part 2)

CS 21a: Introduction to Computing I

First Semester, 2013-2014


Last time
Last Time…

  • Building abstractions for data, analogous to abstractions for procedures

  • The idea of types

  • Algorithm-centered perspective

    • Algorithms are active

    • Algorithms manipulate data


Today
Today…

  • More layers of abstraction

  • A deeper discussion about data types

  • Data-centeredperspective

    • Data are active

    • Data use algorithms


Outline
Outline

  • Hierarchies of Abstraction

  • Data Types and Data Structures

  • From Procedural to OOP


Compound data types can be made of compound data types
Compound Data Types Can Be Made of Compound Data Types

  • This should come as no surprise, given that we want to apply the same principles of abstraction to both algorithms and data.


Example
Example

class Point {

intx, y;

}

class Circle {

Point center;

intradius;

}

classLineSegment {

Point firstEndPoint, secondEndPoint;

}


Example1
Example

classStickFigure {

Circle head;

LineSegmentleftArm,

rightArm,

body,

leftLeg,

rightLeg;

}


What allows hierarchies of abstraction
What Allows Hierarchies of Abstraction?

  • The means of combination has the closure property (mathematics).

  • Recall: A set is closed under an operation if performing the operation on members of the set produces a member of the same set.

    • Example: integer + integer = integer


What allows hierarchies of abstraction1
What Allows Hierarchies of Abstraction?

  • If our set is a set of combinations (including primitives) and the operator is a combination operator, we have the following:

    • Expression op expression = expression

    • Procedure combine procedure = procedure

    • Data structure combine data structure = data structure





What allows hierarchies of abstraction2
What Allows Hierarchies of Abstraction?

  • Notice the intimate relationship between hierarchies, trees, recursion, and the closure property.


Practice programming problem facebook profile
Practice Programming Problem: Facebook Profile

  • Define all the data types needed, along with the constructors and selectors, to implement a Facebook profile with the following information:

  • Id

  • Name

  • Birthday and Age

  • Phone Number

  • E-mail Address

  • Hometown

  • Location


Outline1
Outline

  • Hierarchies of Abstraction

  • Data Types and Data Structures

  • From Procedural to OOP


What is a data type
What is a Data Type?

  • A set of possible values

  • Constructors are the means for building the whole (data of compound data type) out of the parts (data of simpler data types).

  • Selectors are the means for taking the parts (data of simpler data types) from the whole (data of compound data type).


What is a data type1
What is a Data Type?

  • A data type is a set of values and the expression of the need for constructors and selectors for breaking down those values in terms of simpler data types.


The data has to obey certain properties
The Data Has to Obey Certain Properties

  • The value of f is a Fractioniff…

  • The value of f is the result of makeFraction(a, b) implies num(f)is a and denom(f) is b, for some integers a and b


The data has to obey certain properties1
The Data Has to Obey Certain Properties

  • Not just any variable can be meaningfully passed to numor denom

  • Not just any definition of makeFraction, num, and denomwill produce data that obeys this property


The data structure implements the data type
The Data Structure Implements the Data Type

  • A data structure is a implementation of a data type.

  • A correct data structure for a data type has the correct definitions of the constructors and selectors to ensure that the data obeys rules imposed by the data type.


The data structure implements the data type1
The Data Structure Implements the Data Type

  • A data structure includes a complete description of how a data type is composed of simpler data types:

    • The types and (internally) the names of its parts.

    • Constructors: How the whole is made from the parts.

    • Selectors: How the parts are obtained from the whole.


A piece of data is an instance of a type
A Piece of Data is an Instance of a Type

  • The set is not the member of the set.

  • 1 is an int, but 1 is not int.

  • The data type is the blueprint, or idea, that all its instances must follow.

  • A piece of data is an instance of a data type.

Note: it’s sometimes convenient to use the term “data type” to refer to both the abstract data type (which embodies the required properties without caring about the implementation) and any single concrete data structure that correctly implements the abstract data type.



Magic analogies
Magic Analogies

Problems

Data Types

A data type is a set of values and the expression of the need for procedures (constructors and selectors) for relating those values to simpler data types.

  • A problem is a set of input-output pairs and the expression of the need for procedures for relating those input-output pairs to simpler problems.


Magic analogies1
Magic Analogies

Algorithms

Data Structures

Data structures implement data types.

There are many data structures that correctly implement one data type.

Choice depends on application.

  • Algorithms solve problems.

  • There are many algorithms that correctly solve one problem.

    • Choice depends on application.


Magic analogies2
Magic Analogies

Computations

Data

Two independent pieces of data created from the same data structure may yield different values, even if they arise out of the same data structure.

  • Two independent simulations of the same algorithm may yield different behaviors, even if they arise out of the same algorithm.


Magic analogies3
Magic Analogies

Computations

Data

Two different data structures that implement the same data type can yield two pieces of data that look different, but given the same procedure applications will produce the same behavior.

  • Two different algorithms that solve the same problem can yield two computations that look different, but given the same question will produce the same answers.


Does this definition apply to primitive types as well
Does This Definition Apply to Primitive Types As Well?

  • Primitive data (and Strings) can be instantiated from a primitive data type (and the String type) using a literal.

    • Constructor: assigning a literal to a variable.

  • The value of a variable containing primitive data can be obtained by directly looking up the associated literal.

    • Selector: directly evaluating a variable.


Literals
Literals

  • Variables are symbols that refer to other symbols. A variable needs to be evaluated against an environment to know its value.

  • A literal, as opposed to a variable, is a symbol which refers to itself. Its value is itself.

    • Examples: 5, 3.14, "Hello", true, false.


Literals1
Literals

  • Variables: The name is not the variable is not the value.

  • Literals: The name is the literal is the value.


Constants
Constants

  • Some literals get used often enough that they can be given a name.

  • Can be declared outside procedures so that they can be used in all of them

  • Examples:

    • // inside a procedure

      finalintPI = 3.14159265359;

    • // outside a procedure

      staticintDIME_VALUE = 0.10;


Quick practice programming problem pi
Quick Practice Programming Problem: PI

  • Create a procedure that computes the area of a circle given its radius.

  • Declare as a constant.


Outline2
Outline

  • Hierarchies of Abstraction

  • Data Types and Data Structures

  • From Procedural to OOP


Bigger systems need more modularity
Bigger Systems Need More Modularity

  • I have tons of procedures in one file, now what?

    • Can happen in even larger systems

    • Ok, I’ve built barriers of abstraction with procedures to help me maintain the complexity, but…

    • Loading a 1MB file in my IDE just to edit a small part of the system? No, thanks.


Algorithm centered solution
Algorithm-Centered Solution

  • Group all related functionality in modules:

    • Example in games

      • All physics in one module

      • All A.I. in one module

      • All constants in one module

      • All graphics in one module

  • javapjava.lang.Mathto see how it’s designed


Fractions module version
Fractions: Module Version

public class Fraction

{

intnumerator;

intdenominator;

static Fraction makeFraction(intnum, intdenom) {

Fraction f = newFraction();

f.numerator = num;

f.denominator = denom;

return f;

}


Fractions module version1
Fractions: Module Version

static intnum(Fraction x) {

returnx.numerator;

}

static intdenom(Fraction x) {

returnx.denominator;

}

}


Fractions module version2
Fractions: Module Version

publicclass Arithmetic {

staticFraction add(Fraction a, Fraction b) {

intnum = Fraction.num(a) * Fraction.denom(b) +

Fraction.num(b) * Fraction.denom(a);

intdenom = Fraction.denom(a) * Fraction.denom(b);

returnFraction.makeFraction(num, denom);

}

// other operations for arithmetic

// static ComplexNum add(ComplexNum a, ComplexNum b)

}


Fractions module version3
Fractions: Module Version

publicclass Printing {

staticvoid print(Fraction x) {

print(Fraction.num(x));

print("/");

print(Fraction.denom(x));

}

// other operations for printing

// static ComplexNum print(ComplexNum x)

}


Fractions module version4
Fractions: Module Version

publicclassProgramThatUsesFraction{

publicstaticvoid main(String args[]) {

Fraction x = Fraction.makeFraction(3, 2);

Fraction y = Fraction.makeFraction(1, 5);

Fraction sum = Arithmetic.add(x, y);

Printing.print(sum); }

}


Data centered solution
Data-Centered Solution

  • Group everything that has to do with a data type in one class.

  • A class is a blueprint for all objects of a given type, which includes all the procedures that can operate on the given type.


An algorithm centered view of data types
An Algorithm-Centered View of Data Types

  • Data types are sets of possible values.

  • Data types are specified for operations.

    • Operations can only take values of certain types as operands.

    • Operations only return values of certain types.


A data centered view of data types
A Data-Centered View of Data Types

  • Data types are sets of possible values.

  • Operations are specified for data types.

    • Only certain operations can be performed on the values of a type.

    • Only certain operations can produce values of a (possibly different) data type.


Procedural is algorithm centered oop is data centered
Procedural is Algorithm-Centered, OOP is Data-Centered

  • The main idea of OOP:

    • Give data behavior

    • Couple relevant operations on the data type with the data type definition

    • Let data be active, instead of passive arguments to procedures


The procedural view
The Procedural View

  • Statements: Do actions on things.

  • Expressions: Combine things to create other things.

  • Constructors: There are special actions to create things.

  • Selectors: There are special actions to break things apart.


The object oriented view
The Object-Oriented View

  • Statements: Things perform actions.

  • Expressions: Things interact with other things to produce other things.

  • Constructors: Beginning with an initial state is one of the special actions a thing can perform.

  • Accessors: Things can report about its state with special actions.

  • Mutators: Things can change its state with special actions.

The state of an object is its complete description in terms of the values of its components or fields.


A change in vocabulary
A Change in Vocabulary

Procedural

Object-Oriented

Method invocation

Accessor method

  • Procedure call

  • Selector


Fractions oop version
Fractions: OOP Version

  • Suggestion: open the procedural version too to see how the similarities and differences.


Fractions oop version1
Fractions: OOP Version

public class Fraction {

intnumerator, denominator;

public Fraction(intnum, intdenom) {

this.numerator= num;

this.denominator= denom;

}

public intnum() {

returnthis.numerator;

}

public intdenom() {

returnthis.denominator;

}

Put this in a different file from the one that contains your main method.


Fractions oop version continued
Fractions: OOP Version (Continued)

public void print() {

print(this.num());

print("/");

print(this.denom());

}

publicFraction add(Fraction x) {

intnum = this.num() * x.denom() +

x.num() * this.denom();

intdenom = this.denom() * x.denom();

return new Fraction(num, denom);

}

Put this in a different file from the one that contains your main method.


Fractions oop version continued1
Fractions: OOP Version (Continued)

publicvoidsetNum(int x) {

numerator = x;

}

publicvoidsetDenom(int x) {

denominator = x;

}

publicvoid reduce() {

intdivisor = ClassWeDefine.gcd(num(), denom());

setNum( num() / divisor );

setDenom( denom() / divisor );

}

}

Now we can reduce Fractions exactly when we need to!


Using oop fractions
Using OOP Fractions

publicstaticvoid main(String args[])

{

Fraction x = new Fraction(3, 2);

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}


Several differences
Several Differences

  • Changed syntax for defining a constructor (the name of the procedure and the return type is the same and is just typed-in once).

  • Changed syntax for calling a constructor that we defined.

    • The call to a “primitive” constructor can be given arguments.


More important differences
More Important Differences

  • Added public

    • To make it possible to invoke the constructors, accessors, and mutatorsfrom a different class/file

  • Dropped static

    • static means the method, field, or inner class belongs to the class, instead of a specific instance.

    • static is usually used to use a class as a module for procedures.


Static versus non static
Static versus Non-static

  • Math.pow is a static procedure.

    • ClassName.procedure(arguments);

    • Takes input and returns output, usually with no side effects: no changing of state/data associated with objects

    • Procedural style

  • java YourProgramNamecalls YourProgramName.main


Static versus non static1
Static versus Non-static

  • Fraction’s add is a non-static method.

    • instanceVariable.method(arguments);

    • Usually deals with the data associated with an object instance

    • OO style

  • There are other uses of static in OOP, not just for distinguishing OO and Procedural.

    • Beyond the scope of this course.


More important differences1
More Important Differences

  • The object instance is now an implicit argument of the procedure, instead of an explicit one, referred to by the this keyword.

    • The dot operator is used to invoke a method on an object instance as well as access a field.


Most important differences
Most Important Differences

  • Operations on Fractions are now part of the Fraction data type definition (data structure)!

  • Data and procedures coupled more closely

  • Mutator methods: forcefully changing the values of variables.


Most important differences1
Most Important Differences

  • OOP encourages you to think of changing state.

    • Stateless systems: a name for the input, another name for the output

    • State-full systems: one name for the entire “lifetime” of the data

      • from the moment of its “birth” at input

      • to the moment of its “death” at output

      • and all the transformations in between


Practice programming problem oop facebook
Practice Programming Problem: OOP Facebook

  • Convert the Facebook profile definition into OO-style. Add the necessary mutator methods.


By the way
By The Way

  • The thiskeyword can be dropped.

  • If we use a variable name that isn’t in the scope of the method (neither a local variable name nor a parameter name), Java assumes you’re referring to an instance field.

    • Of course, if there’s no instance field, you get a nasty compile error.

    • The scope of the method is nested inside the scope of the class.


Will this work
Will This Work?

public class Fraction {

intnumerator, denominator;

public intnum() {

returnthis.numerator;

}

// constructor and other methods here

}


Will this work1
Will This Work?

public class Fraction {

intnumerator, denominator;

public intnum() {

returnnumerator;

}

// constructor and other methods here

}


Will this work2
Will This Work?

public class Fraction {

intnumerator, denominator;

public intnum() {

returnthis.num;

}

// constructor and other methods here

}


Will this work3
Will This Work?

public class Fraction {

intnumerator, denominator;

public intnum() {

returnthis.denominator;

}

// constructor and other methods here

}


Will this work4
Will This Work?

public class Fraction {

intnumerator, denominator;

public intnum() {

intnumerator = 0;

returnnumerator;

}

// constructor and other methods here

}


Will this work5
Will This Work?

public class Fraction {

intnumerator, denominator;

public intnum() {

intnumerator = 0;

returnnumerator;

}

// constructor and other methods here

}

This phenomenon is called shadowing.


Will this work6
Will This Work?

public class Fraction {

intnumerator, denominator;

public intnum() {

intnumerator = 0;

returnthis.numerator;

}

// constructor and other methods here

}


Will this work7
Will This Work?

public class Fraction {

intnumerator, denominator;

public intignoreParamReturnNum(int numerator) {

return numerator;

}

// constructor and other methods here

}


Will this work8
Will This Work?

public class Fraction {

intnumerator, denominator;

public intignoreParamReturnNum(int numerator) {

returnthis.numerator;

}

// constructor and other methods here

}


Will this work9
Will This Work?

public class Fraction {

intnumerator, denominator;

public intignoreParamReturnNum(int numerator) {

intnumerator = 0;

returnthis.numerator;

}

// constructor and other methods here

}


Will this work10
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x = newFraction(3);

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}


Will this work11
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x = newFraction();

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}


Will this work12
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x = newFraction();

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}

Default constructor assigns default value (probably not what you want) to fields.


Will this work13
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x = new Traction(3, 2);

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}


Will this work14
Will This Work?

publicstaticvoid main(String args[])

{

Traction x = new Traction(3, 2);

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}


Will this work15
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x = newFraction(3, 2);

Fraction y = new Fraction(1, 5);

Fraction sum = x.add("YOLO");

}


Will this work16
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x;

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}


Will this work17
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x;

Fraction y = new Fraction(1, 5);

Fraction sum = x.add(y);

}

Unassigned object variables are given the special value null: you can’t tell a nothing to do something.


Will this work18
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x = new Fraction(3, 2);

Fraction y;

Fraction sum = x.add(y);

}


Will this work19
Will This Work?

publicstaticvoid main(String args[])

{

Fraction x = new Fraction(3, 2);

Fraction y;

Fraction sum = x.add(y);

}

add will call num and denom on y, but y is null


Three uses of a java class
Three Uses of a Java Class

  • Plain old data

    • Data type definition

    • Class only contains instance fields

  • Helper classes

    • Group procedures into modules

    • Class only contains static methods (and possibly static fields)


Three uses of a java class1
Three Uses of a Java Class

  • Complete objects

    • Class contains instance fields and non-static (instance) methods


Practice programming problem oop fractions
Practice Programming Problem: OOP Fractions

  • Complete the Fractionclass by including the methods for subtracting, multiplying, dividing, and printing Fractions.

  • Also create a MathHelpermodule to contain the gcdprocedure.

  • Create a separate class to contain the main procedure, which will use and test the Fraction class.


Practice programming problem oop fractions1
Practice Programming Problem: OOP Fractions

  • Write a program to compute the following. Print each answer on a separate line, with the numerator and denominator separated by a /character. Express the answer in lowest terms.


Summary
Summary

  • Compound data types can be built out of compound data types too.

  • Hierarchies can be built when combinations have closure.

  • Data structures implement data types.

  • Literals are symbols which refer to themselves.

  • Constants are named literals.


Summary1
Summary

  • One problem, possibly many algorithms

  • One data type, possibly many data structures

  • The same principles work with algorithms and data.

  • Scopes can be nested, but the principles remain the same.


Summary2
Summary

  • Two ways to get more modularity:

    • Group procedures into modules.

    • Data Abstraction + Procedural Abstraction = OOP.

      • state + behavior = objects


Summary3
Summary

  • OOP is about coupling data and procedures.

  • OOP is about coupling state and behavior.

  • OOP is about changing state.


Next time
Next Time…

  • The idea of “changing state,” and what re-assignment does to a program

  • The difference between primitive types and Object types in Java

  • Another way to think about OOP


ad