c#面向对象1.0（变量分类 作用域 重载）

c# 面向对象1.0（变量分类 作用域 重载）

1.类与对象的基本概念

变量------ 语句------类（属性和方法）----模块

对象是什么

1. 可触及的事务都称之为对象 有静态 和动态特征

类的定义规范

定义类名

关于字段 又称 成员变量 一般在类的内部做数据交互使用 一般用private修饰

字段命名规范：字段命名一般采用camel命名法

字段的通俗理解 ：

私有化：字段就好比个人财产，只供我们自己使用 所以一般是private修饰。

添加标准： 一个类中究竟需要添加几个字段 需要根据程序的编写过程的需要来决定

属性的理解：

1. 属性是外部访问私有字段的入口，属性本身不保存任何数据
2. 给属性赋值，其实就是属性指向的私有字段赋值
3. 读取属性值 其实是获取属性指向的私有字段值或其他值
4. 只读属性没有set方法

字段与属性的对比

字段（成员变量 ）

1. 为类的内部做数据交互使用 ，字段一般都会private 。
2. 字段可以赋值 也可以取值
3. 当字段需要为外部提供数据的时候 ，请将字段封装为属性，而不是使用公有

属性

1. 属性一般是向外提供数据，主要用来描述对象的静态特征 所以属性一般 是public的
2. 属性可以根据需要设置只读 只写 提高数据安全性
3. 属性内部可以添加需要的业务逻辑 从而避免非法数据

方法（实例方法 静态方法）（构造方法 ，抽象方法， 虚方法）

注意事项：

1. 访问修饰符：可以省略，默认private 可以 根据需要定义成public
2. 方法名：一般是动词或者是动宾短语 采用pascal 命名法，首字母大写 不能以数字开头
3. 参数列表：根据需要添加 也可以省略 参数列表要求以 （类型 参数名） 使用，分隔开
4. 有返回值：使用return 返回 return语句后面不能再有其他语句
5. 没有返回值：如果不返回任何数据，使用void表示

变量的分类及其作用域

1. 在方法内部的变量 称为局部变量 只能在该方法内部使用
2. 在方法外部 类的内部定义的变量 成为成员变量

  /// <summary>
    /// 学员类 
    /// </summary>
    internal class Student
    {
        //添加一个字段  学号 
        private int studentId;
        //添加一个姓名 
        private string studentName = string.Empty;
        //字段 年龄
        private int age;
        public int Age
        {
            get { return age; }
            set {
                if (value < 18)
                    age = 18;
                else
                    age = value;   //添加业务逻辑 避免非法数据
                }
        }

       
        //属性 
        public int StudentId
        {
            get { return studentId; }
            set

            { studentId = value; }
        }
            public string StudentName
        {
            get { return studentName; }
            set { studentName = value; }
            
        }
        public string  GetStudent()
        {
            string info = string.Format("姓名：{0}学号：{1}",studentName, studentId);

            return info;

        }


    }
--------------------------------------------------------------------------------------
  internal class Program
    {
        static void Main(string[] args)
        {
            //创建对象
            Student stu = new Student();
            //给对象属性赋值
            stu.StudentId = 1;
            stu.StudentName = "张三";
           string info =  stu.GetStudent();
            Console.WriteLine(info);
            Console.ReadKey();
            Console.WriteLine("Hello, World!");
        }
    }

 internal class Student
    {
        public int StudentId { get; set; }
        public string StudentName { get; set; }    
        public int StudentAge { get; set; }
        public DateTime Birthday { get; set; }
        public int PhoneNumber { get; set; }

        public string GetStudent()
        {
            string info = string.Format("姓名：{0},学号：{1},年龄：{2},手机：{3},", StudentName, StudentId, StudentAge, PhoneNumber);

            return info;
        }
        /// <summary>
        /// 根据输入的学员信息返回详细内容
        /// </summary>
        /// <param name="stuName"></param>
        /// <param name="stuId"></param>
        /// <param name="birthday"></param>
        /// <returns></returns>
        public  string GetStudentInfo(string stuName, int stuId, DateTime birthday)
        {
            this.Birthday = birthday;
            string info = string.Format( "xingming{0} ,xuehao{1},nianling{2}", stuName,stuId, birthday);
            return info;
        }

    }
-----------------------------------------------------------------------------------
     internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
            Student obj = new Student();
            obj.StudentName = "424";
            obj.StudentId = 45;
            obj.StudentAge = 12;
            obj.PhoneNumber = 1212121;

            string str=obj.GetStudent();
            Console.WriteLine(str);
            string str1=obj.GetStudentInfo("san", 12, Convert.ToDateTime("1999-10-02")
                );
            Console.WriteLine(str1);

        }
    }

什么是封装？

1. 是指将一个或若干个小对象封装在一起，然后以一个新的完整的对象呈现
2. 作用：封装使得一个对象的内部特征变得隐蔽 从而更加的安全
3. 类封装： 类是最小的程序单元 是 对属性 方法的封装
4. 模块封装：类可以被封装成模块，组成更大的程序组件

重载：

    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Hello, World!");
            Calculator cal = new Calculator();
            double res = cal.Sub(12.3, 3.2);
            Console.WriteLine(res);
            
        }
    }
-------------------------------------------------------
     internal class Calculator
    {
        public int Add(int a , int b)
        {
            return a + b;
        }
        public double Add(double a ,double b)
        {
            return (double)a + b;
        }
        public int Sub(int a , int b)
        {
            return a - b;

        }
        public double Sub(double a ,double b)
        {
            return (double)a - b;
        }
    }

方法重载的好处

1. 减少类的对外接口（只显示一个方法）
2. 便于用户使用（相同功能的方法名称一样）和识别

方法重载的条件

1. 方法的名称必须一样
2. 方法的参数个数或者类型不一样

方法重载的无关性

1. 方法重载与返回值无关