c#学习第三天

标签：内存   赋值   end   mon   就是   比较   false   情况下   pytho   

1.常量：
声明常量的方法：
const 常量（注意要大写）//赋值号左边必须是变量,而常量不能被重新赋值
/*不想被改变得的量一般设为常量*/
2.枚举
1).语法：
[pubic] enum 枚举名
{

值1,
值2,
值3,
.......

}
public:访问修饰符，可有可无
enum:枚举方法
2).枚举意义
为了解决项目之间定义的差别，多个人一起玩，需要统一要玩东西的名字
比如：性别
char gender ="男";
string s1="men";
string s2="female";
/*枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用*/
/*本质为变量,所谓多重变量*/
--应用举例 例如
public enum Gender
{
男,
女
}
static void Main(string[] args)
{
int n=10;
Gender gender=Gender.男;

}
3).类型转换：
（1）--枚举类型和int类型相互转换（两种类型兼容）
int n=(int)"男";//返回值为0（枚举类型默认从0开始）哈哈，类似double
（2）--与字符串转换
int n1=1;
Gender gender=Gender.n1;//返回值为"女"
/*所有类型都可以调用ToString方法转换为字符串,但字符串不能直接转换为枚举类型*/
（3）--调用Parse()方法
Gender n=(Gender)Enum.Parse(typeof(Gender),s);//将s转换为Gender类型，并用n接受
/*如果枚举中没用类似s，则会抛异常（按照老方法try--catch--语句）*/
3.结构
可以帮助我们一次性声明多个不同类型变量
public struct Person
{
public string _name;/*只有结构中才能加，但是现在变为字段，并非变量，可以存放
多个值,变量只能存放一个值
一般要求规范加下划线来与变量分别*/
public int _age;
public char _gender;
}
//和python中数组类似,----但完全不同
Person ara;//事实上这里只声明了一个变量ara，使其类型属于结构
ara._name="ara";
ara._age=20;
ara._gender="man";
4.数组
可以帮助我们一次性存放多个相同类型的变量（数据）//与python中数组好类似
语法：
1)数字的数组定义
int[] nums=new int[10];
/*要注意，c#中先定义数组长度（即开辟出内存空间），
嗯----先建立整体，要内存有一定道理，符合c家族的一贯作风
数组中每个变量都为数组中元素，且初值为0
想要访问每个元素，需要对元素对应的序号操作（序号从零开始，哈哈，和python类似）
*/
//通过循环赋值,注意不能赋值的多了
for (int i=0;i<nums.length;i++);
{
nums[i]=i;

}
//当然也可以通过循环取值
for (int i=0;i<nums.length;i++);
{
Console.WriteLine(nums[i]);
}
2)字符串（初值为null，就是没有开辟空间）和布尔类型（初值为false）数组定义
3)数组的声明方式
int[] nums={1,2,3}
int[] nums=new int[3]{1,2,3}
//练习：从一个整数数组中取出最大整数和最小的整数
//声明一个iny类型的数组，并且随意赋初值
int nums={1,2,3,4,5,6,7,8,8,9}//定义数组
int max=nums[0];//声明变量存储最大值(还可以写为int max=int.MinValue(将整数类型表示的最小值赋给max))原来还有这样的函数啊
int mon=num[0];//声明变量存储最小值
int sum=ave=0;
for (int i=0;i<nums.length;i++);
{
if(nums[i]>max)
{
max=nums[i];
}
if (nums[i]>min)
{
min=nums[i];
}
sum+=nums[i];
ave=sum/nums.length;
}
Console.WriteLine("数组中最大值为{0}，最小值为{1},总和为{2}，平均值为{3}"，max,min,sum,ave);
Consolo.ReadKey();
//练习：将名字用“｜”分割
string[] names={"老杨","老苏"};
string str=null;
for (int i=0;i<names.length-1;i++)
{
str+=names[i]+"|"
}
Console.WriteLine(str+names[names.length-1]);
Console.ReadKey();
5.冒泡排序
将一个数组中的元素按照从小到大或从大到小的顺序进行排列
int[] nums={122,,22,33,23,2,34,54,1223}
//将第一个元素与后面的每一个元素进行比较
//排序专门方法Array.Sort(nums)(只能升序排列)
//Array.Reverse(nums);
for (int i=0;i<nums.length;i++)
{
for (int j=0;j<nums.length-1-i;j++)
{
if (nums[j]>nums[j+1])
{
int temp =nums[j];
nums[j]=nums[j+1];
nums[j+1]=nums[j];
}
}
}
for (int i=0;i<nums.length;i++)
{
Console.WriteLine(nums[i])
}
Console.ReadKey();
6.方法
public static 返回值类型 方法名([参数列表])
{
方法体;
}
public:访问修饰符，公开的，公共的
static:静态的
返回值类型：如果没有，写void（即不需要变量接收，但可以换行）
方法名：psical,所有单词首字母大写，其余小写
参数列表：所需条件,如果没有,小括号必须写
return:立即结束本次方法，返回要返回的值
*如果想要被执行，必须在Main()函数中执行
*调用时[类型 变量=类名.方法名([参数列表])]
*调用一个未知的函数,打一个括号,会显示应该输入的条件
***在某些情况下，类名可以省略，在相同类下
//举例
public static int GetMax(int n1,int n2)
{
return n1>n2?n1:n2;

}
int a=program.GetMax(1,3);

1.常量：
声明常量的方法：
const 常量（注意要大写）//赋值号左边必须是变量,而常量不能被重新赋值
/*不想被改变得的量一般设为常量*/
2.枚举
1).语法：
[pubic] enum 枚举名
{

值1,
值2,
值3,
.......

}
public:访问修饰符，可有可无
enum:枚举方法
2).枚举意义
为了解决项目之间定义的差别，多个人一起玩，需要统一要玩东西的名字
比如：性别
char gender ="男";
string s1="men";
string s2="female";
/*枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用*/
/*本质为变量,所谓多重变量*/
--应用举例 例如
public enum Gender
{
男,
女
}
static void Main(string[] args)
{
int n=10;
Gender gender=Gender.男;

}
3).类型转换：
（1）--枚举类型和int类型相互转换（两种类型兼容）
int n=(int)"男";//返回值为0（枚举类型默认从0开始）哈哈，类似double
（2）--与字符串转换
int n1=1;
Gender gender=Gender.n1;//返回值为"女"
/*所有类型都可以调用ToString方法转换为字符串,但字符串不能直接转换为枚举类型*/
（3）--调用Parse()方法
Gender n=(Gender)Enum.Parse(typeof(Gender),s);//将s转换为Gender类型，并用n接受
/*如果枚举中没用类似s，则会抛异常（按照老方法try--catch--语句）*/
3.结构
可以帮助我们一次性声明多个不同类型变量
public struct Person
{
public string _name;/*只有结构中才能加，但是现在变为字段，并非变量，可以存放
多个值,变量只能存放一个值
一般要求规范加下划线来与变量分别*/
public int _age;
public char _gender;
}
//和python中数组类似,----但完全不同
Person ara;//事实上这里只声明了一个变量ara，使其类型属于结构
ara._name="ara";
ara._age=20;
ara._gender="man";
4.数组
可以帮助我们一次性存放多个相同类型的变量（数据）//与python中数组好类似
语法：
1)数字的数组定义
int[] nums=new int[10];
/*要注意，c#中先定义数组长度（即开辟出内存空间），
嗯----先建立整体，要内存有一定道理，符合c家族的一贯作风
数组中每个变量都为数组中元素，且初值为0
想要访问每个元素，需要对元素对应的序号操作（序号从零开始，哈哈，和python类似）
*/
//通过循环赋值,注意不能赋值的多了
for (int i=0;i<nums.length;i++);
{
nums[i]=i;

}
//当然也可以通过循环取值
for (int i=0;i<nums.length;i++);
{
Console.WriteLine(nums[i]);
}
2)字符串（初值为null，就是没有开辟空间）和布尔类型（初值为false）数组定义
3)数组的声明方式
int[] nums={1,2,3}
int[] nums=new int[3]{1,2,3}
//练习：从一个整数数组中取出最大整数和最小的整数
//声明一个iny类型的数组，并且随意赋初值
int nums={1,2,3,4,5,6,7,8,8,9}//定义数组
int max=nums[0];//声明变量存储最大值(还可以写为int max=int.MinValue(将整数类型表示的最小值赋给max))原来还有这样的函数啊
int mon=num[0];//声明变量存储最小值
int sum=ave=0;
for (int i=0;i<nums.length;i++);
{
if(nums[i]>max)
{
max=nums[i];
}
if (nums[i]>min)
{
min=nums[i];
}
sum+=nums[i];
ave=sum/nums.length;
}
Console.WriteLine("数组中最大值为{0}，最小值为{1},总和为{2}，平均值为{3}"，max,min,sum,ave);
Consolo.ReadKey();
//练习：将名字用“｜”分割
string[] names={"老杨","老苏"};
string str=null;
for (int i=0;i<names.length-1;i++)
{
str+=names[i]+"|"
}
Console.WriteLine(str+names[names.length-1]);
Console.ReadKey();
5.冒泡排序
将一个数组中的元素按照从小到大或从大到小的顺序进行排列
int[] nums={122,,22,33,23,2,34,54,1223}
//将第一个元素与后面的每一个元素进行比较
//排序专门方法Array.Sort(nums)(只能升序排列)
//Array.Reverse(nums);
for (int i=0;i<nums.length;i++)
{
for (int j=0;j<nums.length-1-i;j++)
{
if (nums[j]>nums[j+1])
{
int temp =nums[j];
nums[j]=nums[j+1];
nums[j+1]=nums[j];
}
}
}
for (int i=0;i<nums.length;i++)
{
Console.WriteLine(nums[i])
}
Console.ReadKey();
6.方法
public static 返回值类型 方法名([参数列表])
{
方法体;
}
public:访问修饰符，公开的，公共的
static:静态的
返回值类型：如果没有，写void（即不需要变量接收，但可以换行）
方法名：psical,所有单词首字母大写，其余小写
参数列表：所需条件,如果没有,小括号必须写
return:立即结束本次方法，返回要返回的值
*如果想要被执行，必须在Main()函数中执行
*调用时[类型 变量=类名.方法名([参数列表])]
*调用一个未知的函数,打一个括号,会显示应该输入的条件
***在某些情况下，类名可以省略，在相同类下
//举例
public static int GetMax(int n1,int n2)
{
return n1>n2?n1:n2;

}
int a=program.GetMax(1,3);

1.常量：
声明常量的方法：
const 常量（注意要大写）//赋值号左边必须是变量,而常量不能被重新赋值
/*不想被改变得的量一般设为常量*/
2.枚举
1).语法：
[pubic] enum 枚举名
{

值1,
值2,
值3,
.......

}
public:访问修饰符，可有可无
enum:枚举方法
2).枚举意义
为了解决项目之间定义的差别，多个人一起玩，需要统一要玩东西的名字
比如：性别
char gender ="男";
string s1="men";
string s2="female";
/*枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用*/
/*本质为变量,所谓多重变量*/
--应用举例 例如
public enum Gender
{
男,
女
}
static void Main(string[] args)
{
int n=10;
Gender gender=Gender.男;

}
3).类型转换：
（1）--枚举类型和int类型相互转换（两种类型兼容）
int n=(int)"男";//返回值为0（枚举类型默认从0开始）哈哈，类似double
（2）--与字符串转换
int n1=1;
Gender gender=Gender.n1;//返回值为"女"
/*所有类型都可以调用ToString方法转换为字符串,但字符串不能直接转换为枚举类型*/
（3）--调用Parse()方法
Gender n=(Gender)Enum.Parse(typeof(Gender),s);//将s转换为Gender类型，并用n接受
/*如果枚举中没用类似s，则会抛异常（按照老方法try--catch--语句）*/
3.结构
可以帮助我们一次性声明多个不同类型变量
public struct Person
{
public string _name;/*只有结构中才能加，但是现在变为字段，并非变量，可以存放
多个值,变量只能存放一个值
一般要求规范加下划线来与变量分别*/
public int _age;
public char _gender;
}
//和python中数组类似,----但完全不同
Person ara;//事实上这里只声明了一个变量ara，使其类型属于结构
ara._name="ara";
ara._age=20;
ara._gender="man";
4.数组
可以帮助我们一次性存放多个相同类型的变量（数据）//与python中数组好类似
语法：
1)数字的数组定义
int[] nums=new int[10];
/*要注意，c#中先定义数组长度（即开辟出内存空间），
嗯----先建立整体，要内存有一定道理，符合c家族的一贯作风
数组中每个变量都为数组中元素，且初值为0
想要访问每个元素，需要对元素对应的序号操作（序号从零开始，哈哈，和python类似）
*/
//通过循环赋值,注意不能赋值的多了
for (int i=0;i<nums.length;i++);
{
nums[i]=i;

}
//当然也可以通过循环取值
for (int i=0;i<nums.length;i++);
{
Console.WriteLine(nums[i]);
}
2)字符串（初值为null，就是没有开辟空间）和布尔类型（初值为false）数组定义
3)数组的声明方式
int[] nums={1,2,3}
int[] nums=new int[3]{1,2,3}
//练习：从一个整数数组中取出最大整数和最小的整数
//声明一个iny类型的数组，并且随意赋初值
int nums={1,2,3,4,5,6,7,8,8,9}//定义数组
int max=nums[0];//声明变量存储最大值(还可以写为int max=int.MinValue(将整数类型表示的最小值赋给max))原来还有这样的函数啊
int mon=num[0];//声明变量存储最小值
int sum=ave=0;
for (int i=0;i<nums.length;i++);
{
if(nums[i]>max)
{
max=nums[i];
}
if (nums[i]>min)
{
min=nums[i];
}
sum+=nums[i];
ave=sum/nums.length;
}
Console.WriteLine("数组中最大值为{0}，最小值为{1},总和为{2}，平均值为{3}"，max,min,sum,ave);
Consolo.ReadKey();
//练习：将名字用“｜”分割
string[] names={"老杨","老苏"};
string str=null;
for (int i=0;i<names.length-1;i++)
{
str+=names[i]+"|"
}
Console.WriteLine(str+names[names.length-1]);
Console.ReadKey();
5.冒泡排序
将一个数组中的元素按照从小到大或从大到小的顺序进行排列
int[] nums={122,,22,33,23,2,34,54,1223}
//将第一个元素与后面的每一个元素进行比较
//排序专门方法Array.Sort(nums)(只能升序排列)
//Array.Reverse(nums);
for (int i=0;i<nums.length;i++)
{
for (int j=0;j<nums.length-1-i;j++)
{
if (nums[j]>nums[j+1])
{
int temp =nums[j];
nums[j]=nums[j+1];
nums[j+1]=nums[j];
}
}
}
for (int i=0;i<nums.length;i++)
{
Console.WriteLine(nums[i])
}
Console.ReadKey();
6.方法
public static 返回值类型 方法名([参数列表])
{
方法体;
}
public:访问修饰符，公开的，公共的
static:静态的
返回值类型：如果没有，写void（即不需要变量接收，但可以换行）
方法名：psical,所有单词首字母大写，其余小写
参数列表：所需条件,如果没有,小括号必须写
return:立即结束本次方法，返回要返回的值
*如果想要被执行，必须在Main()函数中执行
*调用时[类型 变量=类名.方法名([参数列表])]
*调用一个未知的函数,打一个括号,会显示应该输入的条件
***在某些情况下，类名可以省略，在相同类下
//举例
public static int GetMax(int n1,int n2)
{
return n1>n2?n1:n2;

}
int a=program.GetMax(1,3);

1.常量：
声明常量的方法：
const 常量（注意要大写）//赋值号左边必须是变量,而常量不能被重新赋值
/*不想被改变得的量一般设为常量*/
2.枚举
1).语法：
[pubic] enum 枚举名
{

值1,
值2,
值3,
.......

}
public:访问修饰符，可有可无
enum:枚举方法
2).枚举意义
为了解决项目之间定义的差别，多个人一起玩，需要统一要玩东西的名字
比如：性别
char gender ="男";
string s1="men";
string s2="female";
/*枚举声明到命名空间的下面，类的外面，表示这个命名空间下，所有的类都可以使用*/
/*本质为变量,所谓多重变量*/
--应用举例 例如
public enum Gender
{
男,
女
}
static void Main(string[] args)
{
int n=10;
Gender gender=Gender.男;

}
3).类型转换：
（1）--枚举类型和int类型相互转换（两种类型兼容）
int n=(int)"男";//返回值为0（枚举类型默认从0开始）哈哈，类似double
（2）--与字符串转换
int n1=1;
Gender gender=Gender.n1;//返回值为"女"
/*所有类型都可以调用ToString方法转换为字符串,但字符串不能直接转换为枚举类型*/
（3）--调用Parse()方法
Gender n=(Gender)Enum.Parse(typeof(Gender),s);//将s转换为Gender类型，并用n接受
/*如果枚举中没用类似s，则会抛异常（按照老方法try--catch--语句）*/
3.结构
可以帮助我们一次性声明多个不同类型变量
public struct Person
{
public string _name;/*只有结构中才能加，但是现在变为字段，并非变量，可以存放
多个值,变量只能存放一个值
一般要求规范加下划线来与变量分别*/
public int _age;
public char _gender;
}
//和python中数组类似,----但完全不同
Person ara;//事实上这里只声明了一个变量ara，使其类型属于结构
ara._name="ara";
ara._age=20;
ara._gender="man";
4.数组
可以帮助我们一次性存放多个相同类型的变量（数据）//与python中数组好类似
语法：
1)数字的数组定义
int[] nums=new int[10];
/*要注意，c#中先定义数组长度（即开辟出内存空间），
嗯----先建立整体，要内存有一定道理，符合c家族的一贯作风
数组中每个变量都为数组中元素，且初值为0
想要访问每个元素，需要对元素对应的序号操作（序号从零开始，哈哈，和python类似）
*/
//通过循环赋值,注意不能赋值的多了
for (int i=0;i<nums.length;i++);
{
nums[i]=i;

}
//当然也可以通过循环取值
for (int i=0;i<nums.length;i++);
{
Console.WriteLine(nums[i]);
}
2)字符串（初值为null，就是没有开辟空间）和布尔类型（初值为false）数组定义
3)数组的声明方式
int[] nums={1,2,3}
int[] nums=new int[3]{1,2,3}
//练习：从一个整数数组中取出最大整数和最小的整数
//声明一个iny类型的数组，并且随意赋初值
int nums={1,2,3,4,5,6,7,8,8,9}//定义数组
int max=nums[0];//声明变量存储最大值(还可以写为int max=int.MinValue(将整数类型表示的最小值赋给max))原来还有这样的函数啊
int mon=num[0];//声明变量存储最小值
int sum=ave=0;
for (int i=0;i<nums.length;i++);
{
if(nums[i]>max)
{
max=nums[i];
}
if (nums[i]>min)
{
min=nums[i];
}
sum+=nums[i];
ave=sum/nums.length;
}
Console.WriteLine("数组中最大值为{0}，最小值为{1},总和为{2}，平均值为{3}"，max,min,sum,ave);
Consolo.ReadKey();
//练习：将名字用“｜”分割
string[] names={"老杨","老苏"};
string str=null;
for (int i=0;i<names.length-1;i++)
{
str+=names[i]+"|"
}
Console.WriteLine(str+names[names.length-1]);
Console.ReadKey();
5.冒泡排序
将一个数组中的元素按照从小到大或从大到小的顺序进行排列
int[] nums={122,,22,33,23,2,34,54,1223}
//将第一个元素与后面的每一个元素进行比较
//排序专门方法Array.Sort(nums)(只能升序排列)
//Array.Reverse(nums);
for (int i=0;i<nums.length;i++)
{
for (int j=0;j<nums.length-1-i;j++)
{
if (nums[j]>nums[j+1])
{
int temp =nums[j];
nums[j]=nums[j+1];
nums[j+1]=nums[j];
}
}
}
for (int i=0;i<nums.length;i++)
{
Console.WriteLine(nums[i])
}
Console.ReadKey();
6.方法
public static 返回值类型 方法名([参数列表])
{
方法体;
}
public:访问修饰符，公开的，公共的
static:静态的
返回值类型：如果没有，写void（即不需要变量接收，但可以换行）
方法名：psical,所有单词首字母大写，其余小写
参数列表：所需条件,如果没有,小括号必须写
return:立即结束本次方法，返回要返回的值
*如果想要被执行，必须在Main()函数中执行
*调用时[类型 变量=类名.方法名([参数列表])]
*调用一个未知的函数,打一个括号,会显示应该输入的条件
***在某些情况下，类名可以省略，在相同类下
//举例
public static int GetMax(int n1,int n2)
{
return n1>n2?n1:n2;

}
int a=program.GetMax(1,3);

c#学习第三天

标签：内存   赋值   end   mon   就是   比较   false   情况下   pytho   

原文地址：https://www.cnblogs.com/Aradear/p/8835355.html