【第六天】06c#今日小结

原创已于 2025-12-09 19:15:37 修改 · 212 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#c# #开发语言

于 2025-12-09 19:14:02 首次发布

1.方法语法

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _01方法语法
{
    internal class Program
    {
        static void Main(string[] args)
        {

            //方法：把一些相关的代码封装在一个代码块里面，可以代码块添加一个名称，这个名称就是方法，可以通过调用这个方法名实现功能，方法可以重复调用，减少代码重复率

            //方法语法：public static/非静态  void/非void  方法名字 (参数列表){}
            // public :修饰符，一般方法都是定义成公共
            // static(静态)/不写（非静态） : 静态方法找类名.方法名()，非静态方法对象.方法名()
            // void/非void： void 无返回值的，只是功能的实现 ，没有结果， 非void：有返回值的方法
            // 方法名字 大驼峰的命名方法 DoWorking
            // (参数列表) ：参数列表
            // {}： 方法体


            //方法的调用
            //静态方法找类名.方法名()，非静态方法对象.方法名()


            //先定义 再调用
            //调用 本类里面可以省去对象或者类名
            Program.Test1();//等待方法执行完之后 才会继续执行
           




            Console.ReadLine();
        }

        //方法定义在类Program里面 
        // 目前就定义成static
        public static  void Test1()
        {
            Console.WriteLine("我是一个无静态、返回值 、无参数的方法的");
            for (int i = 0; i < 1000; i++)
            {
                Console.WriteLine("张三很帅");
            }
        }

    }



}

方法：把一些相关的代码封装在一个代码块里面，可以代码块添加一个名称，这个名称就是方法，可以通过调用这个方法名实现功能，方法可以重复调用，减少代码重复率。

方法语法：public static/非静态 void/非void 方法名字 (参数列表){}

public :修饰符，一般方法都是定义成公共

static(静态)/不写（非静态） : 静态方法找类名.方法名()，非静态方法对象.方法名()

void/非void： void 无返回值的，只是功能的实现，没有结果，非void：有返回值的方法

方法名字大驼峰的命名方法 DoWorking

参数列表) ：参数列表

{}：方法体

2.参数列表

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _02参数列表
{
    internal class Program
    {


        static void Main(string[] args)
        {

             //方法的参数:可以通过在调用时候通过实参把值传递方法中的形参，保证形参的值随着实参的值进行变化，达到方法的兼容性的效果
            //实参：有具体值的变量 int a = 10
           //形参:形式上参数，没有具体值 只能把实参赋值给形参 例如方法定义参数列表(int a ,int b)

            Test1(10,"征服");//调用的时候根据按照定义参数列表以及顺序进行传递实参

            Console.WriteLine(new String('+',100));// 重复字符100遍
            Console.WriteLine("++++++++++++++++++++++");//


            int count = 100;//实参
            string info = "临时抱佛脚";//实参
            Test1(count, info); //参数也可以是变量

            //调用默认值参数的方法Test2
        
            Test2(18, "张三"); // 默认值不用写 sex="男"
            Test2(30, "小美", "女"); //传递了默认参数 sex=传递的



            Console.ReadKey();
        }
        //定义带俩个参数的方法 整型count 字符串类型的info
        // 要求 根据用户提供个数唱多少局征服
        //count 次数  info:内容
        static void Test1(int count,string info)
        {
            for (int i = 0; i < count; i++)
            {
                Console.WriteLine("唱:"+ info);
            }
        }
        // 方法注释
        // 默认值参数，如果不传参数sex="男" 如果传了参sex=你传递的， 默认值参数一定写在最后
        /// <summary>
        /// 统计学生姓名 年龄 性别的方法，
        /// </summary>
        /// <param name="age">年龄</param>
        /// <param name="name">姓名</param>
        /// <param name="sex">性别.默认参数值="男"</param>
       static void Test2(int age ,string name,string sex="男")
        {
            Console.WriteLine("我的姓名是:"+name+"年龄是:"+age+"性别:"+sex);
        }


    }
}

方法的参数:可以通过在调用时候通过实参把值传递方法中的形参，保证形参的值随着实参的值进行变化，达到方法的兼容性的效果。

3.方法参数赋值的问题

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _03方法参数赋值的问题
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //C#是面向对象的编程语言，面向对象语言的三个基本特征:封装 继承 多态
           
            int a = 10;
            int b = 20;
            char c = '*';
            Sum(a, c, b);//调用完方法之后 把实参值赋值给形参

            //a,b 以及 num1 num2关系
            //方法实参和形参中间会有赋值的过程， 即num1 = a  num2 = b  fuhao = c,, 目前abc都属于值类型
            //值类型在赋值的过程当中 相当于把输入拷贝一份，备份一份传递过去，修改拷贝的一份不会影响另一个

            //原理等同下面赋值
            //int a1 = 10;
            //int b1 = a1;
            //a1 = 30;
            //Console.WriteLine(b1);

            Console.WriteLine(a+"-------"+b);// 10 20




            Console.ReadKey();
        }

        //俩个数字运算的方法。传递三个参数 数字1 运算符号，数字2 ，不带返回值
        static void Sum(int num1,char fuhao,int num2)
        {
            Console.WriteLine(num1+"----"+num2);//
            num1 = 30; //修改num1
            num2 = 40; // 修改num2
            if (fuhao=='+')
            {
                Console.WriteLine("{0}+{1}={2}",num1,num2,num1+num2);
            }
            else if (fuhao == '-')
            {
                Console.WriteLine("{0}-{1}={2}", num1, num2, num1-num2);
            }
            else if (fuhao == '*')
            {
                Console.WriteLine("{0}*{1}={2}", num1, num2, num1 * num2);
            }
            else if (fuhao == '/')
            {
                Console.WriteLine("{0}/{1}={2}", num1, num2, num1 / num2);
            }
            else
            {
                Console.WriteLine("输入的运算符号不正确");
            }
        }

    }

   
}

4.方法参数赋值引用类型的形参

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _04方法参数赋值引用类型的形参
{
    internal class Program
    {
        static void Main(string[] args)
        {

            

            // 引用类型赋值(对象描述这个问题) 对象怎么来 ：类创建对象的通用方法 类名 对象名 = new 类名();
            // 引用类型变量存储的是内存地址，把内存地址赋值给另一个变量，俩个变量的内存地址是一样的，这俩个变量都是指向同一个数据，修改其一另外一个会跟着变换
            //1 普通变量的赋值场景:
            Girl  g1 = new Girl();
            g1.Name = "炮娘";
            Girl  g2 = g1; //把g1赋值给 g2
            g1.Name = "提莫";
            Console.WriteLine(g2.Name);//提莫
            Console.WriteLine(g1.Name);//提莫


            //2 方法 实参和形参传递的过程
            Girl g3 = new Girl();
            g3.Name = "冰女";
            //调用方法的时候出现引用类型的赋值，a=g3
            Test1(g3);//方法的实参和形参类型一致
            Console.WriteLine(g3.Name +"------------------------");// 都是修改之后的



            Console.ReadKey();

        }

        //参数不再是一个基本类型 而是对象类型
        static void Test1(Girl a)
        {
            a.Name = "女警";
            Console.WriteLine(a.Name+"0000000000000000000000");
        }
    }

    //定义类
    class Girl
    {
        public string Name; //添加成员
    }


    /*
     * 值类型：值类型在赋值的过程当中 相当于把输入拷贝一份，备份一份传递过去，修改拷贝的一份不会影响另一个
     *   1 普通变量的赋值场景:
     *  
         int a1 = 10;
          int b1 = a1;
          a1 = 30;
        Console.WriteLine(b1); // b1不会受影响10=
     *   
     *   
     *   2 方法实参和形参传递的过程
     *   int b = 50
     *   Test(b)
     *   Console.WriteLine(b) 50
     *   void Test（int a){ a  = 30; 函数内部修改}
     *   
     * 
     * 
     * 引用类型  ：引用类型变量存储的是内存地址，把内存地址赋值给另一个变量，俩个变量的内存地址是一样的，这俩个变量都是指向同一个数据，修改其一另外一个会跟着变换
     *   1 普通变量的赋值场景:
     *   
            Girl  g1 = new Girl();
            g1.Name = "炮娘";
            Girl  g2 = g1; //把g1赋值给 g2
            g1.Name = "提莫";
            Console.WriteLine(g2.Name);//提莫
            Console.WriteLine(g1.Name);//提莫

     *   
     *   
     *   2 方法实参和形参传递的过程
     *   
     *   
     *      Girl g3 = new Girl();
            g3.Name = "冰女";
            Test1(g3);
            Console.WriteLine(g3.Name +"------------------------");// 都是修改之后的 女警
           
     *   
     *    static void Test1(Girl a) {  a.Name = "女警"; }
     * 
     */





}

值类型：值类型在赋值的过程当中相当于把输入拷贝一份，备份一份传递过去，修改拷贝的一份不会影响另一个

引用类型：引用类型变量存储的是内存地址，把内存地址赋值给另一个变量，俩个变量的内存地址是一样的，这俩个变量都是指向同一个数据，修改其一另外一个会跟着变换

引用类型赋值(对象描述这个问题) 对象怎么来：类创建对象的通用方法类名对象名 = new 类名();

引用类型变量存储的是内存地址，把内存地址赋值给另一个变量，俩个变量的内存地址是一样的，这俩个变量都是指向同一个数据，修改其一另外一个会跟着变换

5.ref参数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _05ref参数
{
    internal class Program
    {
        static void Main(string[] args)
        {
           
            int a = 10;
            Test1(a);
            Console.WriteLine(a); //10


            int a1 = 20;
            Test1(a1);
            Console.WriteLine(a1);//20


            //以上实参是值类型的时候，在方法内部修改形参，不会影响到实参

            //要求 能不能实现修改形参达到修改实参的目的
            //例如 要求上面Console.WriteLine(a1) 是方法内部修改之后的值


            //ref参数的使用
            //1定义方法的给参数添加ref关键字 static void Test2(int a ,ref int b){}

            //2 调用带ref参数的方法
            // Test2(10,ref 20); ref后面只能跟变量 不能具体的值
            //ref:添加的目的其实就是想把参数改成引用类型的参数,实现在方法内部进
            //行修改的，达到修改实参的目的
            //使用ref需要注意1ref后面只能跟变量 不能具体的值
            //注意2：使用ref的必须给其一个初始值
            int a3=10;
            Test2(10, ref a3);
            Console.WriteLine(a3);//40 


            Console.ReadKey();
        }
        //定义带有ref参数的方法
        static void Test2(int a ,ref int b)
        {
            b = 40;
            //Console.WriteLine("a的值为{0};ref b的值为{1}",a,b);
        }

        static void Test1(int a)
        {
            a = 999;
            Console.WriteLine("a的值为:" + a); //9999
        }
    }

  
}

6.具有返回值的函数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace _06具有返回值的函数
{
    internal class Program
    {
        static void Main(string[] args)
        {
         // 有返回值的方法把void 该成想要的类型 例如想返回一个字符串类型 把void改成string类型
         // 返回值的好处 可以其他地方使用这个结果，可以使用一个变量接收这个方法
            int sum =  Sum(10, 20);
            //此处用到和 直接就用sum就行
            Console.WriteLine(sum*100);



            //先定义方法 再main进行调用
            int 被三整除总和 = Sum1();
            Console.WriteLine(被三整除总和);



            //——----------调用Drink方法----------------
           int n1 =  Drink();
           Console.WriteLine(n1);

            //————调用第二种逻辑 完美-------------
            Drink3(364);// 364瓶能够喝多少
            Drink3(500);// 500瓶能够喝多少
            Drink3(10);// 


            Console.ReadKey();

        }

        //9.3个可乐瓶可以换一瓶可乐，现在有364瓶可乐。问一共可以喝多少瓶可乐，剩下几个空瓶。
        //返回喝多少可乐
        static int Drink()
        {
            // 空瓶的总数是变化
            int num = 364;// 目前把所有可乐喝完之后 空瓶的数量
            int coke = 0;//剩余的空瓶
            int drink = 364;// 目前喝的可乐数
            while (num >=3) //当空瓶数量超过3的时候，去换可乐
            {
                num = (num + coke) / 3;//能喝多少瓶  （拿目前空瓶+剩余空瓶）/3 
                coke  = (num +coke ) % 3 ; // 剩余多少
                drink = drink + num;//总共喝多少瓶  
            }
            Console.WriteLine("总共能喝"+ drink+";剩余:"+ (coke+ num)+"瓶");

            return drink;
        }

        //.3个可乐瓶可以换一瓶可乐，现在有364瓶可乐。问一共可以喝多少瓶可乐，剩下几个空瓶。
        // 364 可以变化的数
        //方法带参数

        static void  Drink3(int count)
        {
            int num = count; // 剩余的总瓶
            int drink = count; // 喝的个数
            while(num>=3)
            {
                drink += num / 3;
                num = num/3 + num%3; //   num/3  有多少瓶可乐 产生多个瓶子;  num%3 剩余的瓶子   num是剩余总瓶子
            }
            Console.WriteLine("总共能喝" + drink + ";剩余:" +  num + "瓶");
        }

        //定义俩个数字相加的方法 目的得到方法的结果在其他地方使用
        //必须有关键字rteturn ，return后面的一定和返回类型保持一致
        static int Sum (int a,int b)
        {

           
            return a + b;


        }
        //定义一个方法计算0-100之间被3整除的和
        //静态  有返回值的 Sum1 不带参数
        //方法语法：public static/非静态  void/非void  方法名字 (参数列表){}
        static int Sum1()
        {
            int s = 0;
            for (int i = 0; i < 101; i++)
            {
                if (i % 3 == 0)
                {
                    s += i;
                }
            }

            return  s;
        }


    }
}






/* 方法定义：public static void/类型 方法名（int a，int b，Girl c，string name = "小丑"）{}
 * 
 *方法 调用:方法名(10,19,new Girl());
 * 方法名(10,19,new Girl(),"hello");  
 * 
 * ref参数
 *  ref:添加的目的其实就是想把参数改成引用类型的参数,实现在方法内部进行修改的，达到修改实参的目的
 使用ref需要注意1 ref后面只能跟变量 不能具体的值
 注意2：使用ref的必须给其一个初始值
 * 
 *
 * 
 * 
 * 
 * 
 */

有返回值的方法把void 该成想要的类型例如想返回一个字符串类型把void改成string类型

返回值的好处可以其他地方使用这个结果，可以使用一个变量接收这个方法