Viewers: in countries Watching now:
Most modern programming languages, such as Java, C#, Ruby, and Python, are object-oriented languages, which help group individual bits of code into a complex and coherent application. However, object-orientation itself is not a language; it's simply a set of ideas and concepts.
Let Simon Allardice introduce you to the terms—words like abstraction, inheritance, polymorphism, subclass—and guide you through defining your requirements and identifying use cases for your program. The course also covers creating conceptual models of your program with design patterns, class and sequence diagrams, and unified modeling language (UML) tools, and then shows how to convert the diagrams into code.
Up 'til now we've been focused on the instance members of our classes where every object we instantiate will have its own unique copy of all the attributes and all the behaviors we've defined. But we can also create what are called static or shared members, meaning a variable or a method that is shared across all objects in that class. Here's an example. So I have a straightforward SavingsAccount class with an accountNumber attribute, and a balance attribute, deposit and withdraw methods.
And we can instantiate multiple objects based on this class that all have their own copies of all the attributes and behaviors, the variables and methods. But then we realize they all need an interest rate, and that's a pretty straightforward piece of information, and it belongs here. Should savings account have an interested rate? Sure, it should. So we could define that as a regular attribute, an instance variable, and now every instance, every object has its own copy of interest rate. But our business rules say that interest rate is one rate across all savings account, it does not vary from account to account.
It might change ten times a day, but when it changes, it changes for everyone. So there's no need to have potentially thousands of copies of this variable and worry about keeping them all perfectly synchronized. That could be done, but it's not efficient, and it's unnecessary. Now, if you come from a procedural programming background, your gut instinct might be to fix this by pulling out this variable and putting it in some global area by itself. But that's a bad idea when object- oriented programming, and you should be avoiding any generic global dumping ground for data.
And more to the point, the interestRate should be defined in the SavingsAccounts class, the savings account has an interest rate. It belongs here. So we define this as a static or shared variable. This is also referred to as a class-level variable as opposed to an instance-level variable, and all these terms mean the same thing, one copy shared across all objects, static, shared, or class-level. As just a basic example of how this is expressed in code if I'm in a language like C# or Java, instead of creating the variable the normal way with just the type and the name, we just use the word static in there.
If I'm using a language like VB. NET, they use the term Shared. Ruby prefers to call them class level variables, and they use the two At signs to denote those. But they're all referring to the same concept. Now, when I use the term static here, it does not mean constant or fixed. This variable can still change, but there's only one copy across all objects. And if it seems like static is the wrong word for this, know that it doesn't mean static as an unchanging, it means static as opposed to dynamic, because if I use the word static, we now know that there's always one of these variables and only one of these variables, whereas anytime we run the application, there could be one or 10,000 or none of the instance-level variables because that can change depending on how many objects the program creates that time around.
When we access normal instance-level variables, we use the name of the object to get to them. So, if I wanted to access one of the pieces of each of these instances, I would make sure to use the name of the actual object. But if I want to access a static or shared variable, I access it using the class name itself, not any particular instance name. And that's the only way to get to these variables. Now, because it's accessed using the class name, it doesn't matter if you have one object, 10,000 objects, or even no objects at all.
Even if you haven't instantiated any objects from this class yet, you can still use any variables defined as static. So we could set the interest rate for this class before creating any objects of this class. We can also create static methods, methods that exist at the class level, not at any instance level. Again, we've seen how to create a static variable, we'd use the word Static or Shared or the two At signs or however else your language might implement this. And the same way, I would create a normal method, but I use the word Static to actually say that there's only one of these, and it's always accessible using the class name, not the name of any instance of this class.
Now, static methods can only access static variables, static data. I can't write code in a static method to access instance-level variables. But an example here might be that I create static methods to get and set the interest rate, and then I could make the actual currently public static variable interestRate private, the way it should be. Being static does not affect our choices with visibility. And now we could use the name of the class, and then the name of a class-level method, a static method to set the interest rate and control exactly how that happens.
Now, in UML static members of a class are typically shown with an underline, so static attributes, static behaviors. That's how you recognize that these exist at the class level, not the instance level. Now, most classes you define will be composed of mainly instance-level members, but class-level, static or shared members, whatever term you prefer to use, they are a useful and a classic concept in object-oriented design and programming.
There are currently no FAQs about Foundations of Programming: Object-Oriented Design.
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.