1 / 24

Working With Objects

Learn the fundamentals of object-oriented programming and how to work with objects in Java, including encapsulation, instantiation, and object variables. Explore the advantages of object-oriented programming and understand the difference between classes and objects.

carltong
Download Presentation

Working With Objects

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. Working With Objects Tonga Institute of Higher Education

  2. Introduction • The building block of an object-oriented language is an object. • Object - A self-contained entity that contains data and procedures to manipulate the data. • An object is like a tool that we can use to do things. • In Java, almost everything is an object. • String • Integer • System • PrintStream • Etc. • Java has over 2,700 pre-built objects for us to use. • You can find a list of pre-built objects in the Java Developer’s Kit documentation.

  3. Advantages of Object Oriented Programming • Code is easier to maintain • Code is more readable • Encapsulation • Show what the object can do • This is normally what we want to know • Hide how the object does it • This can be very complicated • We often don’t care how it is done • Code is easier to re-use • A piece of code, once written, should not be thrown away. It is best to re-use the code in other programs. • Example: Millions of people use System.out.println(). But it was only written once. • Code development is more efficient • You don’t code the same thing over and over again

  4. Advantage of Encapsulation • Show what the object can do. • This is accomplished by exposing the signature. • Signature – The combination of method name and parameters used to uniquely identify a method. • Hide the code that the object uses. • The person using the object doesn’t know how it works. • Therefore, we can change the code in a method and don’t need to update the programs using it if we don’t change the signature. • If others are using your signature, do not change it! • If you do, you will cause everybody using your object to crash. class Math { public double getPI() { return 3.14; } } class Math { public double getPI() { return 3.1415926; } }

  5. Objects • Objects are like primitive data types with extra functionality. • Generally, use them like primitive data types. Except: • Capitalize the first letter of an object data type • Ex: byte vs. String • They have methods that provide extra functionality • Look at Java documentation to find functionality. • Examples: • String • String.charAt(int index) • String.compareTo(String anotherString) • Date • Date.getHours() • Character • Character.compareTo(Character anotherCharacter) • They have constructors that let you create them. • Primitive data types can have object wrappers. • Ex: The object wrapper for the int primitive data type is Integer.

  6. Classes vs. Objects • Object - A self-contained entity that contains data and procedures to manipulate the data. • Class - The blue print or design for creating an object. • Instantiate – The act of creating an object from a class • Instance – An instantiated class/object

  7. Using Object Variables • 2 Steps to using variables • Declare the variable • Instantiate the variable / Initialize the variable

  8. Declaring Object Variables – 1 • Declare the variable – Tell the computer to reserve a space in memory for the variable. • You need to tell the computer 2 things: • Name of the variable • Type of the variable (What kind of variable you have) • Object types • Integer • String • This works exactly the same for primitive variables! Type Name

  9. Declaring Object Variables – 2 • Use a name that is easy to remember. • Do not use x, y, z • Variable names must start with a letter, underscore or dollar sign. • Variables should begin with a lowercase character. Then a capital letter for each next word. • Examples • firstName • customerID • This works exactly the same for primitive variables!

  10. Instantiating Object Variables / Initializing Object Variables • Instantiate – The act of creating an object from a class • Use the new keyword • Initialize the variable – Assign an initial value to a variable. • A newly instantiated object can be used to initialize a variable • Char values must be enclosed in single quotes. • String values must be enclosed in double quotes. Parameters may not be required New Keyword Type of Object

  11. Declaring and Initializing Object Variables in 1 line • You can declare and initialize a variable in 1 line.

  12. Strings are Special • They are objects, but you can use them like primitives Is the same as

  13. Demonstration Declaring, Instantiating and Initializing Variables

  14. Constructors • Constructor – A method that is automatically executed when an object is created. • This allows you to set initial values for the object. • Many objects have multiple constructors. (They are overloaded) • You can find a list of constructors in the Java Developer’s Kit documentation.

  15. Demonstration Constructors

  16. Attributes / Fields • Attributes / Fields – A variable that a class allows others to see • Use dot notation to access it • Example: <Object name>.<field name> • Example: JOptionPane.INFORMATION_MESSAGE • You can find a list of fields in the Java Developer’s Kit documentation.

  17. Demonstration Attributes / Fields

  18. Methods • Methods - Pieces of code that perform a single function • Use dot notation to access it • Example: <Object name>.<method name>(<parameters>) • You can find a list of methods in the Java Developer’s Kit documentation. • Calling a Method – The act of using a method • We’ve already used a lot of methods: • println(…) • main(…) • intValue(…)

  19. Method Input Output Method Inputs • Some methods take inputs • Parameter/Arguments – A piece of information that provides additional information to the method as to how it should behave. • Parameters should be in the parenthesis next to the method name • The order they are passed is important • Values are separated by commas • Even if you aren’t passing any parameters, you still need to use () • Example: Integer.intValue() Method Name Input Information

  20. Method Input Output Method Outputs • Some methods return outputs • When something is returned, it may or may not be used. • The programmer chooses what to do with the data returned. • Only one thing may be returned. • Void means nothing is coming back • Function – A method that returns a value Output Information

  21. Demonstration Methods

  22. Method Overloading • If two methods do the same thing, they should have the same name • Overloading - Having multiple methods with the same name but different parameters • Java determines the correct method to use by matching up the number and type of arguments. • Therefore, you can’t have 2 methods with the same name and same number & type of arguments. • Without overloading, we would have to remember more function names. That would make code more complicated.

  23. Demonstration Method Overloading

  24. Members • Member – An attribute/field or method. • Sometimes used to refer to attributes/fields and methods as a whole.

More Related