1 / 53

OOP / VB .NET (Chp4)

OOP / VB .NET (Chp4). DR. JOHN ABRAHAM UTPA Credit: Partial slides from startvbdotnet.com. INTRODUCTION. The book uses car analogy We humans are very good in recognizing and working with objects , such as a pen, a dog, or a human being.

chana
Download Presentation

OOP / VB .NET (Chp4)

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. OOP / VB .NET (Chp4) DR. JOHN ABRAHAM UTPA Credit: Partial slides from startvbdotnet.com

  2. INTRODUCTION • The book uses car analogy • We humans are very good in recognizing and working with objects, such as a pen, a dog, or a human being. • We learned to categorize them in such a way that make sense to us. We may categorize them as animate object, inanimate objects, pets, friends, etc.

  3. INTRODUCTION (2) • We some times classify objects based on their attributes, for example, green apples or red apples, fat or slim people, etc. • If you think about it each object has many attributes. If I ask you list the attributes of an orange, you probably could list many things such as color, shape, weight, smell, etc.

  4. INTRODUCTION(3) • In addition to attributes, all objects exhibit behaviors. • A dog eats, barks, wags its tail, plays, and begs. A dog exhibits many more other behaviors than this short list. • Another thing we need to remember about objects is that objects interact between each other.

  5. OBJECTS • objects are packages that contain data and functions (methods) that can be performed on the data.

  6. OBJECTS (2) • Data could be considered to be attributes and functions are considered to be behaviors of the object. • We can say that the attributes and behaviors are encapsulated into an object.

  7. OBJECTS(3) • The objects interact between each other through their interfaces. • As an example a date object may have a set of data consisting of month, day and year, and methods consisting of assign date, display date, yesterday and tomorrow.

  8. CLASSES AND OBJECTS in VB • Classes are types and Objects are instances of the Class. • Without objects you can't use a class. (Your book says you can’t drive the drawing of a car) • In Visual Basic we create a class with the Class statement and end it with End Class.

  9. Using objects • Pressing the gas pedal sends a message to the car to perform a task. • Similarly in programming you use a method call to send a message to the object.

  10. The Syntax for a Class • Public Class Test----- Variables-----Methods-----Properties-----EventsEnd Class

  11. CREATING AN OBJECT • To create a object for this class (TEST) we use the new keyword and that looks like this: • Dim obj as new Test().

  12. Imports System.Console Module Module1 Sub Main() Dim obj As New Test obj.disp() Read() End Sub End Module Public Class Test Sub disp() 'a method named disp in the class Write("Welcome to OOP") End Sub End Class Sample program

  13. Members of a class • Fields, Properties, Methods and Events • They can be declared as Public, Private, Protected, Friend or Protected Friend. • Fields and Properties represent information that an object contains. • Fields of a class are like variables and they can be read or set directly. • For example, if you have an object named House, you can store the numbers of rooms in it in a field named Rooms.

  14. It looks like this: Public Class House Public Rooms as IntegerEnd Class

  15. Instance variables (Attributes) Examples: Amount of Gas in your car Balance in your bank account

  16. Properties (Attributes) Properties are retrieved and set like fields. If they are public they can be changed by clients. Private properties are implemented using Property Get and Property Set procedures which provide more control on how values are set or returned.

  17. Properties(2) Get and set appear to be similar to declaring the properties public. Through get and set, programmer can have control over setting the properties. For instance if a client tries to set a date to 37, it can be checked are set to a default value instead.

  18. Textbook Example GradeBook • Public Class GradeBook • Private courseNameValue As String = "Not set yet" • Public Property CourseName() As String • Get • Return courseNameValue • End Get • Set(ByVal value As String) • courseNameValue = value • End Set • End Property • Public Sub displayMessage() • Console.WriteLine("Welcome to the grade book for " & vbNewLine & courseName & "!") • End Sub • End Class

  19. Textbook Example Module • Module GradeBookTest • Sub Main() • Dim theName As String • Dim gradebook As New GradeBook • Console.WriteLine("Initial course name is: " & gradebook.CourseName & vbNewLine) • Console.WriteLine("Please enter course name: ") • theName = Console.ReadLine() • gradebook.CourseName = theName • Console.WriteLine() • gradebook.displayMessage() • Console.ReadKey() • End Sub • End Module

  20. Methods (Behavior) Methods represent the object’s built-in procedures.  For example, a Class named Country may have methods named Area and Population.

  21. Defining Methods You define methods by adding procedures, Sub routines or functions to your class. For example, implementation of the Area and Population methods discussed above might look like next slide

  22. Methods defined Public Class CountryPublic Sub Area() Write("--------")End SubPublic Sub population() Write("---------")End SubEnd Class

  23. STOP HERE COVER THE REST IN NEXT LECTURE

  24. Events We have been programming for events already. Events allow objects to perform actions whenever a specific occurrence takes place. For example when we click a button a click event occurs and we can handle that event in an event handler.

  25. Constructors • A constructor is a special member function whose task is to initialize the objects of it's class. • A constructor is invoked whenever an object of it's associated class is created.

  26. Constructors (2) • If a class contains a constructor, then an object created by that class will be initialized automatically. • We pass data to the constructor by enclosing it in the parentheses following the class name when creating an object. • In Visual Basic we create constructors by adding a Sub procedure name New to a class.

  27. Imports System.Console Module Module2 Sub Main() Dim startObject As New Constructor(10) WriteLine(startObject.display()) 'storing a value in the constructor by passing a value(10) and calling it with the 'display method Read() End Sub End Module Public Class Constructor Public x As Integer Public Sub New(ByVal value As Integer) 'constructor x = value 'storing the value of x in constructor End Sub Public Function display() As Integer Return x 'returning the stored value End Function End Class

  28. Destructors • Destructors run when an object is destroyed. • Within a destructor we can place code to clean up the object after it is used. • We use Finalize method in Visual Basic for this and the Finalize method is called automatically when the .NET runtime determines that the object is no longer required.

  29. Constructors (2) • When working with destructors we need to use the overrides keyword with Finalize method as we will override the Finalize method built into the Object class. • We normally use Finalize method to deallocate resources and inform other objects that the current object is going to be destroyed. • The following code demonstrates the use of Finalize method.

  30. Imports System.Console Module Module3 Sub Main() Dim obj As New Destructor End Sub End Module Public Class Destructor Protected Overrides Sub Finalize() Write("destroyed!") Read() End Sub End Class

  31. Inheritance • A key feature of OOP is reusability. • It's always time saving • it can be used by other programs to suit the program's requirement. • This is done by creating a new class from an existing class. • The process of deriving a new class from an existing class is called Inheritance.

  32. Inheritance(2) • The old class is called the base class • the new class is called derived class. • The derived class inherits some or everything of the base class. • In Visual Basic we use the Inherits keyword to inherit one class from other.

  33. Inheritance coding Public Class One------End ClassPublic Class Two     Inherits One------End Class

  34. Inheritance coding (2) mports System.Console Module Module4 Sub Main() Dim ss As New Two WriteLine(ss.sum()) Read() End Sub End Module (see next slide for inheritance)

  35. Public Class One Public i As Integer = 10 Public j As Integer = 20 Public Function add() As Integer Return i + j End Function End Class Public Class Two Inherits One Public k As Integer = 100 Public Function sum() As Integer 'using the variables, function from base class and adding more functionality Return i + j + k End Function End Class

  36. Polymorphism It means  "one name, multiple forms". It is also called as Overloading which means the use of same thing for different purposes. Using Polymorphism we can create as many functions we want with one function name but with different argument list. The function performs different operations based on the argument list in the function call. The exact function to be invoked will be determined by checking the type and number of arguments in the function.

  37. Polymorphism analogy If you are asked to open you will know what to do depending on what the object you are working with: a door, a jar, an envelope, etc.

  38. Polymorphism Code Imports System.Console Module Module5 Sub Main() Dim two As New One1 WriteLine(two.add(10)) 'calls the function with one argument WriteLine(two.add(10, 20)) 'calls the function with two arguments WriteLine(two.add(10, 20, 30)) 'calls the function with three arguments Read() End Sub End Module

  39. Public Class One1 Public i, j, k As Integer Public Function add(ByVal i As Integer) As Integer 'function with one argument Return i End Function Public Function add(ByVal i As Integer, ByVal j As Integer) As Integer 'function with two arguments Return i + j End Function Public Function add(ByVal i As Integer, ByVal j As Integer, ByVal k As Integer) As Integer 'function with three arguments Return i + j + k End Function End Class

  40. Interfaces • allow us to create definitions for component interaction. • They also provide another way of implementing polymorphism. • Through interfaces, we specify methods that a component must implement without actually specifying how the method is implemented. • We just specify the methods in an interface and leave it to the class to implement those methods.

  41. Interfaces (2) • Visual Basic .NET does not support multiple inheritance directly but using interfaces we can achieve multiple inheritance. • We use the Interface keyword to create an interface and implements keyword to implement the interface. • Once you create an interface you need to implement all the methods specified in that interface.

  42. Imports System.ConsoleModule interfaces Sub Main() Dim OneObj As New One Dim TwoObj As New Two 'creating objects of class One and Two OneObj.disp() OneObj.multiply() TwoObj.disp() TwoObj.multiply() 'accessing the methods from classes as specified in the interface End SubEnd Module

  43. Public Interface Test 'creating an Interface named Test Sub disp() Function Multiply() As Double 'specifying two methods in an interfaceEnd Interface

  44. Public Class One Implements Test 'implementing interface in class One Public i As Double = 12 Public j As Double = 12.17 Sub disp() Implements Test.disp 'implementing the method specified in interface WriteLine("sum of i+j is" & i + j) Read() End Sub Public Function multiply() As Double Implements Test.Multiply 'implementing the method specified in interface WriteLine(i * j) Read() End FunctionEnd Class

  45. Public Class Two Implements Test 'implementing the interface in class Two Public a As Double = 20 Public b As Double = 32.17 Sub disp() Implements Test.disp WriteLine("Welcome to Interfaces") Read() End Sub Public Function multiply() As Double Implements Test.Multiply WriteLine(a * b) Read() End FunctionEnd Class

  46. Abstract Classes • An abstract class is the one that is not used to create objects. • An abstract class is designed to act as a base class (to be inherited by other classes). • Abstract class is a design concept in program development and provides a base upon which other classes are built.

  47. Abstract classes(2) • Abstract classes are similar to interfaces. • After declaring an abstract class, it cannot be instantiated on it's own, it must be inherited. • Like interfaces, abstract classes can specify members that must be implemented in inheriting classes. • Unlike interfaces, a class can inherit only one abstract class. Abstract classes can only specify members that should be implemented by all inheriting classes.

  48. Creating Abstract Classes • In Visual Basic .NET we create an abstract class by using the MustInherit keyword. • An abstract class like all other classes can implement any number of members. • Members of an abstract class can either be Overridable (all the inheriting classes can create their own implementation of the members) or they can have a fixed implementation that will be common to all inheriting members.

  49. Creating abstract classes(2) • Abstract classes can also specify abstract members. • Like abstract classes, abstract members also provide no details regarding their implementation. • Only the member type, access level, required parameters and return type are specified. • To declare an abstract member we use the MustOverride keyword. • Abstract members should be declared in abstract classes.

  50. Imports System.ConsoleModule abstractClasses Public MustInherit Class AbstractClass 'declaring an abstract class with MustInherit keyword Public MustOverride Function Add() As Integer Public MustOverride Function Mul() As Integer 'declaring two abstract members with MustOverride keyword End Class Public Class AbstractOne Inherits AbstractClass 'implementing the abstract class by inheriting Dim i As Integer = 20 Dim j As Integer = 30 'declaring two integers Public Overrides Function Add() As Integer Return i + j End Function 'implementing the add method Public Overrides Function Mul() As Integer Return i * j End Function 'implementing the mul method End Class

More Related