C#入门秘笈(二)

类（Class）

语法：

属性和方法

静态方法(静态函数)

一、区别：

二、代码案例

三、总结

构造方法

系统默认的构造：

重载的有参构造

析构方法

部分资料来源于网络，如有侵权可联系本人删除

类（Class）

类是一种数据结构，它可以包含数据成员，函数成员以及嵌套类型。类类型支持继承。

语法：

类的定义是以关键字 class 开始，后跟类的名称。类的主体，包含在一对花括号内。

<access specifier> class  class_name
{
    // member variables
    <access specifier> <data type> 属性1;
    <access specifier> <data type> 属性2;
    ...
    <access specifier> <data type> 属性n;
    // member methods
    <access specifier> <return type> 成员1(parameter_list)
    {
        // method body
    }
    <access specifier> <return type> 成员2(parameter_list)
    {
        // method body

    }
    ...
    <access specifier> <return type> 成员N(parameter_list)
    {
        // method body
    }

}

<代码解析>

访问标识符 <access specifier> 指定了对类及其成员的访问规则。如果没有指定，则使用默认的访问标识符。类的默认访问标识符是 internal，成员的默认访问标识符是 private。

数据类型 <data type> 指定了变量的类型，返回类型 <return type> 指定了返回的方法返回的数据类型。

如果要访问类的成员，你要使用点（.）运算符。

点运算符链接了对象的名称和成员的名称。

属性和方法

成员属性是一个类中的变量属性，可以在函数中访问和使用。并且保持私有性来实现封装。

成员函数是一个在类定义中有它的定义或原型的函数，就像其他变量一样。作为类的一个成员，它能在类的任何对象上操作，且能访问该对象的类的所有成员。

通过不同访问修饰符创建的成员属性和方法，有这不同的访问作用域。这个就要求对于访问修饰符的深入了解。

静态方法(静态函数)

使用了static 修饰符的方法为静态方法，反之则是非静态方法。 静态方法是一种特殊的成员方法，它不属于类的某一个具体的实例，而是属于类本身。所以对静态方法不需要首先创建一个类的实例，而是采用类名.静态方法的格式 。

一、区别：

1.静态方法不需要类实例化就可以调用，反之非静态方法需要创建对象(实例)才能通过对象调用；

2.静态方法只能访问静态成员和方法，非静态方法都可以访问；

3.静态方法不能标记为override，导致派生类不能重写，但是可以访问；

4.静态成员是在第一次使用时进行初始化。非静态的成员是在创建对象的时候，从内存分配上来说静态是连续的，非静态在内存的存储上是离散的，因此静态方法和非静态方法，在调用速度上，静态方法速度一定会快点，因为非静态方法需要实例化，分配内存，但静态方法不用，但是这种速度上差异可以忽略不计

5.static方法是类中的一个成员方法,属于整个类,即不用创建任何对象也可以直接调用，static内部只能出现static变量和其他static方法。而且static方法中还不能使用this....等关键字，因为它是属于整个类!

静态方法：原理就是共享代码段 共享代码段不会产生任何问题 因为代码段都是给CPU作为"读取"用的,除非你进行恶意"修改"运行时的代码段 所以静态方法是可以放心使用的 。

静态变量：原理就是共享数据段 同上 只要没有进行"写入"操作就不会产生问题 但是数据通常都是用于读和写所以静态变量要注意使用。

注意：静态方法创建多的占用内存会很大，不是必要情况不要创建静态对象。

二、代码案例

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StaticFunction
{
    class Program
    {
        public static void Method3()
        {
            Console.WriteLine("我是Method3，是静态方法");
        }

        public void Method4()
        {
            Console.WriteLine("我是Method4，不是静态方法");
        }

        public void Method5()
        {
            //2.静态方法只能访问静态成员和方法，非静态方法都可以访问；
            A.Method1();//因为当前方法为非静态方法，所以都可以访问；
            A a = new A();
            a.Method2();
            Console.WriteLine("我是Method5，是非静态方法");
        }

        static void Main(string[] args)
        {
            {
                //1.静态方法不需要类实例化就可以调用，反之非静态方法需要创建对象(实例)才能通过对象调用；
                A.Method1();
                // A.Method2(); //报错，非静态方法必须通过实例化才能引用
                A a = new A();
                a.Method2();
            }
            {
                //2.静态方法只能访问静态成员和方法，非静态方法都可以访问；
                Method3();//因为是
                //Method4();Method4是非静态方法，在静态方法只能访问静态成员和方法
            }
            Console.ReadKey();
        }

    }

}

public class A
{
    public static void Method1()
    {
        Console.WriteLine("我是Method1，是静态方法");
        //静态方法中互获取类名
        string className =System.Reflection.MethodBase.GetCurrentMethod()
                          .ReflectedType.FullName;
        Console.WriteLine("Method1方法所在类：{0}", className);//命名空间.类名
    }
    public void Method2()
    {
        Console.WriteLine("我是Method2，不是静态方法");
        //非静态方法获取类名
        string className = this.GetType().FullName;
        Console.WriteLine("Method2方法所在类：{0}", className);//命名空间.类名;和上面方法同在一个类，所以输出结果相同

    }

}

三、总结

使用静态得准则就是：

1.保证不会产生并发。

2. 在方便快捷和开发难度上做一个衡量。

构造方法

构造方法的作用：构造方法的主要作用就是为类中的成员变量进行初始化。

<!--构造的注意事项 -->

1、构造方法名必须和类名相同。

2、构造方法能够添加参数。

3、构造方法可以进行重载，系统根据参数不同选择调用符合的构造方法。

4、构造方法可以不写，系统会添加一个默认的无参构造方法。

5、构造方法可以是私有的，私有后不允许通过该构造方法初始化对象。

6、构造方法会在创建对象或者第一次访问静态成员的时候调用。

系统默认的构造：

  public class student
    {
        //系统默认生成的构造方法
        public student()
        {
        }
    }

重载的有参构造

通过构造方法初始化成员变量：构造方法的参数可以是所有属性参数，也可以是其中几个。

        public student(参数1, 参数2, 参数3)
        {
            this. 参数1= 参数1;
            this. 参数2= 参数2;
            this. 参数3= 参数;
        }

那么怎样在别的类中调用呢，如写在Main方法里：

    class Demo
    {
        static void Main(string[] args)
        {
            student stu = new student();//默认构造，括号不能丢 
            student stu2 = new student(参数1,参数2,参数3);//重载的有参构造 
        }
    }

析构方法

作用：释放对象

谁在使用：GC垃圾回收机制在调用

语法：

~类名()
{
    //语句块（析构函数无法重载，一个类只有一个析构函数）
}

垃圾回收机制：

1.回收非托管资源(看是否是托管资源还是非托管资源，判断是否有DIspose()方法，如果有，则是非托管资源)具体有：

2.通过调用Close()和Disposable()实现。

CLose()方法关闭对象，没有完全释放

Disposable()方法完全释放了，再使用的时候需要重新创建

继承、

继承是面向对象程序设计中最重要的概念之一。继承允许我们根据一个类来定义另一个类。

当创建一个类时，程序员不需要完全重新编写新的数据成员和成员函数，只需要设计一个新的类，继承了已有的类的成员即可。这个已有的类被称为的基类，这个新的类被称为派生类。

一个类可以派生自一个类和多个接口，但是C#不支持多继承，所以可以继承于一个类和多个接口，但是不能继承于多个类。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ClassInherit
{
    class Shape
    {
        public void setLen(int w, int h)
        {
            width = w;
            height = h;
        }
        protected int width;
        protected int height;
    }
    // 基类 PaintCost
    public interface PaintCost 
    {
        int getCost(int area);
    }

    public interface PaintCost1
    {
        int getCost1(int area);
    }

    class Rectangle : Shape, PaintCost, PaintCost1 //C# 不支持多重继承。但是，
       //您可以使用接口来实现多重继承，如此处的PaintCost
    {

        // 成员变量
        protected double length;
        protected double width;
        public Rectangle(double l, double w)//重载的构造函数
        {
            length = l;
            width = w;
            Console.WriteLine("类(Rectangle)的重载构造被调用");
        }
        public double GetArea()//成员方法
        {
            return length * width;
        }
        public void Display()//成员方法
        {
            Console.WriteLine("长度： {0}", length);
            Console.WriteLine("宽度： {0}", width);
        }
        public int getCost(int area)//继承的接口1
        {
           return area * 70;
        }
        public int getCost1(int area)//继承的接口2
        {
            return area * 70;
        }
    }

    class Tabletop : Rectangle //单继承，
    {
        private double cost;
        public Tabletop(double l, double w) : base(l, w)
        {
            //子类的构造函数，为了兼容父类重载的构造函数
            //子类构造用默认构造的话会先调用父类的构造函数
            Console.WriteLine("子类(Tabletop)的重载构造被调用");
        }
        public double GetCost()
        {
            double cost;
            cost = GetArea() * 70;
            return cost;
        }

        public void Display()
        {
            base.Display();
            Console.WriteLine("成本： {0}", GetCost());
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Tabletop t = new Tabletop(4.5, 7.5);
            t.Display();
            Console.ReadLine();
        }
    }
}

委托

委托是一种类型，可以理解为方法的别名，实例化后可以与方法关联，用于方法调用或将方法作为参数传递；

1、委托定义

public delegate void DelShowMsg (string msg);

2、委托实例化

void ShowMessage (string s) { Print (s);}
DelShowMsg d = new DelShowMsg(ShowMessage);

或

 DelShowMsg d = ShowMessage;

3、委托调用

d("Hello, World!");

4、增加或减少关联的方法

d += new DelShowMsg(ShowMessage1);
d --= new DelShowMsg(ShowMessage2);

5、作为方法的参数

void Test ( DelShowMsg fun)
{
    fun ("Hello, World!");
}

事件

1、事件是一种特殊签名的委托实例，用于触发一个或多个响应处理方法；

2、常用事件

public delegate void EventHandler (object sender, System.EventArgs e);

public delegate void EventHandler <TEventArgs >(object sender, TEventArgs e);

3、事件定义

public event EventHandler EventTest；

4、订阅事件

public void TestMethod (object sender, System.EventArgs e) { };

EventTest += TestMethod

5、取消订阅

EventTest -= TestMethod；

5、触发事件

EventTest (this, System.EventArgs.Empty);

6、事件与委托的区别

事件对象只能在类内定义；

事件对象只能在其所在类内访问，外部类只能对事件对象使用+=或者-=；