C# 方法

最新推荐文章于 2024-11-12 11:55:35 发布
最新推荐文章于 2024-11-12 11:55:35 发布
阅读量298 收藏 5
点赞数 5
文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_74918341/article/details/140831894
版权

方法的定义与调用

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)
        {
            //方法:函数
            //就是把一系列相关的代码组织(封装)到一起,用于执行一系列的任务的代码块
            //一个方法分为两部分: 1. 方法的定义(声明)   2.方法的调用(执行)
​
            //Math.Max();
​
            //2.方法的调用:在方法的名字后面添加()  ()称之为执行运算符
            Console.WriteLine(1);
            Test();
            Console.WriteLine(2);
            Test();
            Test();
​
​
            //练习:封装一个方法,在控制台输入10次吴亦凡
​
            //特定的功能:输出10次吴亦凡
            MyWrite();
            MyWrite();
            MyWrite();
           // 在控制台打印13次吴亦凡;
        }
​
        //1.方法的定义, 一个方法一般情况下,写在一个类中
​
        /*
         * 格式: 访问修饰符  返回值类型 方法的名字 (参数列表){
         *  这个方法的代码块
         * }
         * 
         * 
         * 访问修饰符: public  """暂且先记住这一个"""
         * 返回值类型: void  没有返回值
         * 方法的名字 :自定义,一个以大驼峰命名(见名知意)
         */
​
​
        //方法在声明之后,会发现无法再Main中使用,因为Main是静态方法,Test不是静态方法,所以两个方法之间是不互通的,只能把Test修饰成静态方法
        //注意!!!! 不是所有的方法都需要static关键字修饰成静态方法
        //''''暂且''''' 在所有的方法上添加static关键字(后续详解)
        public static void Test()
        {
            Console.WriteLine("我在C#中学习到的第一个方法");
        }
​
        public static void MyWrite()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("吴亦凡");
            }
        }
​
​
    }
}
​

方法的参数

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)
        {
            //上个课件中的练习:方法的功能十分的单一
            //如果我们需要输出13次吴亦凡,就需要再次封装一个方法
​
            //这两个需求的功能是相似的,我们就可以通过传递参数,来控制一个方法做出不同的功能
​
            //参数: 形参和实参
            //形参: 形式参数,方法在定义的时候,声明在()里面的变量,这个形参的值由实参决定
            //实参: 实际参数,方法在调用的时候,写在()中的数据,这个数据将会赋值给对应的形参
            Test(1);
            MyWrite1();
            MyWrite2(1);
            MyWrite3(2, "罗志祥");
            MyWrite3(5, "李云迪");
            MyWrite4(6, "李云迪");
            MyWrite4(6);
​
​
            int c = 5;
            string s = "aaaa";
​
​
            //传递参数的时候,不仅可以直接写数据,也可以写一个变量,会自动将变量的值传递给形参
            MyWrite4(c, s);
        }
        public static void Test(int x)
        {
            Console.WriteLine(x);
        }
        //原始方法  1.0
        //功能:打印10次吴亦凡
        public static void MyWrite1()
        {
            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine("吴亦凡");
            }
        }
​
        //2.0 打印任意次数的吴亦凡
        public static void MyWrite2(int count)
        {
            for (int i = 0; i < count; i++)
            {
                Console.WriteLine("吴亦凡");
            }
        }
        //3.0 打印任意次数 任意内容
​
        public static void MyWrite3(int count,string name)
        {
            for (int i = 0; i < count; i++)
            {
                Console.WriteLine(name);
            }
        }
​
        //4.0版本  如果传入内容, 则打印传入的内容,如果不传入内容,则打印默认值"劣迹明星"
​
        //方法在定义的时候,可以给形参设置一个默认值,当方法调用的时候,如果没有传递参数,则使用这个默认值(这个参数是可选参数)
​
        //注意:可选参数必须写在必选参数的后面
​
        //比如: f(int a,int b)  √ 两个都是可选参数
              //f(int a,int b=666) √ 可选参数在必选参数的后面
              //f(int a=888,int b=666) √ 两个参数都是可选参数
              //f(int a=888,int b) X 可选参数,不能设置在必选参数的前面
        public static void MyWrite4(int count, string name="劣迹明星")
        {
            
            for (int i = 0; i < count; i++)
            {
                Console.WriteLine(name);
            }
        }
​
​
        //注意:1.形参的类型和实参的类型要保持一致
             //2.形参的个数和实参的个数也要保持一致
​
    }
}
​

方法参数的赋值

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace _05_方法参数的赋值
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //值类型
            //方法调用的时候,如果传入的是变量,或者是表达式,都会先进行计算,然后再传递
            //也就是说,方法调用传递变量,传递过去的是这个变量的值,而不是变量本身
            Test1(10);
            Test1(5 + 5);
​
            int z = 10;
            Test1(z);
            Console.WriteLine($"z=={z}");
​
​
            //原理:
            int c = 2;
            int b = c;
            b = 20;
            Console.WriteLine($"c=={c}");
​
​
​
            //引用类型
​
            //当给方法传递一个引用类型的时候,传递的也是这个变量的值
            //只不过引用类型的变量存储的数据的内存地址,所以传递进去的也是内存地址,相当于两个地方操作的是一个内存地址,一个改变,另一个也会发生改变
​
            People p1= new People() { Name="吴亦凡"};
            Test2(p1);
            Console.WriteLine(p1.Name);//李云迪
​
            //原理:
            People p2 = new People() { Name = "吴亦凡" };
            People p3 = p2;
            p3.Name = "李云迪";
            Console.WriteLine(p2.Name);
​
​
        }
        public static void Test1(int x)
        {
            Console.WriteLine($"传入的参数为{x}");
            x = 20;
​
        }
        public static void Test2(People p)
        {
            Console.WriteLine($"传入的参数p.name为{p.Name}");
            p.Name = "李云迪";
​
        }
    }
    class People
    {
        public string Name;
    }
}
​

引用传参

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)
        {
            //方法传递参数有两种方案:
            //值传递:(值参数):方法默认的传递方式,这种方式调用方法,会在方法执行的时候,声明一个新的变量接收一个参数,实参的值会赋值给这个新的变量,当我们传递的数据类型不同的时候,也会出现不同的效果
            //当传递的是一个值类型的数据的时候,方法内部修改形参,不会影响外部,当传递的是一个引用类型的数据的时候,方法内部修改形参,会影响外部
​
​
            //引用传递(引用传参):当传递一个基本数据类型的时候,方法内部修改形参,会影响外部
            //当方法内部需要修改传递进来的变量的时候,就需要使用引用传递
​
            int x = 88888;
            //使用引用传递的时候,传递变量就是传递的这个变量本身,而不是变量里面保存的值
​
            Test(ref x);//传递参数的时候,必须加上ref关键字
            Console.WriteLine("x:"+x);
​
​
            //需求:定义一个函数,交换a和b的值
            int a = 6666;
            int b = 7777;
​
            Huan(ref a, ref b);
            Console.WriteLine(a);
            Console.WriteLine(b);
​
​
/*
 * 总结:
 * 方法内部修改形参的时候,外部是否会收到影响
 * 
 * 
 * 1. 看方法内部是怎么样改的 如果是  形参=xxx 外部不会受到影响
 *                         如果是  形参.xxx=xxxx 外部受影响
 * 2. 如果使用的是引用传递(ref) 内部使用 形参=xxx 外部也会受到影响
​
 */
​
        }
        //给方法的某个形参的前面加上ref关键字,这个参数就将进行引用传递(直接传递变量本身)
        public static void Test( ref int a)
        {
            Console.WriteLine("参数"+a);
            a = 9999;
        }
        public static void Huan( ref int x,ref int y)
        {
            (x, y) = (y, x);
        }
    }
}
​

方法的返回值

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace _07_方法的返回值
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //Math.Max(10, 20);
​
            //有些方法的功能仅仅用于输入工作,调试工作
            //有些方法的功能以计算为主要目标,一般在方法执行结束后,获取结果
​
            
         string str  =  Test();
         Console.WriteLine(str);
​
​
            //需求:定义一个函数,传入两个参数,返回两个参数的和
​
            int a = 100;
            int b = 200;
            Console.WriteLine(Sum(a,b));
​
        }
        //方法通过返回值将方法内部计算的结果返回给调用的地方
        //需要在定义方法的位置,指定方法的返回值类型,如果没有返回值 写void
        public static string Test()
        {
            //Console.WriteLine("吴亦凡");
            //注意:方法标注了返回值类型,那么这个方法内部就必须要返回对应类型的数据
            return "吴亦凡123";
        }
        public static int Sum(int x,int y)
        {
            //return 关键字不仅可以用于返回数据,还可以用于终止方法的执行
            //return 关键字后面的代码不会执行
            return x + y;
           // Console.WriteLine(x+y);
        }
        
    }
}
​

out输出参数

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace _08_out输出参数
{
    internal class Program
    {
        static void Main(string[] args)
        {
​
            //ref 输入关键字
            //out 输出关键字
            //return 关键字用于返回方法执行的结果,但是只能返回一个数据,如果需要同时返回多个数据到调用的时候,就可以使用输出关键字
            int a = 1;
            int b = 2;
            Test1(ref a, ref b);
            Console.WriteLine($"a=={a},b=={b}");
​
            int c;
            int d;
            Test2(out c, out d);
            Console.WriteLine($"c=={c},d=={d}");
            
​
            /*
             * out和ref的区别
             * 1.out传递参数,可以不同赋值
             * 2.out传递的参数,在方法中必须赋值
             * 3.ref传递参数,可以在方法中获取值,out传递参数,只能在赋值之后取值(out不能传递进去数据)
             * 
             * 
             * ref 的主要作用是为了传入数据,因此传入的时候必须进行赋值
             * out的主要作用是为了传出数据,因此在传入的的时候可以不进行初始化.并且在方法中必须赋值
             */
​
        }
        public static void Test1(ref int x ,ref int y)
        {
            Console.WriteLine($"Test1方法中x:{x}y:{y}");
            x = 30;
            y = 40;
        }
        public static void Test2(out int x, out int y)
        {
            x = 30;
            y = 40;
            Console.WriteLine($"Test2方法中x:{x}y:{y}");
        }
    }
}
​

参数列表

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace _09_参数列表
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //一个方法除了可以接收固定个数的参数外,还可以接收未知数量的参数
            Sum(10,20,20,5);
​
            Console.WriteLine(Sum(101,20, 5));
            Test(1, "a", "d", "a");
        }
​
        //参数列表的格式 : params 数据类型[] 参数的名字
        public static int Sum(params int[] nums)
        {
            int sum = 0;    
            //获取参数的长度,就是参数的个数
            Console.WriteLine(nums.Length);//3
            //索引 获取参数列表的某一个值  索引从0开始  0 表示获取第一个值 1表示获取第二个值....
            //Console.WriteLine(nums[0]);
            //Console.WriteLine(nums[1]);
            //Console.WriteLine(nums[2]);
            //Console.WriteLine(nums[3]);
​
            for (int i = 0; i < nums.Length; i++)
            {
                Console.WriteLine(nums[i]);
                // sum = sum + nums[i];
                sum += nums[i];
            }
            return sum;
​
        }
        public static void Test(int a,string s,params string[] str)
        {
​
        }
    }
}
   
​

作用域

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
​
namespace _10_作用域
{
    internal class Program
    {
        static void Main(string[] args)
        {
            //作用域: 就是一个变量可以使用的范围
            //局部作用域:声明的变量仅仅能在某个代码块中使用
            int a = 6666;
​
            Console.WriteLine(a);
        }
​
​
​
        public static void Test() {
            // Console.WriteLine(a);
            int b = 10;
            Console.WriteLine(b);
​
​
            {
                Console.WriteLine(b);
                int c = 20;
            }
            //Console.WriteLine(c);
​
            for (int i = 0; i < 10; i++)
            {
​
            }
​
        }
    }
}

晴天羽翼
关注
C#方法的定义
torino999的博客
05-18 3418
C#方法的定义一、方法的定义。语法：访问修饰符 修饰符 返回值类型 方法名（参数列表）{语句块} 1、访问修饰符 [1] Public：公有的，是类型和类型成员的访问修饰符。对其访问没有限制。[2] Internal：内部的，是类型和类型成员的访问修饰符。同一个程序集中的所有类都 可以访问。[3] Private：私有的，是一个成员访问修饰符。只有在声明它们的类和结构中才可以访问。[4] Protected：受保护的，是一个成员访问修饰符。只能在它的类和它的派生类中访问。[5] protected ..
C#方法的递归
weixin_49756833的博客
02-24 6541
1.函数递归：递归的本质就是自己调用自己。 2.递归的定义：递归本身就是一个循环。 3.递归的思想：越来越接近已知值。 4.递归的总结：1）通过自己调用自己吧复杂的逻辑简单化，可以求得最终结果； 2）递归要有开始条件，也要有一个结束条件； 3）有一种递归的逻辑运算。 1.递归假设是有结束条件的，就一定不会发生栈内存溢出错误吗 假设这个结束条件是对的，是合法的，递归有时...
C# 方法重载
钢铁男儿
06-22 3402
**方法重载 概念：方法的重载指的是方法的名称相同，但是参数不同。 参数不同，分为两种情况： 1）如果参数的个数相同，那么参数的类型就不能够相同。 2） 如果参数的类型相同，那么参数的个数就不能相同。 **方法的重载跟返回值没有关系。 using System; namespace 方法重载 { class Program { static void Main(string[] args) { Console.WriteLine(1)
C#方法（函数）精讲
路虽远，行则必至！
06-06 6124
一、方法（函数）的概念 函数就是将一堆代码进行重用的一种机制。函数就是一段代码，这段代码可能有输入的值（参数），可能会返回值。一个函数就像一个专门做这件事的人，我们调用它来做一些事情，它可能需要我们提供一些数据给它，它执行完成后可能会有一些执行结果给我们。要求的数据叫做参数，返回的执行结果就是返回值。 有了函数，我们在写代码的时候就像拼积木，C#中的各种各样的技术其实就是通过for、if等这些基础的语法，将不同的函数按照一定的逻辑组织起来。 二、关于方法（函数）的一些补充知识 为什么叫方法和函数呢？ 指某
C#方法的定义和调用
荒唐的博客
12-04 7089
一个方法是把一些相关的语句组织在一起，用来执行一个任务的语句块。每一个 C# 程序至少有一个带有 Main 方法的类。 定义方法 调用方法 递归方法调用 参数传递 （一）定义方法 /*C#定义方法的语法： <Access Specifier> <Return Type> <Method Name>(Parameter List) { Method Body }*/ public int FindMax(int num1, int num2)
C# 方法重写
奋斗的菇凉的博客
01-17 4302
为什么需要重写 为了选择性复用，解决父类所定义方法在子类中不适用（虚方法），或父类没有实现(抽象方法)，这样的方法子类可以重写。 方法重写有三种重写的方法 虚方法重写 重写方法重写 抽象方法重写 abstract 方法：在子类必须重写，除非子类也是抽象类 virtual 方法：在子类可以重写，父类方法的做法与子类不同 override方法：已经重写过的方法，在子类还可以继续重写，除非...
C#异步方法
weixin_50179860的博客
04-28 6547
async关键字和await是配套使用的异步方法语法糖，配合Task类可以使多线程变得有序， 也可以自己实现一套协程功能。 async关键字（异步方法） async关键字是C#特有的。Java没有这玩意。 async在C#世界里是上下文关键字。它只有在修饰一个方法的时候才自动被编译器识别为 关键字，在代码的其他位置上可以被用作变量名等其他任何用途。 asyn关键字用来修饰两类方法：lambda表达式或则异步方法。 就如上⾯这个⽅法ExampleMethodAsync()，微软爷爷特别喜欢在定义异步函数名字
C# 方法拦截器
lishuangquan1987的博客
05-20 6150
https://www.cnblogs.com/lwhkdash/p/6728611.html
C#之扩展方法
热门推荐
weixin_39520967的博客
01-24 1万+
通常，我们想要向一个类型中添加方法，可以通过以下两种方式： 修改源代码。 在派生类中定义新的方法。 但是以上方法并不是万能的，我们并不能保证拥有一个类型的源码，也并不能保证这个类型可以让我们继承（如结构，枚举，String等等）。但是C#提供了一个办法，那就是扩展方法，使用扩展方法可以直接向现有的类型“添加”方法，无需修改类型的源码，也无需用一个派生类实现方法。 一、什么是扩展方法？ 扩展方法使你能够向现有类型“添加”方法，而无需创建新的派生类型、重新编译或以其他方式修改原始类型。 二、扩展方法结构
JavaScript调用C#方法
ezreal_pan的博客
02-21 6368
最近在做winform的项目，遇到了很多麻烦的事情，涉及到透明控件，圆角控件等界面渲染总是比较麻烦，重绘，自定义控件，而且发现好像这一块用的人已经不多了，想起之前的有过的想法用html来实现界面渲染，是以，再继续研究研究这一方面的知识。 首先要设置类的COM属性，使其为真。还要设置ObjectForScripting这个属性。案例如下： //为了使网页能够与winform交互 将com的可...
C#方法中的ref参数
weixin_45721187的博客
10-20 1525
能够将一个变量带入一个方法中进行改变，改变完成后，再将改变后的值带出方法。ref参数要求在方法外必须为其赋值，而方法内可以不赋值。
C#方法重写
你的小甜甜的博客
06-15 1267
什么是方法重写? 在一个项目中,子类中的一个方法想要与父类中的一个方法名称相同,但是子类中方法的逻辑不同与父类中方法的逻辑,在这里我们就可以使用方法重写 方法重写的前提是:父类方法必须是抽象方法或虚拟 虚拟方法: ...
每日一题——第一百二十一题
weixin_45778846的博客
11-07 1291
【代码】每日一题——第一百二十一题。
C#画图板代码
xioayanran123的博客
11-12 261
这种方法对于简单的绘图应用是可行的，但它并不是最佳实践，因为它会导致闪烁和性能问题，并且绘制的图形在窗体大小调整或最小化后不会保留。对于更复杂的绘图应用，建议使用双缓冲技术，并在窗体的Paint事件中绘制图形。此外，你还可以考虑将绘制的图形保存在一个集合中，以便在窗体重新绘制时能够恢复它们。下面是一个简单的C#画图板示例代码，它使用WindowsForms来创建一个基本的绘图应用程序。如果没有，请添加一个，并调整其属性以匹配上述说明。2. 打开你的项目，并在Form1的设计视图中添加一个Panel控件。
windows C#-创建记录类型(上)
苏洛的博客
11-12 440
记录是使用基于值的相等性的类型。 C# 10 添加了 record structs，以便你可以将记录定义为值类型。 两个记录类型的变量在它们的类型和值都相同时，它们是相等的。 两个类类型的变量如果引用的对象属于同一类类型并且引用相同的对象，则这两个变量是相等的。 基于值的相等性意味着可能需要的记录类型中的其他功能。 声明 record 而不是 class 时，编译器将生成许多这些成员。 编译器针对 record struct 类型生成这些相同的方法。
SCAU 编译原理 实验二 语法分析
csdn3043663729的博客
11-08 194
输入单词串，以“#”结束，如果是文法正确的句子，则输出成功信息，打印“suc-cess”，否则输出“error”。利用C语言编制递归下降分析程序，并对简单语言进行语法分析。(7)<因子)：：= IDI NUMI(<表达式>)(6)<项)：：=<因子)|*<因子)|/<因子>(5)<表达式)：：=<项)|+<项)|-<项》(1)<程序)：：=begin<语句串>end。(2)<语句串)：：=<语句>|；(4)<赋值语句)：：=ID:=(表达式)(3)<语句)：：=<赋值语句》输出 success。
C# 按字母/汉字排序字符串列表
最新发布
a451319296的博客
11-12 262
通过自定义比较器，List.Sort 方法能够灵活地处理多种排序需求。你可以根据实际的需求，选择适合的比较方式进行排序。上述代码演示了如何实现简单的混合字符串排序，涵盖了数字、字母和汉字的顺序。
C# 软件测试
lvxingzhe3的博客
11-12 756
C# 软件测试
C#的6种常用集合类
weixin_53720617的博客
11-08 605
哈希表是经过优化的，访问下标的对象先散列过。这个泛型方法可以重置数组大小，但是该方法是重新创建新设置大小的数组，用的是旧数组的元素初始化。，HashTable 和 NameValueCollection很类似但是他们还是有区别的，HashTable 的KEY是。一类，在System.Collections.Specialized下。与哈希表类似，区别在于SortedList中的Key数组排好序的。才能访问特定的元素，然而很多时候这样的下标并不是很有用。2.数组要声明元素的类型，集合类的元素类型却是。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值