Start learning with our library of video tutorials taught by experts. Get started
Viewers: in countries Watching now:
Join author David Gassner as he explores Java SE (Standard Edition), the language used to build mobile apps for Android devices, enterprise server applications, and more. This course demonstrates how to install both Java and the Eclipse IDE and dives into the particulars of programming. The course also explains the fundamentals of Java, from creating simple variables, assigning values, and declaring methods to working with strings, arrays, and subclasses; reading and writing to text files; and implementing object oriented programming concepts.
When you're working with object- oriented development patterns a lot of developers feel that fields should always be private and their data should only be accessed through what we call getter and setter methods. In some languages there is a port for implicit setters and getters. For example, in both C# and in ActionScript 3, you can use the words set and get before method names as separate words and then you can refer to those methods as properties. In the Java language, in the absence of some other framework, you can only use explicit setters and getters, that is methods that start with the word get as part of the method name, but these are so common that there is support for generating these kinds of methods in the development environment such as Eclipse.
I'm working in the class Olive which is a member of the project getters and setters. This is class has 4 fields, 2 strings, one long in one end, and 3 of the fields are public and one private. To generate getter and setter methods, place the cursor anywhere in the class. You don't have to select the code as I've shown here, and then you can right click and choose Source or you can go to the main Menu and choose Source. From there choose Generate Getters and Setters.
In this dialog box choose the field for which you want to Generate Getter and Setter methods. For this first example, I'll only choose the oilfield. Next, determined the insertion point, where do you want to put the new code. If you choose first member, the code will go right after the class declaration, and last member will put it at the end. I typically like to put my getters and setters after the field declarations. So I'll choose after oil; that's the last field declaration and before the methods.
Next, indicate how you want to Sort. Do you want to put the Fields in alphabetical order or do you want to do all the getters first and then all the setters. I'm generating only getter and setter for one field initially, so it doesn't matter which I choose, but typically, I like the first option, Fields in getter/setter pairs. Next, set the Access modifier, are your getters and setters going to be public, protected, default, or private? I'm going to set them as public, so that they can be called from anywhere in the application. I'll click OK, and that generates two methods named getOil and setOil.
Here is the syntax of an explicit getter method, it always has a return data type, which matches the original fields' data type, the name of the method matches the name of the field with a prefix of get, and the name of the field is changed to have an uppercase initial character. So oil, all lowercase, becomes oil with an uppercase O, and then within the getter method, there is a return statement that returns the value of the field. A setter method always has a void return type, and it has a prefix of set before the field name, it receives a value that matches the data type of the field, and then it sets the field using this, to distinguish the field from the argument.
Once you've created these methods, you can we refactor the rest of the application to always set the fields through the methods. So for example in my public constructor down here the one who receives an int value, instead of saying this.oil=oil, I'll call the method setOil and pass in oil, the argument. Following this pattern results in centralizing the processing of the argument, later on if you want to validate, modify, or otherwise secure the data; it makes it very easy to do.
Now let's do something similar in the olivepress class. Currently this getOil method in this class loops through an array list of olive objects, crushes each of them, then calculates the amount of olive oil, but it doesn't actually return the olive oil to the application. You could change this method so that it have a return type say of int, and then add a return statement, or another approach, would be to create a field of the class, so that once the getOil method was done, it would set the amount of oil as a member of the class and then the rest of the application could access that oil.
So I'm going to place the cursor right after the class declaration and before the constructor method. I'll declare a private integer variable and I'll name it totalOil and I'll initialize it to a value of 0. When the class is instantiated, this private field will have a value of 0, but then I can add values to it each time the getOil method is called. Next, I'll add a getter and a setter for this field. I'll right click and choose Source>Generate getters and setters.
I'll check the only field, I'll place the insertion point after totalOil, and I'll set the access modifier to public and click okay. So there's my getter and setter. The rule that I want to follow is the only code within the class is allowed to set the totalOil, but code anywhere in the application can access it. So I am going to change the access modifier for setTotalOil to private. So now from the point of view of the rest of the application, it's a read-only value.
Within the getOil method I'll move the cursor down here, and I'll call the method setTotalOil and pass in the value that was calculated. I'll take this line of code that's outputting the total amount of oil and I'm going to place it in the main application. I'll go to main.java and place the cursor after the call to the OlivePresses get oil method, I'll paste in that line of code and now instead of outputting the value of an oil variable, which is no longer in the scope of this class, I'll get that value from press.getTotalOil, because it's a public accessor method, a public getter method, I can call it from anywhere in the application.
It's up to the olivepress to set the oil, but my main application code can get to it. I'll run the application as a Java application and there is the result. Everything still works exactly the same as before. Finally, let's say that in this application I wanted to reuse the press object, so that I could add olives at one point in the application and then at another point. As long as I create a single instance of the olivepress class and keep it in memory for the duration of the application session, I should be able to do that, but right now my setTotalOil method is rewriting the value of total oil every time it's called.
Let's say that instead, I wanted to incrementally add to it. I could go to the setTotalOil method and change the operator from equals to plus equals, and now I'm adding to the total. I'll Save my changes. I'll go back to main.java and I'm going to copy these lines of code starting with press.getOil. I'll paste those at the end and so now I am going to crush those olives once, and then I am going to crush them again, because I'm now incrementally adding a value, I should be multiplying the amount of olive oil each time I go through the loop.
I'll Save and Run, and the first time through I got the 5 units and after the second time through I have 10, and so on. This illustrates the value of getters and setters, when you wrap the access of the data in a setter; it lets you change the rules very, very easily. So before every time the method was called, I was just assigning the value, but then with one little change, now I'm incrementally adding to the value, and you can design and code any other sort of business rule you like once you have the getters and setters in place.
So this is a major part of what we talked about when we were discussing encapsulation. Hiding data refers to the practice of setting fields as private and then only allowing access to those fields through getter and setter methods. Again in Java, in the pure programming language, you don't have implicit setters and getters, like you do in some other languages, but there is a very strong convention for how you design setters and getters and then call them from within your application.
There are currently no FAQs about Java Essential Training.
Access exercise files from a button right under the course name.
Search within course videos and transcripts, and jump right to the results.
Remove icons showing you already watched videos if you want to start over.
Make the video wide, narrow, full-screen, or pop the player out of the page into its own window.
Click on text in the transcript to jump to that spot in the video. As the video plays, the relevant spot in the transcript will be highlighted.