Man With Code 👨‍💻

Part 1: Part 2: Covered In This Episode

• Variable Scope
• Class creation
• Open Classes
• Class Inheritance
• Modules

Transcript: Hello Everybody and welcome to Programming With Ruby Episode 10, Objects and Modules. As always, I'm Tyler and this video is brought to you by manwithcode.com Variable scope will be explained. In this episode I will be going over class creation, I touched on this before but that was a while ago and I will also be going more in-depth I will be teaching you what class inheritance is. You will also find out what open classes are, and why they are useful. You will learn what modules are, and how and when you should use them Lets get started! Variable Scope I taught you about variables earlier, but I need to go a little more in-depth for you to be able to write real applications, and not be confused by some mysterious errors. What is a variable scope? a variable scope is where the variable is available for use in the program. The code in classes and methods that you define have a different scope than the code outside them. Different scopes are introduced when classes and methods are defined. There are 5 different types of variables: 1. local variable ex: variable 2. instance variable ex: @variable 3. class variable ex: @@variable 4. global variable ex: $variable 5. constant variables ex: VARIABLE A local variable is available in the scope in which it is defined. An instance variable is available in the instance of the class it was defined. A class variable is available from any instances of that class. A global variable is available anywhere. A constant is available anywhere, but can only be changed within the scope it was defined. Class Creation As mentioned in episode 4 you define classes like this, don't forget that classes must start with an upper case letter: [ruby] class MyClass end [/ruby] and create them like this: [ruby] variable = MyClass.new [/ruby] You can define methods inside the class: [ruby] class MyClass def hello puts 'Hello!' end end [/ruby] If you define a method named 'initialize', that method is run when the class is instantiated. This is very useful in many situations, like creating a screen in a game or connecting to the database in a web application. This is also the usual place for defining instance variables [ruby] class MyClass def initialize @database = connect_to_database end end [/ruby] A method defined with 'self.' in front of it's name is called a class method, because the method is available outside of the class, and you don't have to instantiate an object. These can be useful for times when you don't want create objects, or want certain information about all the instances of a class. [ruby] class MyClass def self.game_objects # Return all objects in the game end end [/ruby] Open Classes So now that you know more about creating classes, I would like to call your attention to a very useful feature of Ruby, Open Classes. The term Open classes means you have the ability to add or substitute code in a class that is already defined. This is quite easy to do too, all you have to do is define a class in the same way you always do, just with a pre-existing class. You only have to define what you are adding, or overwriting, you don't have to define the WHOLE class again. Take for example, the String class. This class (obviously) is the class from which all strings are created. Lets say, for example that you had some code that took a string, and gave back an array that had each word in it. You could do this: [ruby] def words(string) string.scan(/\w[\w\'\-]*/) end words("Hello World") #=> ["Hello", "World"] [/ruby] But it looks a lot nicer, and is more object-oriented if you do this instead: [ruby] class String def words scan(/\w[\w\'\-]*/) end end "Hello World".words #=> ["Hello", "World"] [/ruby] You can probably see why this can be useful. Be careful though, if you override existing functionality, you run the risk of breaking that functionality in your code, and all the external code your project uses. Class Inheritance Lets say you are making a video game. In that game you will have many different types of enemies. Now, odds are that all your enemies will have stuff in common. They probably will all have health, ammo, etc. They all will have to draw themselves on the screen, animate when they move, etc. So you can see that with many different types of enemies, you would have to have lots of duplicate code in each class. This is solved via class inheritance. Class inheritance allows you to write one class that contains all the common code. Then when you create other classes you can specify that those classes will use (inherit) that common code. You specify if a class is inheriting from another by following the class name, with a less than sign followed by the name of the class you are inheriting from. You can also re-implement some of that common code, if needed. For example: [ruby] class Enemy def draw # Drawing Code end end class Soldier < Enemy def move end def shoot end end class DifferentEnemy < Enemy def draw # Changes the draw functionality, only for this class end end [/ruby] Another thing to keep in mind, if you redefine the initialize method in your inherited class, you must call the super method. Modules Modules are like classes, except they can't be initialized, and every method has to be prefixed with "self." like class methods. This limitation in functionality may make you wonder when modules are ever useful. There are actually only a few times. First is to keep parts of your code separated. The more important second reason is when you are creating a library of code for others to use. This is so the functionality in the library isn't stepping over or redefining classes you have already defined (if they happen to have the same name). You define modules just like you do classes, except using the module keyword: [ruby] module DataVisualizer class Grapher end class Plotter end def self.data_compatible? end end [/ruby] To access methods that modules define you simply do: [ruby] module MyModule def self.x end end MyModule.x [/ruby] To access classes defined by modules, you have to use double colons: [ruby] module DataVisualizer class Grapher end class Plotter end end DataVisualizer::Grapher.new [/ruby] That's all there is to know about modules, meaning this is the end of the episode! Please donate, those these videos are free, it costs money to make them. If you have any questions comments or suggestions about anything related to Man With Code or the Ruby tutorials, you can leave a comment on this page or email me at [email protected] Than you very much for watching, goodbye!