USING OBJECTS What are Objects? Properties and Capabilities Classes and Instances Making Instances

1. USING OBJECTS • What are Objects? • Properties and Capabilities • Classes and Instances • Making Instances • A Sample Program Obj ects the object is a road leading over towards the horizon objects are everywhere a world without objects is nothing every object is sacred trust in the object objects rule the world pray to the objects the object is your true master follow the path of the object a Jedi’s strength flows from the object

2. What are Software Objects? • Building blocks of software systems • program is a collection of interacting objects • objects cooperate to complete a task • Objects model conceptual things • meeting • date • to do this, they communicate by sending “messages” to each other • Object model tangible things • school • car • ____________________________ • ____________________________ • Objects model processes • finding path through a maze • sorting a deck of cards • Objects have • capabilities: what they can do, how they behave • properties: features that describe the objects

3. Object Capabilities: Actions • Objects have capabilities that allow them to perform actions • objects are smart　—　they “know” how to do things • an object gets something done only if some other object tells it to use one of its capabilities • Also called behaviors Capabilities can be: • constructors: establish initial state of object’s properties • commands: change object’s properties • queries: provide answers based on object’s properties • Example: trash cans are capable of performing specific actions • 　constructor: be created • 　commands: add trash, empty yourself • 　queries: reply whether lid is open or closed, 　　whether can is full or empty

4. Object Properties: State • Properties determine how an object acts • some properties may be constant, others variable • properties themselves are objects — they also can receive messages • trash can’s lid and trash are objects Properties can be: • attributes: things that help describe an object • components: things that are “part of” an object • associations: things an object knows about, but aren’t parts of the object • State: all of object’s properties; changes if a property changes • some don’t change, e.g., steering wheel of car • others do, e.g., car’s color • Example: properties of trash cans • 　attributes: color, material, smell • 　components: lid, container, trash bag • 　associations: a trash can can be associated with the room it’s in

5. Name that Object • What are some capabilities of the objects in this room? • What are some properties of the objects in this room? • Which of these properties are attributes, which are components and which are associations?

6. Imprints (object instances) Rubber stamp (object class) Classes and Instances • Our current conception: each object corresponds directly to a particular real-life object, e.g., a specific atom or automobile • Disadvantage: too impractical to work with objects this way • may be too many (i.e., modeling all atoms in the universe) • do not want to describe each individual separately, because they may have much in common • Classifying objects factors out commonality • among sets of similar objects • lets us describe what is common once • then “stamp out” any number of copies later

7. Object Classes • Object class • defines a category of objects • defines capabilities common to a set of individual objects • all trash cans can open, close, empty their trash • defines properties that the objects have • a property value of an individual object can be different from others • defines template for making object instances • particular trash cans • each may have a metal casing, be blue, be a certain size, etc. • Classes implement capabilities as methods • a method defines the response to a message • method is a sequence of statements in Java • each statement is a step in the response • objects cooperate by sending messages to others • each message “invokes a method” • i.e., Java executes the sequence of statements in the method • Classes implement a property as an instance variable • slot of memory allocated to the object that can holds some value • its value can be potentially changed

8. Object Instances • Object instances are individual objects • made from the class template • one class may represent an indefinite number of object instances • making an object instance is called instantiating that object • Shorthand: • class: object class • instance: object instance (not to be confused with instance variable) • Different instances of, say, TrashCan class may: • have different color • be at a different location • have different trash inside • So their instance variables can have different values • note: object instances contain instance variables • two different but related uses of the word instance

9. instancea instancei instanceb Object Instances (continued) • Individual instances have individual identities • this allows other objects to send messages to a specific object • each is unique, even though it has same capabilities • think of classroom full of students • Note: in Java, the value of instance variable is always a reference to an instance, not the instance itself • unlike in other programming languages • A reference is just the address in memory where the properties of the instance are stored • also called pointer Properties

10. Memory Revealed • Every instance is stored in computer’s memory • memory is a set of consecutively numbered storage locations, each containing a byte • instance is stored in contiguous bytes starting at a given location • Instance is identified and referenced by unique address of its starting location where it was created • address looks like 0xeff8a9f4 (hexadecimal notation, base 16) • just like postal address represents actual home 0x00000000 (vertical representation) 0x00000001 0x00000002 0x00000080 memory address of instance 1 memory address of instance 2 memory address of instance 3 (horizontal representation of memory)

11. Messages for Object Communication • No instance is an island — it must communicate with others to accomplish task • properties let it know about other objects whom it can talk with • Instances send messages to one another to invoke a capability (i.e., to execute a task) • method is code that implements message • we say “call a method” instead of “invoke capability” • Each message requires: • sender: object initiating action • receiver: instance whose method is being called • messagename: name of method being called • optionally parameters: more info telling method how to operate • we’ll discuss parameters in detail in a few lectures • Receiver can (but does not need to) send reply • we’ll discuss return types in detail in a few lectures

12. Encapsulation • Car encapsulates lots of information • quite literally, under hood and behind dashboard • So, you do not need to know how a car works just to use it • steering wheel and gear shift are the interface • engine, transmission, drive train, wheels, . . . , are the (hidden) implementation • Likewise, you do not need to know how an object works to send messages to it • But, you do need to know what messages it understands (i.e., what its capabilities are) • class of instance determines what messages can be sent to it

13. Public Capability Public Capability Public Capability Public Capability Public Capability Public Capability Views of a Class • Objects separate interface from implementation • object is “black box”; hiding internal workings and parts • interface protects implementation from misuse • Interface: public view • allows instances to cooperate with one another without knowing details • is a contract: list of capabilities and documentation how to use them • Implementation: private view • properties that help capabilities complete their tasks Private Properties Note: private properties shown schematically as literally contained in an object. In reality, they are actually stored elsewhere in memory and referenced by their addresses

14. Notes About Java Syntax • Reserved words • certain words have a particular meaning in Java and cannot be used for any other purpose • case-sensitive (always all lower case) class public new private extends • Identifiers • names used for classes, methods, and variables • first character must be a letter or underscore • rest may be any combination of letters, numbers, and underscores • but no spaces Professor 4thStreet aPrettyLongName a_pretty_long_name

15. Making Code More Readable • Naming conventions • suggestions how to name things • they are intended to make code easier to read and understand • add consistency to a program • not enforced by compiler • We use capitalization to distinguish an identifier’s purpose • class names begin with upper case • method and variable names begin with lower case • in the book, instance variables start with an underscore • this is not common, and we discourage it because it's less readable • different programmers have different programming style • Use a name that represents the functionality of an object Good Name Professor teachClass professor Poor Name Thing (no role, purpose) doStuff (not specific) p(too cryptic) class: method: instance:

16. A Complete Program • Here is our first complete Java program: public class BallApplication extends wheels.users.Frame { public BallApplication () { new Demos.Bounce.BouncingBall (); } public static void main (String [] arguments) { new BallApplication (); } } • We will deconstruct this code • Let’s see the demo!

17. Syntax: Declaring a Class • Class declaration tells Java that we define a new class • i.e., we are “declaring” our intent to “define” class that can be used as a template to instantiate object instances • program must include at least one class definition public class BallApplicationextends wheels.users.Frame • Reserved word public means that anyone can create instance of the class • Reserved word class means that we define a new class • BallApplication is name of the class • named because it is an application (or program) with a bouncing ball • extends wheels.users.Frame means: • there is a classwheels.users.Frame defined in the users subpackage of package wheels (explained later) • an object of class Frame displays a window and a “Quit” button • our class extendsthe functionality of Frame • in this case, we add the ability to create a bouncing ball to the Frame class • our application displays a window with a bouncing ball and a “Quit” button

18. Syntax: Defining a Class • Class definition following declaration tells Java compiler how to make instances of this class and how those instances respond to messages • thus, simply declaring class not enough • we must also definewhat class does (i.e., how it will fulfill its purpose) • Java code is like dictionary: “declaration” of concept, then its definition • no code can appear outside of a class definition • Curly braces{} indicate beginning and end of logical block of code; the “code body” — in this case, class definition • separate declaration from definition • code written between curly braces is belongs to class declared in front of them public class BallApplication extends wheels.users.Frame { } • this is an example of empty code block — “no” code is legal, i.e., syntactically correct, and therefore compiles, but does not do anything useful • Java programs are composed of arbitrarily many classes

19. Constructors • Next we need instances of our classes to do something useful • Constructor is special method that is called whenever the class is instantiated (it creates the instance) • another object sends a message that calls constructor • constructor is the first message an object receives • this object cannot receive a constructor message again • establishes initial state of properties of the instance • If class doesn't define any constructors, Java makes one for you • called default constructor • initializes all instance variables for instance to their default values • We need to write our own constructor... • when our application is created we want to create new object (that bounces around on the screen!)

20. Syntax: Declaring Constructors • We want to declare constructor for our class: public class BallApplication extends wheels.users.Frame { public BallApplication () { } } • This is our first example of method declaration • declares to compiler our intent to define method that implements response to particular message; in this case create a new object of this class • General syntax notes: • public means any other object can call this constructor • BallApplication is method’s name • parentheses () indicate that this method doesn't need parameters (explained later) • Constructors have special syntax: • must always have same name as class name • Notice: constructor is inside the curly braces of class body • so constructor is a special capability of the class

21. Introducing Packages • What does class BallApplication need to fulfill its purpose? • Ball which bounces around screen! • This has already been written for you • built by someone else, but usable by anyone • like parts in a catalog • package is a Java catalog • Packages are collections of related classes • library of reusable classes (demos, wheels) • Packages can also contain other packages • “nesting” provides better organization • like sections and sub-sections in catalog • Packages are reflected in the file system • file with the class must have the name of the class and suffix “.java” • it must be inside a folder whose name is the package name • folder that corresponds to subpackage must be inside a folder whose name is the name of the enclosing package • Always have classes in a package!

22. More Packages • To access classes in another package, must “qualify” class name by package(s) it is in • prepend each package name, separated by periods wheels.users.Frame • Frame is a class in package users, which is a subpackage of wheels • Instead of having to qualify class names we can import them import wheels.users.Frame; • We can also import all classes in a package using “*” import wheels.users.*; • Imports follow package declaration • Unlike the book, we encourage importing classes • it makes code simpler, more readable • it makes statements shorter, often eliminates wrapping onto next line package names class name

23. Object Instantiation • Object instantiation creates an object instance from a particular class • other instances can then send messages to the new instance • constructor is first message: makes the instance public class BallApplication extends wheels.users.Frame { public BallApplication () { new demos.bounce.BouncingBall(); } } • Reserved word new tells Java to make new object instance, it “calls” constructor • name of constructor follows new; since constructors have same name as their classes, this defines the class to instantiate • e.g., new BouncingBall is created (class in bounce package which is a subpackage of demos) • When new object is made Java executes statements defined in constructor • Result of calling constructor is new instance of that class • example of a message that returns a value • We don’t keep track of BouncingBall because we don’t need to call any of its methods • in most cases we need to call methods of new objects so that we must keep track of them • later we will show how

24. What about the rest? public static void main(String[] arguments) { new BallApplication(); } • To run the program, something must create an instance of class BallApplication • the Java Virtual Machine (JavaVM) starts the program by calling the special method main • Our main() method then creates an instance of class BallApplication • You can think of main() as prologue to application’s constructor • special method that can be called without referring to an object • it just gets called and then constructs your application • Every program MUST have one… it’s your starting point! • it’s a lot of magic! (for now) • BallApplication object is the first thing created when the program is run • for now we use wheels.users.Frame, later use something that does less work

25. More about Frames • Frames magically do a lot of work for you • handle input stream of events, i.e., mouse clicks and keyboard presses • send messages to appropriate GUI component to handle event Input from user Appropriate GUI component (button, menu, etc.) wheels.users.Frame

26. Syntax: Extending Frame Class • To create your special frame, you don’t need to start from scratch (which would be a huge amount of work) - instead you can extend, i.e., add to, a default frame defined already • you can take advantage of the work default frames do for you • Syntax for declaring extension is simple: public class BallApplication extends wheels.users.Frame • Three types of packages help you write your programs: • demos: Demos Package — library to illustrate examples in lectures • wheels: graphics library used by examples in the book • Sun provides many more packages with JAVA • GUI (graphical user interfaces) • databases • networking and communication • 2D graphics • sound • etc., etc.

27. public static void main(String[] arguments) new BallApplication(); new Demos.Bounce.BoucingBall(); Steps of Execution • Java programs are executed by the Java VM • your computer is the real machine (Mac, PC) • Java defines its common one on top of all real machines • Java VM is the same for all types of computers • you can compile Java classes on one computer and execute it on another • What’s going on inside Java VM when we start with main()? What about static, void, String[] and arguments? • we’ll talk about them later • for now, just accept that it’s needed to start your program inside main() inside BallApplication()

28. Final Code for BallApplication • Now that we have deconstructed it, let’s look at this code one more time: public class BallApplication extends wheels.users.Frame { public BallApplication() { new demos.bounce.BouncingBall(); } public static void main(String[] arguments) { new BallApplication() } }

29. BallApplication(cont.) • Execution Steps • user starts program • in Eclipse, by right-clicking BallApplicationand selecting “Run” command from popup menu • this executes BallApplication (on a PC) • method main() is called by JavaVM • BallApplication is instantiated by the new command • constructor BallApplication() is called • BouncingBallis instantiated by the new command • constructor BouncingBall() is called, it starts bouncing • BallApplication’s constructor is now finished, BallApplicationand anything constructed in it keep running, e.g., BouncingBall keeps bouncing • user quits the application by clicking the “Quit” button • BallApplicationis destroyed and BouncingBall with it

30. Conclusion • Interface for bouncing ball is extremely simple — instantiate it and watch it go • pro: it is easy (it does all the work!) • con: it is not possible to change anything about the ball • class interfaces can be this simple or much, much more complex