面向对象程序设计(类与对象)

面向对象程序设计


类的概念：
类是对一系列具有相同性质的对象的抽象，是对对象共同特征的描述
类包含属性和方法


对象的概念：
对象就是类的一个实体。


类内部来说是变量，类外部来说叫字段
在定义字段时在没有给访问修饰符的情况下默认为Private
方法里面所有访问权限的成员都可以访问


C#里面的访问修饰符：Public(公共的)，Private(私有的)（默认的），Protect(受保护的),Internal(当前程序集的),
成员的访问修饰权限5种：Public,Private,Protect,Internal,Protect internal
Public：权限最高，类里面，类的对象，类的子类中，其他程序集可以使用
Internal：在当前程序集下的权限如同Public一样，但在其他程序集下是不可以使用的
Protect ：类里面，子类中可以使用，类的对象不能使用，其他程序集的子类中可以访问
Protect internal:在当前程序集的话就相当于public权限，其他程序集的子类中可以使用。（受保护的或当前程序集的）
Private：私有的，只能在类里面访问其他地方都不能访问


类的访问修饰权限有两种：internal(默认的),public


在形参前面加上ref关键字传的是这个变量的引用地址；引用地址传值


参数传值方式有三种：普通值传递，引用地址传值，输出参数


ref与out的区别
ref与out在本质上都是做的地址的传递
ref是将变量的引用地址传给形参，而out是在方法体执行完毕后将形参的引用地址传给实参
ref传值，传给方法的实参要在这之前有值（即有地址）
out传值，在方法体里面，形参变量必须要求有赋值操作（即保证正这个变量有地址往外传）




类中的所有成员都可以加static
加了static的成员是通过类名点出来使用的


静态方法中不能只用非静态成员
非静态方法中可以有静态成员


静态变量，在程序一运行时就会分配内存
实例变量，在实例化这个类的对象时分配内存


重载：
在一个类中出现了多个方法名相同，参数个数或类型不相同的方法
这种方法的定义叫方法的重载
调用方法时，调用匹配普通的重载也匹配带params参数的重载，那么调用的是普通的重载方法

构造函数也是可以重载的

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


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            //类：对一系列具有相同性质的对象的抽象，是对对象共同特征的描述
            //创建这个类的实例
            //这个类的对象
           //Human h = new Human();
           //h.Sex = "男";
           //h.SetInfo();
           //string m= h.SetInfoAndSay("男",190);


           //Console.WriteLine(m);


           //MathF max = new MathF();
          
           // int s=max.Max(10,20,30);


            //将求最大值的操作写到一个方法里
            //体现面向对象编程的封装性
            //提高代码的重用率，加强代码的可维护性


            //int i = 10;
            //int j = 30;
            //MathF m1 = new MathF();
            //int s1 = m1.Sum(i,j);
            //Console.WriteLine(s);
            //int ss = m1.Sum2(ref i, j);
            //Console.WriteLine("i={0},j={1},sum={2}", i, j, ss);
            //m1.Sum3(out i,j);
            //Console.WriteLine("{0}{1}", i, j);


            //参数传值方式有三种：普通值传递，引用地址传值，输出参数
            //ref与out的区别
            //ref与out在本质上都是做的地址的传递
            //ref是将变量的引用地址传给形参，而out是在方法体执行完毕后将形参的引用地址传给实参
            //ref传值，传给方法的实参要在这之前有值（即有地址）
            //out传值，在方法体里面，形参变量必须要求有赋值操作（即保证正这个变量有地址往外传）


            //Console.WriteLine(MyMath.Abs(-10));
            //Student st = new Student("杨坑", "男", 20);
            //st.Show();
            //MathF m=new MathF ();
            //double[] darr = {1,2,3,4,5};
            //double d = m.Sum(10,darr);
            //d = m.Sum(1,2,3,4,5,);
            //调用方法时，调用匹配普通的重载也匹配带params参数的重载，那么调用的是普通的重载方法
           // DateTime dt = new DateTime();///构造函数也是可以重载的


            int n = int.Parse(Console.ReadLine());
            DiGui dd = new DiGui();
            int result= dd.Demo(n);
            Console.WriteLine(result);




        }
    }
    /// <summary>
    /// 人类
    ///类的访问修饰权限有两种：internal(默认的),public
    /// </summary>
    class Human
    {
        //类内部来说是变量，类外部来说叫字段
        //在定义字段时在没有给访问修饰符的情况下默认为Private
        //C#里面的访问修饰符：Public(公共的)，Private(私有的)（默认的），Protect(受保护的),Internal(当前程序集的)
        //成员的访问修饰权限5种：Public,Private,Protect,Internal,Protect internal
        //Public:权限最高，类里面，类的对象，类的子类中，其他程序集也可以使用
        //Internal：在当前程序集下的权限如同Public一样，但在其他程序集下是不可以使用的
        //Protect ：类里面，子类中可以使用，类的对象不能使用，其他程序集的子类中可以使用
        //Protect internal:在当前程序集的话就相当于public权限，其他程序集的子类中可以使用。（受保护的或当前程序集的）
        //Private：私有的，只能在类里面访问其他地方都不能访问
       public string Sex;
       private int Age=0;
       protected internal double Height;
       string country;




        //无返回值
      public void SetInfo()//方法里面所有访问权限的成员都可以访问
       {
           Sex = "男";
           //return; 终止方法的执行，并返回值
           Age = 20;
           Height = 185;
           country = "中国";
       }




        //[访问修符] 返回类型 方法名(参数列表)
       //   {
       //       方法体（要执行的代码）
        //      return 返回的值；
       //   }
         public double GetHeight()
       {
             //方法要求返回一个double的值的话
             //方法体执行中必须要求return double类型值
           if (Height>100)
           {
                return Height;//执行到这里时，方法体中后面的代码不执行


           }
           return 0;
       }
        /// <summary>
        /// 设置信息并返回消息
        /// </summary>
        /// <param name="sex">性别</param>
        /// <param name="height">身高</param>
        /// <returns></returns>
         public string SetInfoAndSay(string sex, double height)
         {
             this.Sex = sex;
             //this当前对象，当前对象的height赋值为传进来的heigh
             this.Height = height;
             string msg = string.Format("My info：性别：{0},身高:{1},国籍:{2}",this.Sex,this.Height,country);
             return msg;


         }


    }
    //写一个数学类
    //Math
    //
    class MathF
    {
    public int Max(int a,int b,int c)
    {
        int max=a;
        if (a<b)
        {
            max = a;
        }
        if (a<c)
        {
            max = c;
        }
        return max;
    }


    public int Min(int a, int b, int c)
    {
        int min = a;
        if (a>b)
        {
            min = b;
        }
         if (a>c)
   {
        min = c;
   }
        return min;
    }
    public int Sum(int a, int b)
    {
        int sum;
        sum = a + b;
        return sum;
    }
    public double Sum(double a, double b)
    {
       return a + b;
    }
    //public double Sum(int a,int b)//返回类型与重载是没有关系的
    //{
    //    return a + b;
    //}


        //重载：在一个类中出现了多个方法名相同，参数个数或类型不相同的方法
        //叫方法的重载


        //public int Sum(out int a,int b)//不是Sum的重载
        //{
        //    return a + b;
        //}
        public void arr(int[] arr)
        {
            for (int i = 0; i < arr.Length; i++)
            {
                arr[i] += 10;
            }
        }


       //params：可变长的数组参数
        //调用数将次形参位置以后传递进来的所有参数看做一个数组
        //params类型的参数必须是参数列表中的最后一个参数


        public double Sum(params double[] arr) 
        {
            double d = 0;
            foreach (double item in arr)
            {
                d += item;
            }
            return d;
        }
        //
        /// <summary>
        /// 在形参前面加上ref关键字传的是这个变量的引用地址；引用地址传值
        /// </summary>
        /// <param name="a"></param>
        /// <param name="b"></param>
        /// <returns></returns>
        public int Sum2(ref int a, int b)
        {
            a += 10;
            return a + b;
        }
        public int Sum3(out int a, int b)
        {
            //out传值就相当于变量在方法体里面定义的(int a)
            //在方法体里必须要先有赋值操作
            a = 10;
            a += 10;
            return a+b;
        }
    }
}

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


namespace ConsoleApplication1
{
    class Student
    {
        //构造函数:一个与类名形同的无返回参数实例化这个对象时自动调用的特殊方法
        //作用：初始化对象
        //
        public string stuName;
        public string sex;
        public int age;




        public Student(string stuName,string sex,int age)
        {
            //stuName = "无语";
            //sex = "男";
            //age = 0;
            this.stuName = stuName;
            this.sex = sex;
            this.age = age;


        }
        public Student(string stuName, string sex)
        {
            this.stuName = stuName;
            this.sex = sex;
        }
        public Student()
        { 
        
        }
        //在我们没有显示写的构造函数的情况下，系统会提供一个默认的构造函数
        //public Student(){}
        //析构函数，在释放对象时自动执行的。C++中用的多
        //C#中一般不用它，GC垃圾回收器
        // ~Student()
        //{ 
        
        //}
        public void Show()
        {
            Console.WriteLine("我的信息：{0}\t{1}\t{2}",stuName,sex,age);
        }


    }
}