一:c#基本语法(2)(老田学习笔记)

数组:

 

代码

  //二维数组
        String[,] abcd = new string[2, 4];//建立一个2*4的数组
        abcd[0, 0] = "田洪川";
        // abcd[0,1] = "";
        abcd[0, 2] = "自由职业者";
        abcd[0, 3] = "26岁";
        abcd[1, 0] = "黄晓梅";
        abcd[1, 1] = "女";
        abcd[1, 2] = "造价师";
        abcd[1, 3] = "24岁";

        for (int i = 0; i < abcd.Rank; i++)//循环数组的维数
        {/*利用GetUpperBound(abcd.Rand-1)得到数组最大维数索引上限,如果是GetUpperBound(0),
          * 就是最小维数的索引上限,数组的索引上限为3,所以这里的循环用了 <= ,而GetUpperBound(int demension)
          *该方法的参数dimension所指定的维数是从0开始的,所以需要:GetUpperBound(abcd.Rank-1),指定第二维的最大索引上限.
          *或者这样指定:GetUpperBound(1)指定第二维最大索引上限,那么abcd第二维为4,索引为3.就得到了最大索引了.
          */
            Response.Write(abcd.Rank + "<br>");
            for (int j = 0; j <= abcd.GetUpperBound(abcd.Rank - 1); j++)
            {
                Response.Write(abcd[i, j] + "<br/>");
            }

        }

 

 

结构和枚举

struct 类型是一种值类型，通常用来封装小型相关变量组，例如，矩形的坐标或库存商品的特征。下面的示例显示了一个简单的结构声明。

 

public struct Book
{
    public decimal price;
    public string title;
    public string author;
}

 

     结构还可以包含构造函数、常量、字段、方法、属性、索引器、运算符、事件和嵌套类型，但如果同时需要上述几种成员，则应当考虑改为使用类作为类型。

结构可以实现接口，但它们无法继承另一个结构。因此，结构成员无法声明为 protected。

结构可以在命名空间中,也就是和类一样的地方声明.

示例:

 

代码

public partial class Default6 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        //结构:
        Book b = new Book();
        b.price = 12.5m;
        b.title = "c#高级编程";
        b.Author = "未知";
        Response.Write(b.price + " "+b.title +" "+b.Author+"<br/>" );

        //枚举:
        Response.Write((int)Color.red);
    }

    public enum Color
    {
        red = 5,
        green = 7,
        blue = 9
    };

    public struct Book
    {
        public decimal price;
        public String title;
        public String Author;
    }
}

 

 循环:

 

代码

        //循环:
        string str = "abcdefghijkmlnopqrstuvwxyx";
        for (int i = 0; i < str.Length; i++)
        {
            Response.Write(str[i] + "<br/>");
        }

        int j = 0;
        do
        {
            j++;
            Response.Write(j + "<br/>");
        } while (j < 5);//do...while是先执行再判断所以能输出5为止


        int k = 0;
        while (k < 5) //而while是先判断再执行所以只能输出到4为止
        {
            Response.Write(k + "<br/>");
            k++;
        }

        string [] thc=new string[]{"labcd","2acde","33areff","4fcds2","dcccasa","6egfds"};
        foreach (string s in thc)
        {
            if (str.Contains("a")) //contains("a")表示a是否出现在该字符串中返回bool值
            {
                Response.Write(s+"<br/>");
            }
        }

 

 函数(传值,传地址):

 

代码

protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
             int i = 1;
             transmitValue(i);
             Response.Write("传递后的变量值:" + i + "发现值无任何变化的,因为是传值<br/>");
            transmitReference(ref i);
            Response.Write("传递后的变量值:" + i +"发现值变化了,因为传的是地址<br/>");
        }
    }

    //传值
    private void transmitValue(int i)
    {
        i = 5;
        Response.Write("传值:"+i+"<br/>");
    }

    //传引用,实际上传的是内存地址
    private void transmitReference(ref int i)
    {
        i = 5;
        Response.Write("传引用:" + i + "<br/>");
    }

 

 

运算符重载:

    因为重载的是系统定义好的那些运算符,这样一来问题就出来了,因为很容易混淆到底这个运算符是做什么的,简言之,他会让代码的易读性降低,那你可能会问了,既然如此那为什么还要学呢?原因很简单,因为在某些特定的环境下,他能够代码更加的简洁,也就是能够把复杂的问题给简化了.

 

     所以记住只有在运算符对类型具有很直观的意义(例如,支持表示数值的类型的两个实例相加)的情况下,才应进行运算符重载.不应使用运算符重载为非直观运算提供语法快捷方式.否则很难保证三个月后你自己都搞不懂你曾今做了什么.

 

     事实上,我们早就在用运算符重载了,记得前面我们讲算术运算符的时候说到加号,它实际上就是这样的,你看，当遇到数值类型的数据,它执行算术运算功能,当遇上字符串型的时候呢,他又执行的是连接的功能.

     

       以对称方式重载运算符:
       例如,如果重载相等运算符,也应重载不能运算符.同样,如果重载小于运算符,也应重载大于运算符.

示例:

 

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;

public class fuhao
{
    private string thc;

    private int age;

    public fuhao(string nthc,int nage)
    {
        thc = nthc;
        age = nage;
    }

    public string Thc
    {
        get
        {
            return thc;
        }
    }

    public int Age
    {
        get
        {
            return age;
        }
    }

    /*运算符:
    一元：！、~、++、--、-（负号）、*（指针）、&、sizeof
    二元：*、/、%、+、-、<<、>>、<、<=、>、>=、==、!=、&、^、|、&&、||、=、+=、-=、*=、/=、%=、>>=、<<=、&=、^=、|=
    三元：? :*/
    /*一元运算只需要一个参数就可以得出结果*/
    /*二元运算就需要两个参数来得出结果如下面例子的==,+,!=这些都是二元运算*/

    //operator是C#的关键字,用来指定你要重载的运算符如:
    /// <summary>
    /// 重载==运算符判断对象属性是否相等
    /// </summary>
    public static bool operator ==(fuhao a, fuhaoTest b)
    {
        if (a.Thc == b.Name && a.Age == b.Age)
        {
            return true;
        }
        else
        {
            return false;
        }
    }


    public static bool operator !=(fuhao a, fuhaoTest b)
    {
        return !(a == b);
    }


    public static string operator +(fuhao a, fuhao b)
    {
        return "<br/>" + a.Thc + a.Age + "<br/>" + b.Thc + b.Age;
    }
}


public class fuhaoTest
{
    private string name;

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    private int age;

    public int Age
    {
        get { return age; }
        set { age = value; }
    }

    public fuhaoTest(string name, int age)
    {
        this.name = name;
        this.age = age;
    }

}

 

 

 

代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Web.UI;
using System.Web.UI.WebControls;

public partial class Default6 : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        fuhao thc = new fuhao("田洪川", 27);
        fuhaoTest hxm = new fuhaoTest("黄晓梅", 11);

        Response.Write(thc == hxm);
        Response.Write("<br/>");
        Response.Write(thc != hxm);
        Response.Write("<br/>");
        Response.Write(thc+thc);
        Response.Write("<br/>");
    }
}

 

 

转载于:https://www.cnblogs.com/jhxk/articles/1622943.html