Sie sind auf Seite 1von 53

Module 9:

Defining Classes &


Members

By

SRIRAM . B
Overview

 Access Specifiers
 Access Modifiers
 Properties
 Interface
 Abstract Class
 Sealed Class
Access Specifier
 Access specifiers are used to limit the accessibility of
the data members and functions in a class.
 The accessibility of class members can be specified
using the keywords:
 Public
 Protected
 Private
 Internal
 Protected internal
Access Specifier
 The public keyword is used to provide unlimited access.

 The protected keyword is used to provide access to the same class


and its derived classes.

 The private keyword is used to limit the access within the class.

 The internal keyword is used to limit the access to the program file.

 The protected internal keyword is used to provide access within the


program file that contains the class definition and to the derived
classes.
Access Modifiers
 Modifiers determine how the data members and
methods are used in other classes and objects.
 A class declaration can include a sequence of access
modifiers.
 Access modifiers can also be applied to methods.
 The different access modifiers that can be used in a C-
Sharp program are:
 static
 sealed
 abstract
 virtual
Access Modifier - Static
 The features of a static modifier are:

 A static modifier allows a variable or method to be


associated with its class and not a class instance.
 A class cannot be declared static.
 Static members are shared by all the instances of a
class.
 A static member can be accessed using the class name.
Example 1 - Access Modifier - Static

using System;
public class Static_modifier
{
public static void sum(int a, int b)
//static keyword
{
int result=a+b;
Console.WriteLine("Sum of the numbers is
{0}",result);
}
Example 1 - Access Modifier - Static

public static void Main()


{
Static_modifier.sum(10,20);
//Static method used without declaring
the instance of the class

}
}
Access Modifier - Sealed
 The sealed modifier
 Does not allow a class to be inherited.
 Is used to create classes in which the methods cannot
be overridden.
 Is used to create standard classes that cannot be
derived.
 Does not allow a method to be overridden.
Example 1 - Access Modifier - Sealed
using System;
sealed class Base
//class declared as sealed
{
public void disp()
{
Console.WriteLine("Base");
}
}
Example 1 - Access Modifier -
Sealed..
class Derived : Base
{
public override void disp()
{
Console.WriteLine("Derived");
}
public static void Main()
{
Derived d=new Derived();
d.disp();
}
}
Access Modifier - Abstract
 The abstract modifier:
 Is used to define an incomplete class that is referred to
as the abstract class.
 An abstract class can act as the base class for other
classes.
 An abstract class cannot be instantiated directly.
 An abstract class cannot be sealed.
 An abstract method is one in which the method
definition is not given.
Example 1 - Access Modifier -
Abstract
using System;
abstract class Base
//abstract class declaration
{
public abstract void disp();
// abstract method declaration
}
Example 1 - Access Modifier -
Abstract..
class Derived : Base
{
public override void disp()
//overriding the abstract method
{
Console.WriteLine("Derived");
}
public static void Main()
{
Derived d=new Derived();
d.disp();
}
}
Access Modifier - Virtual
 The feature of the virtual modifier are:
 A virtual modifier is used to declare a virtual method.
 A virtual method cannot include static, abstract or
override modifier.
Example - Access Modifier - Virtual
using System;
class one
{
public virtual void func()
{
Console.WriteLine("in one func");
}
public virtual void func1()
{
Example - Access Modifier - Virtual
Console.WriteLine("in one func1");
} }
class two: one
{
public override void func()
{
Console.WriteLine("in two func");
}
public override void func1()
Example - Access Modifier - Virtual
{
Console.WriteLine("in two func1");
}
}

class three: one


{
Example - Access Modifier - Virtual
public override void func()
{
Console.WriteLine("in three func");
}
public override void func1()
{
Console.WriteLine("in three func1");
}
}
Example - Access Modifier - Virtual
class implement
{
public static void Main(){
one o=new two();
three t=new three();
o.func(); //invokes func() of two
o.func1(); //invokes func() of two
o=t;
o.func(); //invokes func() of three
o.func1(); // invokes func1() of three
}
}
Properties

 A property is an element of a programming language that


enables you to access an attribute of an object or a class.

 Properties can be considered to be extensions of fields but


they can not be stored in specific memory locations.

 The syntax of fields and properties is similar.

 Properties consist of accessors that are executed in order


to read or write values.

 There are two types of accessors, get and set.


Example - Properties
 You can access class fields with
properties using the following code:

using System;
public class PropertyHolder
{
private int someProperty = 0;
Example - Properties..

public int SomeProperty


{
get
{
return someProperty;
}
set
{
someProperty = value;
}
}
}
Example - Properties..

public class PropertyTester


{
public static int Main(string[] args)
{
PropertyHolder propHold = new
PropertyHolder();
propHold.SomeProperty = 5;

Console.WriteLine(“Property Value:{0}”,
propHold.SomeProperty);

return 0;
}
}
Example – Write Only Property

 You can create write-only property using the set


accessor in the property implementation.
using System;
public class PropertyHolder
{
private int someProperty = 0;
public int SomeProperty
{
set
{
someProperty = value;
Example – Write Only Property..

Console.WriteLine(“The someProperty field is


equal to {0}”,
someProperty);
} }
}
public class PropertyTest
{
public static int Main(string[] args)
{
PropertyHolder propHold = new
PropertyHolder();
propHold.SomeProperty = 5;
return 0;
}
}
Example – Read Only Property

 You can create properties that are read-only by


using only the get accessor in the property
implementation.
using System;
public class PropertyHolder
{
private int someProperty = 0;

public PropertyHolder(int propVal)


{
someProperty = propVal;
}
Example – Read Only Property
public int SomeProperty
{
get
{
return someProperty;
}
}
}
Example – Read Only Property

public class PropertyTest


{
public static int Main(string[] args)
{
PropertyHolder propHold = new
PropertyHolder(5);
Console.WriteLine(“Property Value:{0}”,
propHold.SomeProperty);
return 0;
}
}
Interface
 An interface is a contract that contains a collection
of function prototypes.

 You can implement the interface functions in a class


in order to derive from an interface.
 Interfaces can contain:
 Methods
 Properties
 Indexers
 Events
Interface
 Syntax
– - interface inter { }
– - Contains only method prototypes and not fields
– - By default all are public
– - It can extend zero or more interfaces
– - A class implementing an interface should implement
all the methods
Interface
 Implementing methods explicitly

 Use fully qualified name for the method ie the name of the
interface and the method name.

 Restrictions

 You can access the explicitly defined method only thro the
interface ref.

 Cannot specify an access modifier

 This allows multiple methods with same signature from


diff interfaces to be defined
Example - Interface
interface Itest{
string this[int index] {
get;
set;
}
void F(int value);
string P {
get;
set;
}
}
Example - Interface
You can implement multiple inheritance using
interfaces.
For example,
interface IControl
{
void Paint();
}
Interface ITextBox: IControl
//ITextBox inherits from IControl
{
void SetText(string text);
}
Example - Interface
interface IListBox: IControl
{
void SetItems(string[] items);
}
interface IComboBox: ITextBox, IListBox
// The interface IComboBox inherits from more
than one interface, ITextBox and IListBox.
Example - Interface

You can implement multiple interfaces using


classes.
For example,
interface IMath
{
void Divide(int a, int b, out int re, out int
rem);
}
public class EditBox:IMath, ITextBox
Example - Interface

{
public void Divide(int a, int b, out int
res, out int remainder)
{…}
public void Text()
{…}
}
}
Interface

 You can avoid making the interfaces public in the


implementing class by using qualified names like

void IMath.Divide (int a, int b, out int res, out int


remainder) {…}

void ITextBox.Text() {…}

 Interfaces used with qualified names are also known as


explicit interface members because each member
explicitly provides names of the interface member that
is implemented.

 Explicit interface members can only be called through


the respective interface.
Diff. Between Interface & Abstract
Class
 In an interface class, all methods must be abstract. 

 In an abstract class some methods can be concrete. 

 In an interface class, no accessibility modifiers are


allowed, which is ok in an abstract class.
Abstract Class

 A class that provides common behaviour across a set of


subclasses, but is not itself designed to have instances that
work.

 If you would like to make classes that only represent base


classes, and don’t want anyone to create objects of these class
types.

 It is used to indicate that a class is incomplete and that it is


intended to be used only as a base class.
Abstract Class

 An abstract class cannot be instantiated.


 An abstract class is permitted (but not required) to
contain abstract members.
 An abstract class cannot be sealed.
 An abstract method cannot be private.

 If you declare an abstract method as protected, it should


be protected in its derived class.

 An abstract method cannot have the modifier virtual,


because an abstract method is implicitly virtual.
 An abstract member cannot be static
Example 1 - Abstract Class
using System;

namespace sampleAbstractClass
{
class sampleAbstractClass
{
static void Main(string[] args)
{
yyy a = new yyy();
www b = new www();
a.abc();
b.abc();
Console.ReadLine();
//System.Console.WriteLine("yyy abc");
}
}
Example 1 - Abstract Class
abstract class xxx
{
public abstract void abc();
//System.Console.WriteLine("yyy abc");
}
class yyy : xxx
{
public override void abc()
{
System.Console.WriteLine("yyy abc");
}
}
class www : xxx
{
public override void abc()
{
System.Console.WriteLine("www abc");
}
}
}
Example 2 - Abstract Class
using System;
using System.Collections.Generic;
using System.Text;
namespace sealed_abstract
{
abstract class absClass
{
//A Non abstract method
public int AddTwoNumbers(int Num1, int Num2)
{
return Num1 + Num2;
}
//An abstract method, to be overridden in derived
class
public abstract int MultiplyTwoNumbers(int Num1,
int Num2);
}
Example 2 - Abstract Class..

//A Child Class of absClass


class absDerived : absClass
{
static void Main(string[] args)
{
// You can create an instance of the derived class
absDerived calculate = new absDerived();
int added = calculate.AddTwoNumbers(10, 20);
Example 2 - Abstract Class..

int multiplied =
calculate.MultiplyTwoNumbers(10, 20);

Console.WriteLine("Added : {0},Multiplied : {1}",


added, multiplied);
}

//using override keyword,implementing the abstract


method
//MultiplyTwoNumbers
public override int MultiplyTwoNumbers(int
Num1, int Num2)
{
return Num1 * Num2;
}
}
}
Sealed Class
 You can use sealing to limit the ways in which developers
can extend your framework.

 When you seal a class, other classes cannot inherit from it.
When you seal a member, derived classes cannot override
the implementation of the member. You should not seal
types and members by default.

 Sealing prevents customization of library types and


members, and impacts the perception of usability for some
developers.

 In addition, extensibility is one of the fundamental benefits


of using an object-oriented framework.
 You should carefully weigh decisions that restrict this
benefit.
Sealed Class..
 A sealed class cannot be used as a base class.
 For this reason, it cannot also be an abstract class.
 Sealed classes are primarily used to prevent derivation.
 Sealing a class means one can not derive from it.
 Sealing a method means one can not override it.
Example :
public sealed class classSealed
{
// Class members here.
public string ID;
public double Price;
}
Example 1 - Sealed Class

using System;
using System.Collections.Generic;
using System.Text;

namespace sealed_abstract
{
sealed class SealedClass
{
public int x;
public int y;

}
Example 1 - Sealed Class..
class MainClass
{
static void Main()
{
SealedClass sc = new SealedClass();
sc.x = 110;
sc.y = 150;

Console.WriteLine("x = {0}, y = {1}",


sc.x, sc.y);
}

}
}
Session Ends
Exercise
Relax

Das könnte Ihnen auch gefallen