新浪博客对博文的字数有限制,艾,有些不足啊,否则我何必将N也笔记分开呢?效率太低:
8;C#数据类型有:数值类型,引用类型,指针类型。
9; //装箱和拆箱:任何值类型的引用类型和object对象类型之间进行转换。通过该转换任何值类型的引用类型和object对象类型之间进行转换。
//装箱:就是指将值类型转换成一个引用类型,或者把值类型转换成一个被该值类型应用的接口类型。
//在C#语言类型系统中,提出了两个核心概念,即装箱和拆箱。
//装箱,其实就是指将一个值类型转换成一个引用类型,或者把值类型转换成一个被该值类型应用的接口类型。这个过程会使用到堆栈。关于C#语言的装箱,如下所示:
//int i = 100; //定义一个值类型变量
//object obj = I; //进行装箱转换。
//拆箱,就是指将一个引用类或一个对象类型转换成一个值类型的过程。请读者们注意C#语言的装箱和拆箱,这在处理大量数据的时候,非常有用。
ArrayList arraylist = new ArrayList();//加System.Collections
for (int i = 0; i < 10; i++)
{
arraylist.Add(i);//装箱
}
for (int i = 0; i < 10; i++)
{
Console.WriteLine(arraylist[i]);
}
Console.Read();
//本来是要建立stringyuaylist=new string[10];
10;GOTO语句的使用
int a, b;
Console.WriteLine("请输入A:");
a = Convert.ToInt32(Console.ReadLine());
Console.WriteLine("请输入B:");
b = Convert.ToInt32(Console.ReadLine());
intput:
{
Console.WriteLine("B>A");
Console.Read();
}
if (a >= b)
{
Console.WriteLine("A>B");
Console.Read();
}
else
{
goto intput;
}
11;;类的继承及重写等:
//Car类
namespace ConsoleApplication2
{
class Car
{
public int wheels;
protected float weight;
public Car(int w, float g)
{
wheels = w;
weight = g;
}
public void Info()
{
Console.WriteLine("我有{0}个车轮",wheels);
Console.WriteLine("我的重量是{0}",weight);
}
public void Speak()
{
Console.WriteLine("我能加速");
}
}
}
//MyCar类
namespace ConsoleApplication2
{
class MyCar:Car
{
int people;
public MyCar(int w, float g, int p) : base(w, g) //从基类累中仿造出一辆车
//base:关键字用于从派生类中访问基类的成员:
//调用基类上已被其他方法重写的方法。
//指定创建派生类实例时应调用的基类构造函数
{
wheels = w;
weight = g;
people = p;
}
public void Info()//对原有父类中的Info函数进行重写:注意其函数名及函数类型等都需一致
{
Console.WriteLine("我有{0}个车轮",wheels);
Console.WriteLine("我的重量是:{0}",weight);
Console.WriteLine("我可以做{0}个人:",people);
}
public void Speak()
{
Console.WriteLine("我能够加速");
}
}
}
//输出:
namespace ConsoleApplication2
{
class Program
{
static void Main(string[] args)
{
//对Car进行的操作
Car myCar = new Car(4, 2000);
myCar.Info();
myCar.Speak();
Console.Write("/n");
Console.Write("/n");
//对MyCar进行操作
MyCar zhoucar = new MyCar(4,3000,10);
zhoucar.Info();
zhoucar.Speak();
Console.ReadLine();
}
}
}
12;;构造函数和析构函数
class C4
{
//构造函数特点:函数名和类名一样;没有构造函数时会自动为其创建;大多数情况下为Public型,如是private则不能被实例化,通常用于只含有静态成员的类中;无需声明放回类型;构造函数可以带参数,也可不带;r如下:
public C4()
{
}
public C4(int a, string str)
{
}
//析构函数:用来小会程序占用的资源,它和构造函数的名字相同,但是析构函数须在函数名潜在 ~号,其特点有:不能带参数及访问限制符;名字是类型前加~;不一定必须,在对象销毁时,会自动的调用。如下
~C4()
{
}
}
13;;静态方法
class C5
{
//静态方法和非静态方法,区别:设置时静态前加static访问限制符,静态方法是不能对类的实例进行操作的;不可使用this关键字。
public static string Country()
{
string strCountry = "静态方法的调用";
return strCountry;
}
}
class C6
{
static void Main(string[] args)
{
Console.WriteLine(C5.Country().ToString());
Console.ReadLine();
}
//如下表明,静态的方法,在不同类之间可以直接调用,无需实例化,在不同的文件中也可以。但在同一程序。
}
14;;静态方法
class C7
{
public string country()
{
string strCountry = "非静态方法的示例!";
return strCountry;
}
public string stradd()
{
C8 strc8 = new C8();
string strField = strc8.Cc() + this.country();//可用this代表C7这里类
return strField;
}
}
class C8
{
public string Cc()
{
return ("这是一个");
}
static void Main()
{
C7 strC7 = new C7();//非静态方法,需对该类进行实例化后,方可调用
Console.WriteLine(strC7.stradd().ToString());
Console.ReadLine();
}
}
15;;重载
class C9
{
//重载方法:方法的名称相同,但各个方法的参数的数据类型、顺序和个数不同,编译器会根据参数的差异,自动选择适合的方法,如下:
static double add(double a, double b)
{
Console.WriteLine("计算双精度");
return a + b;
}
static int add(int a, int b)
{
Console.WriteLine("计算整型");
return a + b;
}
static void Main()
{
int a = 1;
int b = 2;
double c = 1.2;
double d = 5.3;
double m = add(c, d);
Console.WriteLine(d);
int e = add(a, b);
Console.WriteLine(e);
Console.ReadLine();
}
}
16;;继承和重写
class C2//如下表明:类里还可以包含类
{
public class baseclass//基类
{
public static int x = 100;//此为静态,则继承类中可直接调用无需实例化
public int y = 200;
public int add(int a, int b)
{
return a + b;
}
}
public class myClass : baseclass//继承类
{
public static int x = 500;//重写,覆盖原有基类中的x,同样需为静态
public static void Main()
{
myClass zhou = new myClass();//对于成员y,需经过实例化,方可使用
Console.WriteLine("输出继承类中的x={0}",myClass.x);//500
Console.WriteLine("输出基类中的x={0}", baseclass.x);//100
Console.WriteLine("输出继承类中的y={0}", zhou.y);//200
Console.WriteLine(zhou.add(5, 6).ToString());
Console.ReadLine();
}
}
}
17;;方法的四种参数是:值参数、引用参数、输出参数、参数数组;
静态方法不对特定实例进行操作,在静态方法中引用this,会导致编译出错;
方法重载是指调用同一方法名,但各方法中参数的个数、顺序、或数据类型不同
析构函数在对象销毁时被调用,常用来释放对象占用的空间。
对象的生命周期以构造函数开始,以析构函数结束。
18;;面向对象三大特点:封装继承多态、
继承的用途:实现代码的重用。
访问限制符:
public: 子类和其他任何类都可以访问
private:子类不能访问该父类的成员
protected:C#提供的一种访问限制符:使其基类可以访问该父类的protected限制的成员,其他类则不可以访问
//继承
public class fuLei
{
public void outMethod()
{
Console.WriteLine("父类");
}
}
public class ziLei : fuLei
{
public void outMethod2()
{
Console.WriteLine("子类");
}
}
public class isMain
{
static void Main(string[] args)
{
fuLei F = new fuLei();
F.outMethod();
ziLei Z = new ziLei();
Z.outMethod();//为子类继承父类的方法
Z.outMethod2();//子类自定义的方法
//输出分别为:父类 父类 子类
}
}
多态:当从父类派生了一些子类后,每个子类都有不同的代码实现,提供程序通用性和代码的重用率
例如:
//多态的表示
public class myInterest
{
public virtual void Interest()//virtual 关键字用于修饰方法、属性、索引器或事件声明,并使它们可以在派生类中被重写。例如,此方法可被任何继承它的类重写
{
Console.WriteLine("我的爱好!");
Console.ReadLine();
}
}
public class write : myInterest
{
public override void Interest()//要扩展或修改继承的方法、属性、索引器或事件的抽象实现或虚实现,必须使用 override 修饰符。
{
Console.WriteLine("写作");
}
}
public class toProgram : myInterest
{
public override void Interest()
{
Console.WriteLine("编程");
}
}
public class sing : myInterest
{
public override void Interest()
{
Console.WriteLine("唱歌");
}
}
public class Program
{
public static void Main(string[] args)
{
myInterest [] Dobj =new myInterest[4];
Dobj[0] = new write();
Dobj[1] = new toProgram();
Dobj[2] = new sing();
Dobj[3]=new myInterest();
foreach (myInterest Obj in Dobj)
{
Obj.Interest();//
//结果为:写作
// 编程
// 唱歌
// 我的爱好
}
}
}
如上是:调用派生类中的重载,实现了多态,如上的思想是从基类中派生三个继承类,重载基类的方法,然后重新调用派生类中的方法,因为每一次重载的功能不一样,所以就实现了多态。