Esempio n. 1
0
        public void CircleArea()
        {
            var cir    = new CircleA(6);
            var result = cir.Area();

            Assert.AreEqual(113, System.Math.Round(result));
        }
        static void main(string[] args)
        {
            /*
             * Inheritance -
             * allows us to define a class based on another class. This makes creating and maintaining an application easy.
             * The class whose properties are inherited by another class is called the Base class. The class which inherits the properties is called the Derived class.
             * for example, Base class Animal can be used to derive Cat and Dog classes.
             * The derived class inherits all the features from the base class and can have its own additional features
             * example line(12)
             */
            Dog d = new Dog();

            Console.WriteLine(d.Legs); //output is 4
            d.Bark();                  //output Woof
            //A base clase can have multiple derived classes.
            //for example, a Cat class can inherit from Animal
            //Inheritance allows the derived class to reuse the code in the base class without having to rewrite it. Also the derive class can be customized by
            //adding more members. In this manner, the derived class extends the functionality of the base class.

            /*A derived class inherits all the members of the base class, including its methods
             * example line(30)
             *
             */
            Student s = new Student();

            s.Speak();          // output Hi there
                                //C# does not support multiple inheritance, so we cannot inherit from multiple classes, however, we can use interfaces to implement multiple inheritance



            /*
             * Protected -
             * This access modifier is very similar to private access modifier with one difference.
             * A Protected access modifier can be accessed in the derived classes. So a protected member is accessible only from derived classes
             * example line(43)
             */
            Student2 s2 = new Student2("Iykeman");

            s2.Speak();

            /*Sealed -
             * A class can prevent other classes from inheritig it, or any of its members by using the sealed modifier. example
             * sealed class Animal {
             *   //some code
             * }
             * class Dog : Animal {  }   // Error
             * The sealed keyword provides a level of protection to your class so that other classes cannot inherit from it
             */


            /*Derived Class Constructor and Destructor
             * Contructors are called when objects of a class are created. With inheritance, the base class constructor and destructor are not inherited, so we should
             * define constructors for the derived classes.
             * However, he base class constructor and destructor are being invoked automatically when an object of the derived class is created or derleted
             * consider example line(61)
             * Note that the base class constructor is called first and the derived class constructor is called next. When the object is destroyed, the derived class
             * destructor is invoked and then the base class destructor is invoked.
             * we can think of this as the following: the derived class needs its base class in order to work which is why the base class constructor is called first
             */
            Cow c = new Cow();


            /* Polymorphism -
             * this word means having many forms, it occurs when there is a hierarchy of classes and they are related through inheritance from a common base class.
             * Polymorphism means that a call to a member method will cause a different implementation to be executed depending on the type of object that invokes the method.
             * This simplt means that a single method can have a number of different implementations.
             * -Consider having a program that alllows users to draw different shapes.Each shape is drawn differently and you do not know which shape the user will choose,
             * Here, polymorphism can be leveraged to invoke the appropriate Draw method of any derived class. Such methods must be declared using the virtual keyword in the base class
             * example below and line(85)
             * class shape {
             *      public virtual void Draw() {
             *          Console.WriteLine("Base Draw");
             *      }
             * }
             * The virtual keyword allows methods to be overridden in derived classes.
             * Virtual methods enable us to work with groups of related objects in a uniform way.
             *
             * we can derive different shape classes that define their own Draw methods using the override keyword. example line (93).
             * The virtual Draw method in the Shape base class can be overridden in the derived classes. In this case, Circle and Rectangle have their own Draw methods.
             * we can create separate Shape objects for each derived type and then call their Draw methods
             */
            Shape cc = new Circle();

            cc.Draw();   // output "Circle Draw"
            Shape rt = new Rectangle();

            rt.Draw();  //output "Rectangle Draw"

            /*Polymorphism is useful in many cases, For example, we could create a game where we would have different player types with each player
             * having a separate behaviour for the Attack method.
             * In this case, Attack would be a virtual method of the base class Player and each derived class would override it.
             */


            /*Abstract Classes -
             * In situation where it is not meaningful for the virtual method(polymorphism) to have a separate definition in base class,
             * we defined this method with the abstract keyword and specify that the derived classes must define their method on their own.
             * we cannot create objects of a class containing an abstract method, which is why the class itself should be abstract
             * lets use abstract method in the shape class as in polymorphism case, example line (113)
             * The draw method on line 133 is abstract and thus has no body, we do not even need a curly brackets, just end the statement with a semicolon.
             * The Shape class itself must be declared abstract because it contains an abstract method. Abstract method declarations are only permitted in abstract classess
             * Members marked as abstract or included in an abstract class must be implemented by classes that derive from the abstract class.
             * An abstract class can have multiple abstract members
             * Ab abstract class is intended to be a base class of other classess. It acts like a template for its derived classes.
             * we can now define other classes and define their own Draw() method. example line(117)
             */
            Shape2 cc2 = new Circle2();

            cc.Draw();  // output "Circle Draw"
            Shape2 rt2 = new Rectangle2();

            rt.Draw(); //output "Rectangle Draw"

            /*Abstract class have the following features
             * An abstract class cannot be instantiated
             * An abstract class may contain abstract methods and accessors
             * A non-abstract class derived from an abstract class must include actual implementations of all inherited abstract methods and accessors
             * Note that it is not possible to modify an abstract class with the sealed modifier because the two modifiers have opposite meanings.
             * The sealed modifier prevents a class from being inherited and the abstract modifier requires a class to be inherited
             */



            /* Interfaces -
             * An interface is a completely abstract class, which contains only abstract members. It is declared using the interface keyword,
             * Example -
             * public interface IShape
             * {
             *     void Draw();
             * }
             * All members of the interface are by default abstract, so no need to use the abstract keyword.
             * Also all members of an interface are always public, an no access modifiers can be applied to them.
             * It is common to use the capital letter I as the starting letter for an interface name.
             * Interfaces can contain properties, methods, etc but cannot contain fields (variables).
             *
             * When a class implements an interface, it must also implement, or define, all of its methods.
             * The term implementing an interface is used(opposed to the term "inheriting from") to describe the process of creating a class based on an
             * interface. The interface simply describes what a class should do. The class implementing the interface must define how to accomplish the behaviours.
             * The syntax to implement an interface is the same as that to derive a class.
             * example line (134)
             */
            IShape ca = new CircleA();

            ca.Draw();  //Output "Circle Draw"

            /*Note that the override keyword is not needed when you implement an interface
             * Why use interfaces rather than abstract classes?
             * A class can inherit from just one base class, but it can implement multiple interfaces!
             * Therefore, by using interfaces we can include behaviour from multiple sources in a class.
             * To implement multiple interfaces, use a comma separated list of interfaces when creating the class: Class A : IShape, IAnimal, etc
             */



            /*
             * Nested Classes
             * C# supports nested classes, a nested class is a class that is a member of another class. example below & line (148)
             * class Car {
             *      string name;
             *      public Car(string nm) {
             *          name = nm;
             *          Motor m = new Motor();
             *      }
             *      public class Motor {
             *          // some code
             *      }
             * }
             *
             * The Motor class is nested in the Car class and can be used similar to other members of the class.
             * A nested class acts as a member of the class, so it can have the same access modifiers as other members(public, private, protected).
             *
             * Just as in real life, objects can contain other objects. For example, a car, which has its own attributes(color, brand, etc) contains
             * a motor, which as a separate object, has its own attributes(volume, horsepower, etc).
             * Here, the Car class can have a nested Motor class as one of its members
             */



            /*Namespaces
             * when we create a blank project, it has the following structure:
             *
             * using System;
             * using System.Collections.Generic;
             * using System.Linq;
             * using.System.Text;
             * using System.Threading.Tasks;
             *
             * namespace SoloLearn {
             *    class Program {
             *        static void Main(string[] args) {
             *        }
             *    }
             * }
             *
             * Note that our whole program is inside a namespace. So, what are namespaces?
             * Namespaces declare a scope that contains a set of related objects. You can use a namespace to organize code elements.
             * You can define your own namespaces and use them in your program. The using keyword states that the rpogram is using a given namespace.
             * for example, we are using the System namespace in our programs, which is where the class Console is defined. Without the using
             * statement, we would have to specify the namespace whereever it is used like below
             * System.Console.WriteLine("Hello world");
             *
             * The .NET framework uses namespaces to organize its many classes. System is one example of a .NET framework namespaces. Declaring your
             * own namespaces can help you group your class and method names in larger programming projects
             *
             */
        }