c#初级

类：
创建一个类
public class A
{
//访问修饰符：public公有，protected 受保护的，private私有的。

    //public 在类内和类外都可以使用
    public int a; //定义一个字段a

    //protected 他只能在类内和它的子类中使用
    protected string b; //受保护的字段s

    //private 它只能在类内使用
    private float f;  //私有字段f

函数
//函数：有四种形式
//格式：访问修饰符 返回类型 函数名（形式参数）｛执行内容｝
//void：代表是空，即无返回类型
//Sum是自己起的名字

第一种形式
public void Sum()
{
Console.WriteLine(“无返回类型无参数的函数”);
}

第二种形式
public void Sum1(int a)
{
Console.WriteLine(“无返回类型有参数的函数”);
}

第三种形式
public int Sum2()
{
Console.WriteLine(“有返回类型无参数的函数”);
return 123;
}
public int[] Sum3()
{
int[] a = { 1, 2, 3, 4, 5 };
Console.WriteLine(“有返回类型无参数的函数”);
return a;
}

public float Sum3()
{
Console.WriteLine(“有返回类型无参数的函数”);
return 3.14f;
}

第四种形式

public int Sum4(string s)
{
Console.WriteLine(“有返回类型有参数的函数”);
return 1;
}

在主类中使用
//调用类的方法
//第一步 实例化一个类的对象
//格式：类名 对象名=new 类名（）;

        //第二步 调用该类的字段
        //格式：对象名，字段名=赋值

//调用函数的格式：对象名.函数名（实际参数）；

        A a1 = new A();
        a1.a = 34;

        A a1 = new A();
        a1.a = 34;
        //调用无返回类型无参数的函数
        a1.Sum();

        //调用无返回类型 有参数的函数
        a1.Sum1(12);

//调用有返回类型 无参数的函数
float f1= a1.Sum2();
Console.WriteLine(f1);

//调用有返回类型 有参数的函数

        int i = a1.Sum4("2");
        Console.WriteLine(i);

//static表示的是静态，静态类
//静态类里定义字段和函数必须是静态的
//非静态里可以定义静态字段和函数也可以定义非静态的字段和函数

public static class B
{
public static int a;//静态字段

    //静态函数
    public static void add()
    {
        Console.WriteLine("静态函数");

public class C
{
public int s; //非静态字段
public static int x; //静态字段
public void print()
{
Console.WriteLine(“非静态函数”);
}
public static void print1()
{
Console.WriteLine(“静态函数”);
}
}
调用静态函数
在main函数里面写代码
static void Main(string[] args)
{
//调用静态字段和静态函数的方法
//格式：类名。静态字段=赋值
//类名。静态函数（）；
C.x = 24;
Console.WriteLine(C.x);
C.print1(); //调用的的静态函数

题：
//从控制台上输入两个数 交换两个数的值

在main函数外面
public class B
{
public void Add(int a,int b )
{
int c = a;
a = b;
b = c;
Console.WriteLine("{0},{1}",a,b);
在main函数里面：
B b1 = new B();

        int n = Convert.ToInt32(Console.ReadLine());
        int m = Convert.ToInt32(Console.ReadLine());
        b1.Add(n, m);

第二种方法
public class D
{
public void Number1(int a)
{
if (a % 2 == 0)
{
Console.WriteLine(“偶数”);
}
else
{
Console.WriteLine(“奇数”);
}
}
}

函数里面

        D L = new D();
        int o = Convert.ToInt32(Console.ReadLine());
        L.Number1(o);

属性机制
在函数外面
public class per
{
public int a;
private int bar; //私有的 只能在类内使用
//在外部使用获取或者设置私有字段，提供了一种属性机制
public int Bar
{
get
{
return bar; //get是获取的意思
}
set
{
bar = value; //set是设置的意思
}

    }

在函数里面
per p1 = new per();
Console.WriteLine(p1.Bar);//通过get获取ber本身的值
p1.Bar = 35; //通过set重新设置bar的值

题：
//定义一个Date，定义私有字段 年月日 定义一个公有函数print，输入日期的全部信息
public class Date
{
private int year;
private int month;
private int day;
public int Year
{
get
{
return year;
}
set
{
year = value;
}

    }
    public int Month
    {
        get
        {
            return month;
        }
        set
        {
            if (value < 13 && value > 0)
            {
                month = value;
            }
            else
            {
                Console.WriteLine("输入的月份不正确");
            }
        }
    }
    public int Day
    {
        get
        {
            return day;
        }
        set
        {
            if (value < 31 && value > 0)
            {
                day = value;
            }
            else
            {
                Console.WriteLine("输入不正确");
            }
        }
    }
    public void print()
    {
        Console.WriteLine("年{0}，月{1}，日{2}",year,month,day );
    }

}

在函数里面
//Date nn = new Date();
//nn.print();
//nn.Year = 2018;
//nn.Month = 05;
//nn.Day = 29 ;
//nn.print();

//方法重载或者函数重载（方法等价于函数）
//方法重载：函数名相同，但是参数不同
//参数不同：参数个数不同 ，参数顺序不同，参数类型不同
列；
public void Add() { }
public void Add(int a) { }
public void Add(String s) { }
public void Add(string s,int i) { }
public void Add(int i,string s) { }

        Console.ReadKey();