C#封装性

值传递和引用传递

值传递：不会改变原来的变量，传递参与运算的只是值的副本，基本数据类型（int，float，double，char），都是值传递
引用传递：会改变原来的变量，传递参与运算的是地址的值，类的实例化对象与数组都是引用传递
字符串不是基本数据类型，但是默认为值传递。
out是输出参数,方法的返回值不能输出多个，就可以通过out来实现一个方法输出多个值的功能。

ref和out

ref关键字可以把基本类型数据值传递改为引用传递，引用传递加ref还是引用传递
out是输出参数,方法的返回值不能输出多个，就可以通过out来实现一个方法输出多个值的功能。

/**
 * 
 * 学习面向对象：值类型和引用类型
 * 
 * 规则：1.基本数据类型（int，float，double，char），都是值传递
 *      2.类的实例化对象与数组都是引用传递，引用传递加ref还是引用传递
 *      3.字符串不是基本数据类型，但是默认为值传递
 *      4.out是输出参数,方法的返回值不能输出多个，就可以通过out来实现一个方法输出多个值的功能。
 * 
 * 
 * 
 * 
 * **/
using System;

namespace damo1
{
    class MainClass
    {
        //值类型
        public void AddNumber(int num1)//num为形参
        {
            num1 = num1 + 100;
        }
        //引用类型
        public  void AddNumberWithRef(ref int num1)
        {
            num1 = num1 + 100;
        }
        //引用传递(数组)
        public void AddNumberByArray(int[] intArray)
        {
            intArray[0] = intArray[0] + 100;
        }

        //引用传递（对象）
        public void AddNumberByPerson(person per)
        {
            per.IntHeight = 200;
            per.strName = "李四";
        }

        //延时out关键字应用
        public void  ComputNumber(int intNum1,int intNum2,out int intAddResule,out int intSubReasult)
        {
            intAddResule = intNum1 + intNum2;
            intSubReasult = intNum1 - intNum2;
        }


        public void AddNumberByString( string  str)
        {
            str = str + "大家好";
        }
        public static void Main(string[] args)
        {
            MainClass obj = new MainClass();
            int intTestNum = 10;
           
            //值传递
            obj.AddNumber(intTestNum);//intTestNum为实参，结果为10

            //引用传递
            obj.AddNumberWithRef(ref intTestNum);//结果为110
            
            //数组为引用类型
            int[] intArray = new int[1];
            intArray[0] = 20;
            obj.AddNumberByArray(intArray);//结果为120

            //对象为引用类型
            person perobj = new person();
            obj.AddNumberByPerson(perobj);

            //字符串默认为值传递
            string intstring = "同学们";
            obj.AddNumberByString( intstring);//结果为同学们，可以通过加ref在输入输出前转换为引用传递

            //out关键字应用
            int intAddResult = 0;
            int intSubResult = 0;
            obj.ComputNumber(10,20,out intAddResult,out intSubResult);//结果为30,-10
            Console.WriteLine("{0},{1}",intAddResult,intSubResult);
        }
    }
}

属性

一种简化的方法,主要用于对字段的控制。
考虑到字段的安全性 一般都设置为私有的，但是有时候需要访问字段就可以通过访问属性的方式来访问字段。
类包含
1：数据成员：字段，常量，事件
2：函数成员：方法，属性，构造函数，运算符，索引器

/**
 * 
 * 
 * 定义属性
 * 属性的使用范围
 * 属性对字段的控制
 * 
 * 
 * 
 * 
 * 
 * 
 * **/
using System;

namespace damo3
{
    class Sjy
    {
        private int _IntHeight;
        private int _IntWeight;
        public Sjy()
        {
            _IntHeight = 180;
            IntWeight = 80;
        }


        //属性(简化的方法)
        public int Height
        {
            set {
                if (value>20&&value<300)//属性中对字段的控制
                    {
                        _IntHeight = value;
                    }

                }
            get { return _IntHeight; }
        }
        //vs自动生成属性
        public int IntWeight { get => _IntWeight; set => _IntWeight = value; }



        public void DisplayInfo()
        {
            Console.WriteLine("height={0}",_IntHeight);
            Console.WriteLine("weight={0}",IntWeight);
        }
        public static void Main(string[] args)
        {
            Sjy Obj = new Sjy();
            Obj.Height = 200;//赋值属性
            Obj.DisplayInfo();
            Console.WriteLine(Obj.Height);//得到属性
            
        }
    }
}

动态多态性

1.虚方法的动态多态性
2.抽象方法的动态多态性
3.接口方法的动态多态性
动态多态性主要是指声明类和new类不同，这样可以保持原有声明类的属性，在新的类中进行升级完善，优先考虑接口方法

虚方法动态多态性

/**
 * 
 * 动态多态性
 * 
 * 
 * 
 * **/

using System;

namespace damo4
{
    public  class Person
    {
        public virtual void SpeakLanguage()
        {
            Console.WriteLine("说话方法");
        }



        
    }
}
using System;
namespace damo4
{
    public class pang:Person
    {
        public override void SpeakLanguage()
        {
            Console.WriteLine("胖说话");
        }
        public pang()
        {
        }
    }
}

using System;
namespace damo4
{
    public class Sjy:Person 
    {
        public override void SpeakLanguage()
        {
            Console.WriteLine("sjy说话");
        }
        public Sjy()
        {
        }
    }
}

using System;
namespace damo4
{
    public class test
    {
        public test()
        {
        }
        public static void Main(string[] args)
        {
            //动态多态性测试
            //功能声明部分
            Person persjy = new Sjy();//声明父类，new子类
            Person perpang = new pang();//声明父类，new子类，
            //在游戏开发中如果先要升级某些功能，
            //可以直接新建一个类让让其实现升级功能，然后new出来，这要就不用修改太多原本的代码

            //功能的实现部分
            persjy.SpeakLanguage();
            perpang.SpeakLanguage();
            //实现了功能定义和功能实现的脱离，实现代码的进一步灵活性
        }
    }
}

接口多态性

using System;
namespace damo4
{
    interface IPerson
    {
        void SpeakLanguage();
    }
    
    
}


using System;
namespace damo4
{
    public class pang:IPerson
    {
        void IPerson. SpeakLanguage()
        {
            Console.WriteLine("胖说话");
        }
        public pang()
        {
        }
    }
}


using System;
namespace damo4
{
    public class Sjy : IPerson
    {
        void IPerson.SpeakLanguage()
        {
            Console.WriteLine("sjy说话");
        }
        public Sjy()
        {
        }
    }
}




using System;
namespace damo4
{
    public class test
    {
        public test()
        {
        }
        public static void Main(string[] args)
        {
            //使用接口，演示动态多态性（面向接口编程）
            IPerson Ispeaksjy = new Sjy();
            IPerson Ispeakpang = new pang();
            Ispeaksjy.SpeakLanguage();
            Ispeakpang.SpeakLanguage();



        }
    }
}

面向接口编程