静态类和静态方法，抽象类和抽象方法，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）。