C#之初级篇

标签：结构   实例   类   c#   namespace   

bool类型 

bool a=true;

装箱：将值类型隐式转换为引用类型

首先分配一个对象实例，然后将值类型的值复制到该实例中

int i=10;
object obj=i;//将int型的变量i隐式的转换成引用类型，并将其值赋给object类型的变量obj

检查该对象实例是否为给定值类型的一个装了箱的值，将值从实例中复制出来

int i=10;
object o=i;
int j=(int)o;

 ref  引用参数不创建新的位置，引用参数和其基础变量操作的是同一个变量

out  输出参数的值总是与基础变量相同，该函数成员将在这一个存储位置存储新的值，并修改基础变量的值

int F(int j,out int i)
{
j--;
i=j;//在修改i参数的值的同时也修改了i变量的值
return i+j;
}
...
int i;
int sum=F(100,out i);

class Program
    {
        int F(ref int i, int j)
        {
            i--;
            return i + j;
        }
        static void Main(string[] args)
        {
            int i = 10;
            Program p = new Program();
            int sum = p.F(ref i, 10);
            Console.WriteLine("sum的值是：" + sum);
            Console.ReadLine();
        }
    }

类型测试运算符 is as

is运算符用来测定运行时类型是否与给定类型兼容，结果为bool

int i=100;
bool j=i is object;//判断变脸i是否可以转换成object类型

int i=10;
object j=i as object;//将i由int类型转换成object类型

int [] arr={2,3,4,5};
int sum=0;
foreach(int i in arr)//可以；理解为i是第几个数据
{
sum+=i;
}

在同一个命名空间中，各个类可以互相调用，如果在不同的命名空间中，就需要在调用的类之前添加对应的命名空间名称加点号

namespace Test
{
class demo1{
}
class demo2
{
}
class demo3
{
static void Main(string[] args)
{
Test.demo1 d1=new Test.demo1();
Test.demo2 d2=new Test.demo2();
}
}
}

在程序中，可能会使用与系统封装的类相同的的名称命名的一个类，使用双冒号可以在指定的命名空间中寻找1标示符

M::test1 t1=new M::test1();//使用::限定为M命名空间中的test1
L::test1 t1=new L:;test1();//使用::限定为M命名空间中的test1

seald

seald类，密封类不能作为基类，也不能作为抽象类，因此不能从密封类派生新的类

seald class Classs1
{
public void Fun()
{
}
}

虚方法可以由派生类实现（重写方法)

...
public class Program
{
public virtual void P1()
{
Console.WriteLine("program p1");
}
}
public class Test:Program
{
public override void P1()
{
Console.WriteLine("Test.p1");
}
}
...

密封方法

使用sealed修饰符，可以防止派生类重写该方法

public class Test
{
public sealed override void p
{
Console.WriteLine("Test");
}
}

C#特有机制

...
public class Program
{
private string name;
publid string Name
{
get{return name;}
set{name=value;}
}
static void Main()
{
Program p=new Program();
p.Name="hxk";
string name=p.Name;
console.WriteLine(name);
}
}

申明索引器时，需要使用this关键字

public class Program
{
private string[] list;//string类型的数组
public string this[int index]//申明索引器，索引为int类型
{
get{ return list[index];}//获取list数组中的元素
set
{
if(index>-1&&index<list.Length) list[index]=value;//设置list数组元素的值
}
}
public Program（int count)//构造函数
{
list=new string[count];
for(int i=0;i<count;i++)
{
list[i]=i.toString();
}
}
static void Main(string[] args)
{
int count=100;
Program p=new Program(count);
for(int i=0;i<count;i++)
{
//通过索引器访问list数组的元素

Console.WriteLine(p[i]+"");
if(i%10==0)
Console.WriteLine();
}
}
}

析构函数是手动释放类的实例占用的资源，并销毁类的实例

public class Program
{
~Program()
{
Console.WriteLine("销毁类的实例");
}
}

结构

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

namespace Chapter9
{
    class Program
    {
        //声明结构S
        public struct S
        {
            int i;
            public S(int i)
            {
                this.i = i;
            }
            public void F()
            {
                Console.WriteLine("今天是" + i + "号。");
            }
        }

        static void Main(string[] args)
        {
            S s = new S(21);
            s.F();
            Console.ReadLine();
        }
    }
}

动态数组

namespace Chapter10
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList l = new ArrayList();                            //声明一个动态数组l
            l.Add("今天是2012年12月11日");
            l.Add(2012);
            l.Add(12);
            l.Add(11);
            foreach (object obj in l)
            {
                Console.WriteLine(obj);                            //将动态数组各元素打印输出
            }
            Console.ReadLine();
        }
    }
}

C#之初级篇

标签：结构   实例   类   c#   namespace   

原文地址：http://blog.csdn.net/u013470102/article/details/44499239