C# for Beginner session 21 to 30

session 21Inheritance in c#

Why Inheritance

Pillars(支架) of Object Oriented PRogramming

1,Inheritance(繼承)

2,Encapsulation(封裝)

3,Abstraction(抽象類)

4,Poymorphism(多態)

1，Inheritance is one of the primary pillars of object oriented programming.

2,It allows code reuse.(重用)

3,Code reuse can reduce time and errors.

Note:You will specify(指定) all the common fields, properties,methods in the base class,which allows reusability.In the derived class you will only have fields, properties and methods,that are specific to them.

Inheritance Syntax

1,using : to inheritance

2,C# supports only single class inheritance.

3,C#supports multiple interface inheritance.

4,Child class is a specialization(特殊化) of base class.

5，Base classes are automatically instantiated(實例化) before derived classes.

6,Parent class constructor executes before Child Class constructor.

7,Using base keyWord to specify which Constructor methods .

session 22 Method hiding in c#

using the new keyword to hide a base class memeber.You will get a compiler(編譯器) warning,if you miss the new keyword.

Different ways to invoke a hidden base class member from derived class

1,Use base keyword.

2,Cast child type to parent type and invoke the hidden member

3,ParentClass PC = new ChildClass()

PC.HiddenMethod()

session 23Polymorphism in c#

Polymorphism is one of the primary pillars of object-oriented programming.

Polymorphism allows you to invoke derived class methods through a base class reference during runtime.

In the base class the method is declared virtual, and in the derived class we override the same method.

The virtual keyword indicates, the method can be overridden in any derived class.

session 24Difference between method overriding and method hiding

In method overriding a base class reference variable pointing to a child class object, will invoke the overriden method in the child class

In method hiding a base class reference variable pointing to a child class object, will invoke the hidden method in the base class.

session 25Method overloading in c#

Function overloading and method overloading terms are used interchangeably(互換).

Method overloading allows a class to have multiple methods with the same name, but, with a different signature(簽名). So, in C# functions can be overloaded based on the number, type(int, float etc), and kind(Value, Ref or Out) of parameters.

The signature of a method consists of the name of the method and the type, kind, and the number of its formal parameters. the signature of a method does not include the return type and the params modifier. So, it is not possible to overload a function, just based on the return type or params modifier.

session 26Why Properties

Marking the class fields public and exposing(暴露) to the external world is bad, as you will not have control over what gets assigned(賦值) and returned.

簡單的說，為了保護數據安全和完整性，所以需要屬性。

session 27Properties in C#

In C# to encapsulate(封裝) and protect fields we use properties

1,We use get and set accessors(訪問器) to implement properties

2,A property with only get accessor is a Read only property

3,A property with only set accessor is a Write only property

4,A property with both get and set accessor is Read/Write property

Note:The advantage of properties over traditional(傳統的) Get() and Set() methods is that, you can access(訪問) them as if they were public fields.

Auto implemented Properties

if there is no additional logic in the property accessors, then we can make use of auto implemented properties introduced in C# 3.0

Auto-implemented properties reduce the amount of code that we have to write.

When you use auto-implemented properties, the compiler creates a private, anonymous field that can only be accessed through the property's get and set accessors.

session 28Structs in C#

Structs

Just like calsses structs can have

1,Private Fields

2,Public Properties

3,Constructors

4,Methods

Object initializer syntax(語法), introduced in C# 3.0 can be used to initialize either a struct or a class

session 29Difference between classes and structs in c#

a struct is a value type where as a class is a reference type.（結構是值類型，類是引用類型）

All the differences that are applicable(適用于) to value types and reference types are also applicable to classes and structs

Structs are stored(存儲) on stack(棧), where as classes are stored on the heap(堆).

value type hold their value in memory where they are declared, but reference types hold a reference to an object in memory.

Value types are destroyed(銷毀) immediately(馬上) after the scope(應用范圍，也就是大括號) is lost, where as for reference types only the reference variable(變量) is destroyed after the scope is lost. The object is later destroyed by garbage collector.

when you copy a struct into another struct, a new copy of that struct gets created and modifications on one struct will not affect the values contained by the other struct.

when you copy a class into another class, we only get a copy of the reference variable, both the reference variables point to the same object on the heap. so, Operations on one variable will affect the values contanined by the other reference variable.

Classes Vs Structs

Structs can't have destructors, but classes can have destructors.（結構不能有析構函數，類可以有）

Structs cannot have explicit parameter less constructor where as a class can.（結構不可以有無參構造函數，類可以有）

Struct can't inherit from another class where as a class can. Both structs and classes inherit form an interface.（結構不能繼承類，類可以繼承機構，類和機構都可以繼承接口）

Example of structs in the .NET Framework -int(System.Int32),double(System.Double) etc.

Note1: A class or a struct cannot inherit form another struct. when Struct are sealed stypes.

Note2:How do you prevent a class from being inherited? Or what is the significance of sealed Keyword?

session 30Interfaces in c#

We create interfaces using interface keyword. just like classes interfaces also contains properties, methods, delegates or events, but only declarations and no implementations.

It is a compile time error to privide implementations for any interface member.

Interface members are public by default, and they don't allow explicit(顯式) access modifiers.

Interfaces cannot contain fields.（接口不可以包含字段）

If a class or struct inherits from an interface , it must provide implementation for all interface members. Otherwise, we get a compiler error.

A class or a struct can inherit from more than one interface at the same time, but where as, a class cannot inherit from more than oncee class at the same thime.

Interfaces can inherit from other interfaces. A class that inherits this interface must provide implementation for all interface members in the entire interface inheritance chain(一系列)

We cannot create an instance of an interface, but an interface reference variable can point to a derived class object.（接口不可以實例化，可是接口的引用可以指向子類，例如：IA a = new IA(); 這個是錯的，可是如果類A繼承了接口IA，那么這樣是可以的：IA a = new A();