新浪博客对博文的字数有限制，艾，有些不足啊，否则我何必将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();//
//结果为：写作
// 编程
// 唱歌
// 我的爱好
}
}
}
如上是：调用派生类中的重载，实现了多态，如上的思想是从基类中派生三个继承类，重载基类的方法，然后重新调用派生类中的方法，因为每一次重载的功能不一样，所以就实现了多态。
1605
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
