1 / 20

Computer Science 111 Fundamentals of Computer Programming I

Computer Science 111 Fundamentals of Computer Programming I. Working with our own classes. So much for learning programming?. Review of object concepts. So far we have defined a class for each program. In main we get an instance of the class and work with that single object.

frey
Download Presentation

Computer Science 111 Fundamentals of Computer Programming I

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. Computer Science 111Fundamentals of Computer Programming I Working with our own classes

  2. So much for learning programming?

  3. Review of object concepts • So far we have defined a class for each program. In main we get an instance of the class and work with that single object. • We have also made use of classes • From Java • From TerminalIO • From BreezySwing • In the spirit of decomposition and reusability, we now focus on defining our own classes and using multiple objects in a program.

  4. Review of object concepts • When we define a class, we are making a template for the objects from the class – what kind of data and behavior will the objects have. The data is stored in instance variables and the behavior is given by the instance methods • An object is an instance of a class. It has • State – the current values of its instance variables • Behavior – defined by its methods

  5. Review of object concepts • When we declare a variable with type specified by a class (as opposed to a primary type like int), the variable is actually a reference to an object of the given type. There is no memory allocated for the object until the object is instantiated. • We can have the variable reference an actual object by • getting a new object or • have it reference an existing object

  6. Object Concepts MyClass myObj; myObj myObj = new MyClass(); myObj

  7. MyClass myObj1 = new MyClass(); myObj1 MyClass myObj2 = new MyClass(); myObj2 myObj1 = myObj2; Object Concepts Note that there is no reference to the memory allocated for the first object. This will be reclaimed by Java’s garbage collector.

  8. Mutators and Accessors • These are two general categories of methods that we provide. • Mutators are methods that change the object’s state; i.e., cause changes to the instance variables. An example would be the setNumber() methods to change state of GUI fields. Another example would be the updateModelFromRoll() method. • Accessors are methods that return information about the state. An example would be the getNumber() methods. • We provide public mutators and accessors only for the variables for which we want to allow change and access capabilities.

  9. Class template public class <class name> extends <some class>{ // Declaration of instance variables private <type> <name>; … // Code for constructor methods public <class name>( ) { // Initialize instance variables … } // Code for the other methods public <return type><method name>(<params>){ … } … }

  10. Class template by pieces public class <class name> extends <some class>{ // // Classes usually made public so usable by all clients // The class can act as server providing service to clients // // The class name is legal Java identifier. Convention is to // begin with upper case letter. // // The classes in Java form a hierarchy in a tree structure with // the class Object at the very top. Each class we write is a // subclass of some other class. If we do not specify // otherwise, it is made a direct subclass of Object. // // We specify the class we are subclassing by saying our class // extends the other class. The class we extend is called // the parent of our class, and our class is its child. The // child inherits the characteristics of the parent.

  11. Class template by pieces // Declaration of instance variables private <type> <name>; … // We almost always make the instance variables private. // This keeps the users of our objects from directly // accessing these variables. We provide mutators // and accessors to do exactly what we allow and // nothing more. In fact, the instance variables and // their types need not be known. This allows for // implementation changes that do not effect client code. // This is referred to as information hiding.

  12. Class template by pieces // Declaration of instance variables private <type> <name>; … // As an example, suppose we are writing a class for // some kind of temperature class. We might provide // methods for giving the temperature in Fahrenheit or // in Celsius, etc. There would be no need to store // the value in both systems. If we provided access to // an instance variable called fahrenheit, then all code // using this access would be dependent on our keeping // that implementation of our class. If, instead, we // provided access methods called getFahrenheit and // and getCelsius, we could change the implementation // without problems with the client code.

  13. Class template by pieces // Code for constructor methods public <class name>( ) { // Initialize instance variables … } // Note that a constructor has the same name as the class. // Note also that a constructor does not have a return type. // A constructor is always made public. If not specified, this // is the default. // A constructor is executed when a new object is instantiated. // You can have constructors with parameters. // You can have more than one constructor – overloaded

  14. Class template by pieces // Code for the other methods public <return type><method name>(<params>){ … } // Most of our methods will probably be public so they can be // used by various clients. // However, we still should make methods private if they // are “helper” methods for internal use by the objects of // the class we are defining.

  15. Class template by pieces public class Temperature extends Object { private double fahrenheit; … public Temperature( ){ fahrenheit = 0.0; } public Temperature(double aTemp){ fahrenheit = aTemp; } … } … Temperature temperature1 = new Temperature( ); Temperature temperature2 = new Temperature(100.0);

  16. toString methods • We usually provide a method named toString that returns some string representation of the object. • This method has no parameters. • It can be called explicitly like other methods. writer.println(MyObj.toString()); • However it is also called explicitly when we use string concatenation or use println with the object name itself. • str = str + “Today” + myObj.toString();is equivalent to:str = str + “Today” + myObj;

  17. Example – Course Class

  18. Example – Course Class (cont.)

  19. Example – Course Class (cont.)

  20. I want to be like Mike...

More Related