C#方法

一、static关键字

1、静态方法与实例化方法的区别：
   a)访问、调用方式：
 静态方法：调用前初始化
 实例化方法：实例化对象时初始化
   b)静态字段：在程序编译时就预先分配空间，访问效率更快
     实例化字段：执行到该代码段时才分配空间，需要关键字 new
2、静态调用关键字：static
   静态方法能访问到其他静态成员，不能访问实例成员

例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 静态方法
{
    public class Test
    {
        private static int member;

        //实例方法访问静态字段
        public void Way(int num)
        {
            member = num;
        }

        //静态方法访问静态字段
        public static void Show()
        {
            Console.WriteLine("Value of member:"+member);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Test test = new Test();
            //对象调用实例方法
            test.Way(40);
            Test.Show();
        }
    }
}

 

3、静态类：若类上加上static 关键字，则该类中的成员必须为静态成员，且不能继承静态类

 

二、方法重载
1、含义：在同一个类中，方法名相同，参数数据类型、个数或顺序不同的方法

2、例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication4
{
    public class Student
    {
        public void Show1(int num1, int num2)
        {
            Console.WriteLine("两个整数相加为：{0}",num1+num2);
        }
        public void Show2(string sign1, string sign2)
        {
            Console.WriteLine("两个字符串相加等于：{0}",sign1+sign2);
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            Student student = new Student();  //得到Student类的对象
            student.Show1(12,21);
            student.Show2("Hello", "girl");
        }
    }
}

 

三、构造函数：与类名相同，初始化成员变量
1、特征：
a)：无返回值
b)：可重载
c)：任何对象要创建成功必须先调用相应的构造函数再对属性进行赋值
2、语法：
访问修饰符 类名（参数列表）
{
   //构造函数主体
}

3、默认构造函数
a）若类中没有显示定义构造函数，编译器会自动提供一个隐式的默认的不带参数的构造函数，当显示的定义了构造函数时，编译器则不会提供，若要使用默认的构造函数，则需显示定义

例：Student 类中声明两个构造函数

public class Student
    {
        private int no;
        private string name;
        //定义一个带int参数的构造函数
        public Student(int num){ }
        //定义一个带string参数的构造函数
        public Student(string name) { }
    }

      调用构造方法实例化对象

Student student = new Student();  //错误 没有不带参数的构造函数

      需要在Student类中手动定义一个无参数的构造函数

public Student(){}

4、带参数的构造函数

例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 带参数的构造函数
{
    public class Program
    {
        public int num;
        public string name;
        //无参数的构造函数中初始化两个字段
        public Program()
        {
            num = 39;
            name = "Shelly";
        }

        //带int参数的构造函数
        public Program(int id)
        {
            num = id;
            name = "Shelly";
        }
        //带string参数的构造函数
        public Program(string sname)
        {
            num = 49;
            name = sname;
        }
        public void Print()
        {
            Console.WriteLine("name={0}，num={1}",name,num);
        }
        static void Main(string[] args)
        {
            //实例化对象
            Program p1 = new Program();
            p1.Print();

            //int
            Program p2 = new Program(29);
            p2.Print();

            //string
            Program p3 = new Program("Hi");
            p3.Print();
        }
    }
}

 

 

5、静态构造函数：不需要访问修饰符
例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 静态构造函数
{
    public class Test
    {
        //静态字段
        private static int num;
        //静态构造函数
        static Test()
        {
            num = 10;
            Console.WriteLine("num="+num);
        }

        static void Main(string[] args)
        {
            Test test = new Test();
        }
    }
}

 

6、析构函数

   析构方法的重要内容：
1) 不带参数
2) 每个类中有且只有一个
3) 不带访问修饰符
4) 与类名相同，以~作前缀
5) 不能在代码中显示调用析构方法，在垃圾收集过程中调用，垃圾器分析代码，并确定在代码中没有任何途径引用该对象

   注意：若不需要就避免执行，只应释放对象自己外部的资源，不应该访问其他对象

例：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 析构函数
{
  public class ShowClass1
    {
        public ShowClass1()
        {
            Console.WriteLine("调用构造函数:ShowClass1");
        }

        ~ShowClass1()
        {
            Console.WriteLine("调用析构函数:ShowClass1");
        }
    }
  public class ShowClass2
    {
        public ShowClass2()
        {
            Console.WriteLine("调用构造函数:ShowClass2");
        }

        ~ShowClass2()
        {
            Console.WriteLine("调用析构函数:ShowClass2");
        }
        public void test()
        {
            ShowClass1 sc1 = new ShowClass1();
            ShowClass2 sc2 = new ShowClass2();
        }
        
    }
    class Program
    {
        static void Main(string[] args)
        {

            //析构函数调用
            Program pro = new Program();
            pro.test();

            Console.WriteLine();
        }

        //析构函数的实例化
        public void test()
        {
           ShowClass1 sc1 = new ShowClass1();
           ShowClass2 sc2 = new ShowClass2();
        }
        
    }
}

 

构造函数与析构函数不同点：
  1)实例化：构造函数：创建类的每个新实例时调用一次
     析构函数：在每个实例被销毁前调用
  2)静态：构造函数：只调用一次，在类的任意静态变量第一次被访问之前，或在实例被创建之前
   析构函数：不存在，只有实例才有析构函数

7、readonly关键字

   1)、与const不同点：
       　　　　 字段初始化：readonly：可以在声明字段时初始化，也可在构造函数中初始化
    　　　　　　　　　　    const：只能在声明时初始化
　　　　　　  字段状态：readonly：可静态页可非静态
 　　　　  　　　　　　  const：总是静态
　2)、例：

public class Evaluation
    {
        public int x;
        //声明readonly字段
        public readonly int y = 25;  //在声明时初始化值
        public readonly int z;
        public Evaluation(int x)
        {
            this.x = x;
            //在构造函数中初始化值
            z = 25;
            Console.WriteLine("x={0},y={1},z={2}",x,y,z);
        }
        public Evaluation(int num1,int num2,int num3)
        {
            x = num1;
            y = num2;
            z = num3;
            Console.WriteLine("x={0},y={1},z={2}", x, y, z);
        }
    }
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
class Program
 {
     static void Main(string[] args)
     {
           //readonly关键字在声明或构造函数中初始化
          Evaluation show = new Evaluation(11,21,31);
          Evaluation show2 = new Evaluation(22);

      }
      
        
 }

 

View Code

 

8、this关键字：在类中访问自身成员，常用在索引器中
使用范围：实例化构造函数、实例方法、属性和索引的实力访问器、用于区分类的成员和本地变量或参数、作为调用方法的实参
例：
public Round(double r)
{
   this.r=r;//用于区分类成员和参数
}

 

9、索引器：对象的数组访问器
a)使用范围：在任何可以声明属性的地方都可声明
b)语法：
访问修饰符 数据类型 this [数据类型 标识符]
{
   get{};
   set{};
}
c)注意：仅有一个元素时，没有必要使用索引器进行访问，索引器专门针对于数组进行索引