C#

铃汐
116 阅读6分钟

C#

1day

  1. console.Write() ==> 打印输出语句
  2. console.ReadKey() ==> 暂停当前的程序，等待用户按下任意键继续，且显示按下的键
  3. vs2019 生成解决方案(F6) ，可以排查下语法错误

2day

  1. //==> 单行注释
  2. /**/==> 多行注释
  3. ///==> 文档注释

3day

  1. VS快捷键

    ctrl + k 然后松开 + d代码自动对齐
    shift + end, shift + home选中一行代码
    ctrl + k 然后松开 + c注释
    ctrl + k 然后松开 + u取消注释
    #region ...... #endRegion折叠冗余代码
    ctrl+shift+enter开启新的代码行
    ctrl+F5运行代码
    ctrl+shift+/注释，再次就取消注释
    alt+方向代码转移
    ctrl+delete删除光标后面的字符

  2. 数据类型

    int整数
    double浮点数
    string字符串
    char字符

  3. C#区分大小写

4day

  1. 占位符

    • 输出顺序按照{}内的标号输出
    • {0:0.00}表示保留两位小数
    class Program
{
    static void Main(string[] args)
    {
        int a = 10;
        int b = 20;
        Console.WriteLine("a = {0},b = {1}",a,b);
        Console.ReadKey();
    }
}

  2. 接受用户的输入

    Console.ReadLine()

    class Program
{
    static void Main(string[] args)
    {
            Console.WriteLine("请输入你的名字：");
            string name = Console.ReadLine();
            Console.WriteLine("你的名字是{0}",name);
            Console.ReadKey();
    }
}

  3. 转义符

    • \n: 表示换行
    • \":表示一个英文半角的双引号
    • \t:表示一个tab键的空格
    • \b:表示一个退格键，放到字符串的两边没有效果
    • \r\n:windows操作系统不认识\n，只认识\r\n
    • \\:表示一个\
    • @符号：
      • 加在“”的前面表示取消\在字符串的转义作用
        • 加在打印字符串的前面表示字符串按照原格式输出

5day

  1. 强制类型转换(string与int、double)

    static void Main(string[] args)
{
    //使用Convert转换
    string s = "123";//若s不为数字就会抛出异常
    int n = Convert.ToInt32(s);// 此步骤等于int.Parse(s); 
    //Convert.ToInt32本质上还是去调用的int.Parse()所以后者的效率更高
    Console.WriteLine(n);
    double d = Convert.ToDouble(s);
    Console.WriteLine(d);
}

  2. int.TryParse()

    static void Main(string[] args)
{
    int number = 0;
    bool b = int.TryParse("123",out number);
    //这里的int.TryParse会尝试着将字符串转化为int类型的，若失败，则返回false，number置位0
    Console.WriteLine(b);
    Console.WriteLine(number);
}

6day

  1. 产生随机数

    static void Main(string[] args)
{
    Random r = new Random();
    int rNumber = 0;
    for (int i = 0; i < 10; i++)
    {
        //参数给定随机数的范围
        rNumber = r.Next(1, 10);//该区间为左闭右开区间
        Console.WriteLine(rNumber);
    }
}

  2. 枚举类型的定义与使用

    namespace _05枚举类型
{
    //枚举一般放在命名空间的里面，类的外面
    //例如性别
    public enum Gender
    {
        male,
        female
    }
    class Program
    {
        static void Main(string[] args)
        {
            Gender sex = Gender.male;
            Console.WriteLine(sex);
        }
    }
}

7day

  1. 数组

    static void Main(string[] args)
{
    //数据类型[] 数据名 = new 数据类型[数组长度];
    int[] num = new int[10];
    for (int i = 0; i < num.Length; i++)
    {
        num[i] = i + 1;
    }

    for (int i = 0; i < num.Length; i++)
    {
        Console.WriteLine(num[i]);
    }
}

  2. 冒泡排序

    static void Main(string[] args)
{
    int[] nums = { 3, 6, 8, 9, 4, 2, 1, 0, 5, 7 };
    int temp = 0;
    for (int i = 0; i < nums.Length-1; i++)//比较的趟数
    {
        for (int j = 0; j < nums.Length-1-i; j++)//要互换的次数
        {
            if(nums[j]>nums[j+1])//如果前面的数比后面的大，则互相交换位置
            {
                temp = nums[j + 1];
                nums[j + 1] = nums[j];
                nums[j] = temp;
            }
        }
    }

    for (int i = 0; i < nums.Length; i++)
    {
        Console.WriteLine(nums[i]);
    }
}

8day

  1. out参数的使用, 在方法中返回多个不同类型的值

    class Program
{
    static void Main(string[] args)
    {
        //用方法计算一个数组的最大值、最小值、和
        int[] nums = { 4, 6, 8, 9, 0 };
        int max = 0;
        int min = 0;
        int sum = 0;
        Test(nums, out max, out min, out sum);
        Console.WriteLine("最大值为{0}，最小值为{1}，总和为{2}", max, min, sum);
    }

    /// <summary>
    /// 用方法计算一个数组的最大值、最小值、和
    /// </summary>
    /// <param name="nums">要参与计算的数组</param>
    /// <param name="max">要传回的最大值</param>
    /// <param name="min">要传回的最小值</param>
    /// <param name="sum">要传回的总和</param>
    public static void Test(int[] nums,out int max,out int min,out int sum)
    {
        max = nums[0];
        min = nums[0];
        sum = 0;
        for (int i = 0; i < nums.Length; i++)
        {
            sum += nums[i];
            if (max < nums[i])
            {
                max = nums[i];
            }
            if (min > nums[i])
            {
                min = nums[i];
            }
        }
    }
}

  2. ref参数的使用，能够将一个变量带入一个方法中进行改变，改变完成后，在将改变的值带出方法

    class Program
{
    static void Main(string[] args)
    {
        //使用方法来交换两个int变量
        int n1 = 10;
        int n2 = 20;
        Test(ref n1,ref n2);
        Console.WriteLine(n1);
        Console.WriteLine(n2);
    }

    public static void Test(ref int a,ref int b)
    {
        int temp = a;
        a = b;
        b = temp;
    }
}

  3. params参数的使用

    将实参列表中跟可变参数数组类型一直的元素都当做数组的元素去处理

    params可变参数必须是形参列表中最后的一个元素

    class Program
{
    static void Main(string[] args)
    {
        //int[] nums = { 22, 44, 76 };
        string name = "zhangsan";
        Test(name, 22, 44, 76);
    }
    //计算总成绩
    public static void Test(string name,params int[] nums)
    {
        int sum = 0;
        for (int i = 0; i < nums.Length; i++)
        {
            sum += nums[i];
        }
        Console.WriteLine("{0}这次考试的总成绩为{1}", name, sum);
    }
}

9day

面向对象-->属性

person类

public class Person
{
    private string _name;//姓名
    private string _gender;//性别
    private int _age;//年龄

    public string Name
    {
        //当你输出属性值的时候会执行get方法
        get { return _name; }
        //当你给属性赋值的时候会执行set方法
        set { _name = value; }
    }

    public string Gender
    {
        get { return _gender; }
        set { _gender = value; }
    }

    public int Age
    {
        //这里对年龄进行了判断，如果年龄不符合要求就会输出0
        get {
            if (_age < 0 || _age >= 100)
            {
                _age = 0;
                return _age;
            }
            return _age; }
        set { _age = value; }
    }
}

main方法进行调用

class Program
{
    static void Main(string[] args)
    {
        Person zc = new Person();
        zc.Name = "张三";
        zc.Gender = "男";
        zc.Age = 20;
        Console.WriteLine("{0}==={1}==={2}",zc.Name,zc.Gender,zc.Age);
    }
}

10 day

析构函数

//当程序结束时 析构函数才会执行
//帮助我们释放资源
//GC  Garbage Collection
~Student()
{
    Console.WriteLine("AZZZ");
}

11day

this的两个作用

  • 表示当前类的对象
  • 调用当前类的构造函数
public person(string name,string gender,int age)
{
    this.Name = name;
    this.Gender = gender;
    this.Age = age;
}
/// <summary>
/// this 的第二个用法,
/// 调用当前类的构造函数
/// </summary>
/// <param name="name"></param>
/// <param name="age"></param>
public person(string name,int age):this(name,"男",age)
{
}

我们可以将字符串看做是char类型的一个只读数组

  • ToCharArray(); 将字符串转化为char数组

  • new string(char[] chs);能够将char数组转化为字符串

    字符串提供的各种方法

  1. Length：获得单签字符串中字符的长度
  2. ToUpper(): 将字符转换成大写的形式
  3. ToLower(): 将字符串转化为小写的形式
  4. Equals(比较的字符串,StringComparison.OrdinaIgnoreCase): 比较两个字符串,忽略大小写
  5. Split(): 分割字符串，返回字符串类型的数组
  6. Substring(): 截取字符串，在截取的时候包含要截取的那个位置。
  7. IndexOf(): 判断某个字符串中第一次出现的位置，如果没有就返回-1
  8. LastIndexOf(): 判断某个字符串中最后一次出现的位置，如果没有就返回-1
  9. StartWith(...): 判断以...为开始
  10. EndWith(...): 判断以...结束
  11. Replace(): 将字符串中的某个字符串替换成一个新的字符串
  12. Contains(): 判断某个字符串中是否包含指定的字符串
  13. Trim(): 去掉字符串中前后的空格
  14. TrimEnd():去掉字符串中结尾的空格
  15. TrimStart():去掉字符串中前面的空格
  16. string.IsNullOrEmpty():判断一个字符串是否为空或者NULL
  17. string.Join(): 将数组按照指定的字符串连接，返回一个字符串

12day

继承

---子类从父类的那边继承过来了些什么？

子类继承了父类的属性和方法，但是子类并没有继承父类的私有字段、

---子类有没有继承父类的构造函数？

子类并没有继承父类的构造函数，但是子类会默认的调用父类的无参的构造函数，

创建了父类的对象，让子类可以使用父类中的成员。

所以，如果在父类中重新写了一个有参的构造函数之后，那个无参数的就被干掉了，子类就调用不到了，左移子类会报错。

解决方式：

  1. 在父类中重新写一个五参数的构造函数=一般不用
  2. 在子类中显示的调用父类的构造函数，使用关键字：base()
public class Program
{
    static void Main(string[] args)
    {
        Student s = new Student("zc",10,666);
        s.pr();      
    }
}

public class Person
{
    private string _name;
    private int _age;

    public string Name
    {
        get { return _name; }
        set { _name = value; }
    }

    public int Age
    {
        get { return _age; }
        set { _age = value; }
    }

    //父类的构造函数
    //默认调用的是这个
    public Person()
    {

    }

    public Person(string name,int age)
    {
        this.Name = name;
        this.Age = age;
    }

    public void pr()
    {
        Console.WriteLine("略略略略略略绿绿绿绿绿绿绿绿绿绿绿绿绿绿绿绿绿");
    }
}

//在子类的后面加上 :类名 表示继承父类
public class Student:Person
{
    private int _id;

    public int Id
    {
        get { return _id; }
        set { _id = value; }
    }

    //在子类中若要调用父类的特殊的构造函数要在后面加上 :Base()
    public Student(string name, int age,int id):base(name,age)
    {
        this.Id = id;
    }
}

new关键字

  1. 创建对象

  2. 隐藏从父类那里继承过来的同名成员

    隐藏的后果就是子类调用不到父类的成员。

avatar
文章
阅读
粉丝