public class 比较大小
{
public static void GetDX()
{
#region 比较大小
//返回结果小于0,小于
//等于0,相等
//大于0，大于
int a = 10;
int b = 12;
Console.WriteLine("{0}与{1}比较的结果返回值是{2}", a, b, a.CompareTo(b));
string s1 = "abc";
string s2 = "ABC";
Console.WriteLine("{0}与{1}比较的结果返回值是{2}", s1, s2, s1.CompareTo(s2));
#endregion
#region 类型推断 var
//使用var声明变量和使用其他类型声明变量使用起来是一样的
//C#中的var与js中的var完全不同,C#中的是强类型的,js中的是var是弱类型
//如下代码,在js中随着赋值的不同,变量a的类型会跟着改变,类型完全取决于=后面的赋值对象,但是C#中不行,在C#中第一次赋值之后就已经确定了变量的类型,后面不能改变
//var a = 123;
//a = "sdfs";
//a = true;
//在C#中var n =100;等效于int n =100
//如果使用反编译可以看到编译器在编译的时候其实就已经将var替换成了对应的类型
//var 只能用作局部变量
//不能用作方法的参数,不能用作类的成员变量,不能用作方法的返回值
#endregion
#region 装箱和拆箱
//值类型转换成引用类型为装箱
//引用类型转换成值类型为拆箱
//装进去的是什么类型,拆出来的也得是什么类型,否则会报错
int n = 10;
object o = n;//装箱
int m = (int)o;//拆箱
//这里发生了三次装箱,一次拆箱
//在创建变量str的时候,是三个部分相连接而成的
//这时候会调用方法Concat方法,这个方法传入的参数为object类型
//所以4和10传入的时候是值类型转换成引用类型,进行了两次装箱
//* 因为是字符串,是引用类型,所以不会发生装箱操作
int n1 = 10;
object o1 = n1;//这里是第一次装箱
string str = 4 + "*" + (int)o1;//(int)o1为一次拆箱
Console.WriteLine(str);
#endregion
#region 装箱和拆箱的性能问题
ArrayList arList = new ArrayList();
Stopwatch wathc = new Stopwatch();
wathc.Start();
for (int i = 0; i < 1000000; i++)
{
//这里参数是object,所以在添加进去的时候每次都会装箱
arList.Add(i);
}
wathc.Stop();
Console.WriteLine(wathc.Elapsed);
List<int> list = new List<int>();
Stopwatch wc = new Stopwatch();
wc.Start();
for (int i = 0; i < 1000000; i++)
{
list.Add(i);
}
wc.Stop();
Console.WriteLine(wc.Elapsed);
#endregion
#region 自定义泛型类
/*泛型实现的是算法重用
* 比如一个要实现一个相加的功能
* 如果不用泛型实现就要根据传入参数类型的不同重载多次
* 而如果使用返现则简单的多
* 传入int,double 等数字类型直接相加运算
* 如果传入字符串就直接拼接到一起
* 算法相同,单实现的效果不同
*
*/
//泛型类
Myfxl<string> myf = new Myfxl<string>();
myf.SayHi("大家好");
//泛型方法
MyFxff myff = new MyFxff();
myff.SayHello<string>("同志们好！首长好！");
Console.ReadKey();
#endregion
}
}
/// <summary>
/// 泛型类
/// </summary>
/// <typeparam name="T"></typeparam>
public class Myfxl<T>
{
public void SayHi(T arg)
{
Console.WriteLine(arg);
}
}
/// <summary>
/// 泛型方法
/// </summary>
public class MyFxff
{
public void SayHello<T>(T meg)
{
Console.WriteLine(meg);
}
}
/// <summary>
/// 泛型接口
/// </summary>
/// <typeparam name="T"></typeparam>
public interface IFlyable<T>
{
T SayHi();
void SayHello(T msg);
}
//实现泛型接口的时候有两种情况
//1普通类实现泛型接口
public class PTL : IFlyable<string>
{
public string SayHi()
{
throw new NotImplementedException();
}
public void SayHello(string msg)
{
throw new NotImplementedException();
}
}
//2泛型类实现泛型接口
public class FXL<U> : IFlyable<U>
{
public U SayHi()
{
throw new NotImplementedException();
}
public void SayHello(U msg)
{
throw new NotImplementedException();
}
}
/// <summary>
/// 泛型类的约束
/// </summary>
/// <typeparam name="T"></typeparam>
public class MyfxlYS<T, K, V, W, X, Y, Z>
where T : struct//约束T必须为值类型
where K : class//约束K必须为引用类型
where V : IComparable//约束V必须实现接口IComparable
where W : K//约束W必须是K或者K的子类
where X : class ,new()//约束class必须为引用类型,并且有一个无参的构造函数,如果约束条件中带有new(),则必须放在最后一个,多个约束条件使用逗号分隔
{
public void SayHi(T arg)
{
Console.WriteLine(arg);
}
}