实习日记-C#

数据类型

字符串常量

string a = "hello, world";                  // hello, world
string b = @"hello, world";               // hello, world
string c = "hello \t world";               // hello     world
string d = @"hello \t world";               // hello \t world
string e = "Joe said \"Hello\" to me";      // Joe said "Hello" to me
string f = @"Joe said ""Hello"" to me";   // Joe said "Hello" to me
string g = "\\\\server\\share\\file.txt";   // \\server\share\file.txt
string h = @"\\server\share\file.txt";      // \\server\share\file.txt
string i = "one\r\ntwo\r\nthree";
string j = @"one

访问修饰符

定义一个类成员的范围和可见性

public：所有对象都可以访问；
private：对象本身在对象内部可以访问；
protected：只有该类对象及其子类对象可以访问
internal：同一个程序集的对象可以访问；
protected internal：访问限于当前程序集或派生自包含类的类型。

按引用传递参数

引用参数是一个对变量的内存位置的引用。ref关键字声明引用参数。

using System;
namespace CalculatorApplication
{class NumberManipulator{public void swap(ref int x, ref int y){int temp;temp = x; /* 保存 x 的值 */x = y;    /* 把 y 赋值给 x */y = temp; /* 把 temp 赋值给 y */}static void Main(string[] args){NumberManipulator n = new NumberManipulator();/* 局部变量定义 */int a = 100;int b = 200;Console.WriteLine("在交换之前，a 的值： {0}", a);Console.WriteLine("在交换之前，b 的值： {0}", b);/* 调用函数来交换值 */n.swap(ref a, ref b);Console.WriteLine("在交换之后，a 的值： {0}", a);Console.WriteLine("在交换之后，b 的值： {0}", b);Console.ReadLine();}}
}

C#可空类型

C# 提供了一个特殊的数据类型，nullable 类型（可空类型），可空类型可以表示其基础值类型正常范围内的值，再加上一个 null 值。

例如，Nullable< Int32 >，读作"可空的 Int32"，可以被赋值为 -2,147,483,648 到 2,147,483,647 之间的任意值，也可以被赋值为 null 值。类似的，Nullable< bool > 变量可以被赋值为 true 或 false 或 null。

在处理数据库和其他包含可能未赋值的元素的数据类型时，将 null 赋值给数值类型或布尔型的功能特别有用。例如，数据库中的布尔型字段可以存储值 true 或 false，或者，该字段也可以未定义。

using System;
namespace CalculatorApplication
{class NullablesAtShow{static void Main(string[] args){int? num1 = null;int? num2 = 45;double? num3 = new double?();double? num4 = 3.14157;bool? boolval = new bool?();// 显示值Console.WriteLine("显示可空类型的值： {0}, {1}, {2}, {3}",num1, num2, num3, num4);Console.WriteLine("一个可空的布尔值： {0}", boolval);Console.ReadLine();}}
}

输出

显示可空类型的值： , 45,  , 3.14157
一个可空的布尔值：

C#中的构造函数

using System;
namespace LineApplication
{class Line{private double length;   // 线条的长度public Line(){Console.WriteLine("对象已创建");}/*public Line(double len)  // 参数化构造函数{Console.WriteLine("对象已创建，length = {0}", len);length = len;}*/public void setLength( double len ){length = len;}public double getLength(){return length;}static void Main(string[] args){Line line = new Line();    // 设置线条长度line.setLength(6.0);Console.WriteLine("线条的长度： {0}", line.getLength());Console.ReadKey();}}
}对象已创建
线条的长度： 6

C#中的析构函数

格式：~ 类名()
{}
调用时间：结束程序（比如关闭文件，释放内存等）之前释放资源。析构函数不能继承或重载

在这里插入代码片

C#类的静态成员

static关键字把类成员定义为静态的。当我们声明一个类成员为静态时，意味着无论有多少个类的对象被创建，只会有一个该静态成员的副本。
关键字static意味着类中只有一个该成员的实例

using System;
namespace StaticVarApplication
{class StaticVar{public static int num;public void count(){num++;}public int getNum(){return num;}}class StaticTester{static void Main(string[] args){StaticVar s1 = new StaticVar();StaticVar s2 = new StaticVar();s1.count();s1.count();s1.count();s2.count();s2.count();s2.count();        Console.WriteLine("s1 的变量 num： {0}", s1.getNum());Console.WriteLine("s2 的变量 num： {0}", s2.getNum());Console.ReadKey();}}
}

执行结果

s1 的变量 num： 6
s2 的变量 num： 6

static修饰的成员函数，只能访问静态变量，且静态函数再对象被创建之前就已经存在

using System;
namespace StaticVarApplication
{class StaticVar{public static int num;public void count(){num++;}public static int getNum(){return num;}}class StaticTester{static void Main(string[] args){StaticVar s = new StaticVar();s.count();s.count();s.count();                  Console.WriteLine("变量 num： {0}", StaticVar.getNum());Console.ReadKey();}}
}

结果：

变量 num： 3

C#继承

新类称为派生类，被继承的类称为基类
创建派生类的语法如下：
<访问修饰符> class <基类>
{

}
class <派生类> : <基类>
{

}

 class Shape{public void setWidth(int w){width = w;}public void setHeight(int h){height = h;}protected int width;protected int height;}// 派生类class Rectangle: Shape{public int getArea(){return (width * height);}}class RectangleTester{static void Main(string[] args){Rectangle Rect = new Rectangle();Rect.setWidth(5);Rect.setHeight(7);// 打印对象的面积Console.WriteLine("总面积： {0}",  Rect.getArea());Console.ReadKey();}}

多重继承：一个类可以从多个父类继承行为与特征
C#不支持多重继承，但是可以使用接口来实现多重继承

using System;
namespace InheritanceApplication
{class Shape{public void setWidth(int w){width = w;}public void setHeight(int h){height = h;}protected int width;protected int height;}// 基类 PaintCostpublic interface PaintCost{int getCost(int area);}// 派生类class Rectangle : Shape, PaintCost{public int getArea(){return (width * height);}public int getCost(int area){return area * 70;}}class RectangleTester{static void Main(string[] args){Rectangle Rect = new Rectangle();int area;Rect.setWidth(5);Rect.setHeight(7);area = Rect.getArea();// 打印对象的面积Console.WriteLine("总面积： {0}",  Rect.getArea());Console.WriteLine("油漆总成本： ${0}" , Rect.getCost(area));Console.ReadKey();}}
}

C#多态性

多态是同一个行为具有多个不同表现形式或形态的能力
“一个接口，多个功能”
多态就是同一个接口，使用不同的实例而执行不同操作

静态多态性

• 函数重载
• 运算符重载

函数重载

using System;
namespace PolymorphismApplication
{public class TestData  {  public int Add(int a, int b, int c)  {  return a + b + c;  }  public int Add(int a, int b)  {  return a + b;  }  }  class Program  {  static void Main(string[] args)  {  TestData dataClass = new TestData();int add1 = dataClass.Add(1, 2);  int add2 = dataClass.Add(1, 2, 3);Console.WriteLine("add1 :" + add1);Console.WriteLine("add2 :" + add2);  }  }  
}

 class Printdata{void print(int i){Console.WriteLine("输出整型: {0}", i );}void print(double f){Console.WriteLine("输出浮点型: {0}" , f);}void print(string s){Console.WriteLine("输出字符串: {0}", s);}static void Main(string[] args){Printdata p = new Printdata();// 调用 print 来打印整数p.print(1);// 调用 print 来打印浮点数p.print(1.23);// 调用 print 来打印字符串p.print("Hello Runoob");Console.ReadKey();}}

动态多态性

使用关键字abstract创建抽象类，用于提供接口的部分类的实现。抽象类包含抽象方法，抽象方法可被派生类实现，派生类具有更专业的技能