Overview CSE 142. Naming Revisited Declarations. Defining Parts of Objects

Transcription

1 ÿþýûú Overview CSE 142 Anatomy of an object: constructors, methods, and instance variables Quick Review Creating, naming, and using objects Creating (empty) classes and instances of them Today Details of declaring and initializing names (identifiers) Defining and initializing an object's parts Methods to manipulate objects Access control to an objects state (instance variables) Reading Dugan notes: ch. 6, first part of ch. 8 û Naming Revisited Declarations We ve used the following pattern to give names to values <type> <name> = <expression> ; This is called a declaration. Purpose: Introduce a new name (or identifier) Specify the type of values it can name Specify the (initial) value that the name is bound to (optional) A name can be declared without an initial value A name declared like this must eventually be initialized (bound to a value) before it can be used Defining Parts of Objects "Instance variable" declarations specify the parts (or "fields") that all objects (instances) of a class have Instance variables store the state of an object Let s modify Dog so that all instances have a name, weight and a picture: private double weight; // in kgs. private String picture; // name of the file that contains the picture. Pattern for an instance variable declaration <type> <name of instance variable/part> ; All instances of Dog have their own instance variables of name, weight, and picture ÿþýûú û

2 ÿþýûú Accessing instance variables and methods The dot (.) operator provides access to instance variables and methods We ve all ready seen the usage of the dot operator when invoking a method: e.g. fido.bark(); To access instance variables, you can also use the dot operator: e.g. fido.name = Scooby Doo ; However, the declaration specifies that name is private, which prevents outside access to such instance variables (and methods as well) L more on this later Access to instance variables by methods A method of a class always has access to instance variables of the class Hence, when a method of an object is invoked, the method can access the instance variables of the object For example, the bark() method on Dog could access a Dog object s instance variables. So we could modify bark() in the following way: public void bark() { System.out.println( Woof, woof, woof ); weight = weight -.1 // You lose weight when you bark! J Constructors When an object of a class is instantiated (through the new operator), a constructor for the class is invoked to create the object Minimally, the constructor allocates memory for the new object (so that there is a place to store the object s instance variables) Question: How should the instance variables be initialized? Answer: A programmer can write a constructor for the class Constructors, like methods for a class, always have access to the class instance variables The Dog Constructor We can define a constructor in the Dog class private double weight; private String picture; public Dog( ) { name = Scooby Doo ; weight = 21.4; picture = ScoobyDooPicture.gif ÿþýûú

3 ÿþýûú Constructors Pattern public class <ClassName> { public <ClassName> ( ) { <statements to execute to initialize new object> If one is provided, a constructor is guaranteed to be called when objects are created gives programmer a chance to guarantee that object fields are initialized properly when object is created. Using Objects with Constructors Now can create nicely initialized Dog objects! Dog fido = new Dog( ); þ Methods Method invocation on an object can: Change the state of the object (change instance variable(s)) Cause an action ( side effect ) Return information Method pattern, if methods has one argument and returns a result: public <return type> <message name> (<argument type1> <argument 1>) Return type is void if there is no return value Multiple arguments are separated by a comma (,) each argument must have a type specifier Adding methods to the Dog class Changing state: Declare setname method public void setname(string newname) { name = newname; Returning information, Declare getname method public String getname() { return(name); Causing an action: bark method ÿ û ÿþýûú

4 ÿþýûú Return Statement To return a computed value back to a caller, use a return statement. Pattern: return <expression> ; All methods with non-void result types should end in a return statement! No other methods should! The type of the <expression> returned must match <return type> specified in the method declaration private double weight; private String picture; public Dog () { name = Scooby Doo ; weight = 21.4; picture = ScoobyDooPicture.gif ; public void setname(string newname) { name = newname; public String getname() { return(name); public void bark() { System.out.println( Woof, woof, woof ); Dog Class this Within a method or constructor, a variable called this is implicitly declared and available this is a special name for the object associated with the method In accessing an instance variables for a Dog within a method (or constructor), you could write: this.weight = 20.4; instead of weight = 20.4; this (continued) So, the constructor for Dog could be defined as: public Dog () { this.name = Scooby Doo ; this.weight = 21.4; this.picture = ScoobyDooPicture.gif ; Why would you ever use this? We ll talk about this later ÿþýûú ú

5 ÿþýûú Private vs. Public Defines accessibility rights Because name and picture are declared private: fido.name = Snoopy ; // error!! String s = fido.picture; // error!! Only methods within the Dog class can access private instance variables (or private methods for that matter Such statements would be permissible if name and picture were declared public e.g. public String name; public String picture; Public declarations of instance variables are highly discouraged! Public vs. private (continued) Public vs private: all members of a class (instance variables and methods) can be labeled public or private public: can be directly accessed anywhere the class or its instances can be used private: can only be accessed by code inside the class itself Design rules Constructors and methods that are part of the class interface (or specification) should be public Everything else should be private Leads to better modularity; limits possibilities for bugs In other words Implementation details of an object should not be accessible outside the class (why?) To protect an object's fields (parts) from outside access, we can declare that they are private private double weight private String picture; This makes outside accesses illegal Good practice: always protect instance variables in the future We ll see other mechanisms that completely hide instance variables from outside access, given even further protection Constructors can take arguments More than one constructor permissible Constructors with arguments allow for parameterized initialization Adding a new constructor to Dog: public Dog(String initname, double initweight, String initpicture) { name = initname; weight = initweight picture = initpicture; This is clearly a good idea! ûþ ÿþýûú

6 ÿþýûú Constructor advice A well-designed class almost always contains one or more constructors Executed automatically when a new instance of the class is created Allows programmer of the class to guarantee that new instances are properly initialized (Other code in the class can rely on this having been done) A class may have many constructors Must differ in number or types of parameters (or both) Compiler picks correct constructor depending on number and type of arguments when object is created (new) Something to think about Instance variables can be initialized by writing a constructor for the class However, instance variables can also be initialized (rather set ) with an explicit method that does initialization When might it be advantageous to do so? ûÿ ûû Pictorial representation of objects in action nam e land s fido radius objectland String Dog nam e weight picture 10 The situation in pictures after: intradius = 10; Dog fido = new D og( ScoobyD oo,22.4, ScoobyD oopicture ); String s = fido.getname(); Names alw ays refer to objects. Scooby D oo 22.4 String ScoobyD oopicture Triangle û ÿþýûú