静态类和静态方法，抽象类和抽象方法，new关键字，值类型和引用类型，接口

静态类和静态方法：静态成员是与类相关，而非实例相关；普通类中的静态成员:1.只能通过类名访问。2.静态方法中只能访问静态成员，或通过对象访问实例成员。3.多个对象共享同一个成员。静态类（一般用作工具类）：1.Math，console等都是静态类。2.静态类中只能包含静态成员。注意：少使用静态类，静态类、静态成员所分配的内存在程序退出时才会释放。静态类的本质abstract（不能被实例化）+sealed（不能被继承）。

多态：多态就是指不同对象收到相同消息时，会产生不同行为，同一个类在不同的场合下表现出不同的行为特征。多态的作用：把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。实现多态的方式:virtual,abstract,接口。

 

抽象类：抽象类不能被实例化。抽象类中可以有普通成员。抽象类存在的意义：1.抽象类不能被实例化，只能被其他类继承2.继承抽象类的子类必须把抽象类中的所有抽象成员都重写（实现）（除非子类也是抽象类。）3.抽象类就是为了重写→多态(代码重用)。4.抽象类中可以有实例成员也可以有抽象成员。

 

抽象类的例子：计算形状Shape(圆Circle，矩形Square ，正方形Rectangle)的面积、周长。

class Program

    {

        #region 计算形状Shape(圆Circle，矩形Square?，正方形Rectangle)的面积、周长





        #endregion

        static void Main(string[] args)

        {

            Circle c = new Circle(3);

            double circleArea = c.area();

            Console.WriteLine(circleArea );

            Square s = new Square(4,3);

            double squareArea = s.area();

            Console.WriteLine(squareArea);

            Rectangle r = new Rectangle(5);

            double rectangelArea = r.area();

            Console.WriteLine(rectangelArea);

            Console.ReadKey();

        }

    }

    /// <summary>

    /// 形状的抽象类

    /// </summary>

    public abstract class Shape

    {

        public abstract double area();

        public abstract double circumference();

    }

    /// <summary>

    /// 圆形类，继承自形状类，重写抽象方法

    /// </summary>

    public class Circle : Shape

    {

        public Circle(double radius)

        {

            this.radius = radius;

        }

        double radius;



        public double Radius

        {

            get { return radius; }

            set { radius = value; }

        }

        public override double area()

        {

            return Math.PI * this.Radius * this.Radius;

        }



        public override double circumference()

        {

            return 2 * Math.PI * this.Radius;

        }

    }

    /// <summary>

    /// 矩形类，继承自形状类，重写抽象方法

    /// </summary>

    public class Square : Shape

    {

        public Square(double length, double width)

        {

            this.length = length;

            this.width = width;

        }

        double length;



        public double Length

        {

            get { return length; }

            set { length = value; }

        }

        double width;



        public double Width

        {

            get { return width; }

            set { width = value; }

        }



        public override double area()

        {

            return this.Width * this.Length;

        }



        public override double circumference()

        {

            return 2 * (this.Width + this.Length);

        }

    }

    /// <summary>

    /// 正方形类，继承自形状类，重写抽象方法

    /// </summary>

    public class Rectangle : Shape

    {

        public Rectangle(double l)

        {

            this.length = l;

        }

        double length;



        public double Length

        {

            get { return length; }

            set { length = value; }

        }



        public override double area()

        {

            return Length * Length;

        }



        public override double circumference()

        {

            return 4 * Length;

        }

    }

虚方法与抽象方法：

虚方法：

•1.父类中必须有实现。

•2.子类中可以不重写。

•3.虚方法可以在普通类中。（有序方法的类是可以（可能）被实例化的。）

抽象方法：

 

•1.父类中不能有任何实现。

•2.子类中必须重写（除非：子类也是一个抽象类。）

•3.抽象方法必须在抽象类中。

 

值类型与引用类型：值类型均隐式派生自System.ValueType：数值类型、bool、结构、枚举。引用类型派生自System.Object：字符串、数组、类、接口等。引用类型变量的赋值只复制对对象的引用。值类型变量赋值会拷贝一个副本。

 

接口：接口的例子：

class Program

    {

        #region 橡皮rubber鸭子、木wood鸭子、真实的鸭子realduck。三个鸭子都会游泳，而橡皮鸭子和真实的鸭子都会叫，只是叫声不一样，橡皮鸭子“唧唧”叫，真实地鸭子“嘎嘎”叫，木鸭子不会叫.把抽象类变成接口。



        

        #endregion

        static void Main(string[] args)

        {

            Ibark realduck = new RealDuck();

            //realduck.bark();

            Bark(realduck);

            Console.ReadKey();

        }

        public static void   Bark(Ibark bark)

        {

            bark.bark();

        }

    }

    interface Ibark

    {

        void bark();

    }

    interface Iswim

    {

        void swim();

    }

    public class RubberDuck:Iswim ,Ibark 

    {



        public void swim()

        {

            Console.WriteLine("橡皮鸭会游泳");

        }



        public void bark()

        {

            Console.WriteLine("唧唧");

        }

    }

    public class WoodDuck : Iswim

    {



        public void swim()

        {

            Console.WriteLine("我是木鸭，我只会游泳不会叫");

        }

    }

    public class RealDuck : Iswim, Ibark

    {



        public void swim()

        {

            Console.WriteLine("我是真鸭子，我会游泳");

        }



        public void bark()

        {

            Console.WriteLine("嘎嘎，我会叫");

        }

    }

接口特点总结：

1.接口是一种规范。为了多态。

2.接口不能被实例化。

3.接口中的成员不能加“访问修饰符”，接口中的成员访问修饰符为public,不能修改。（默认为public）

4.接口中的成员不能有任何实现。

5.接口中只能有方法、属性、索引器、事件， 不能有“字段”。

6.接口与接口之间可以继承，并且可以多继承。

7.实现接口的子类必须实现该接口的全部成员。

8.一个类可以同时继承一个类并实现多个接口。

9.当一个抽象类实现接口的时候，如果不想把接口中的成员实现，可以把该成员实现为abstract。(抽象类也能实现接口，用abstrac标记)

10.“显示实现接口”，只能通过接口变量来调用（因为显示实现接口后成员为private）。