Lession05 类和对象的高级应用（ref和out关键字、方法重载、访问修饰符、类的静态成员、值类型和引用类型）

lession05 类和对象的高级应用

ref 和 out 关键字

/*
* 值类型数据作为参数，修改形参是不会影响实参
* 而引用类型的数据作为参数，修改形参是可以影响实参的
*
* ref 和 out都是把实参按照引用类型方式传递的
* 区别：传递到ref的参数必须最先初始化，而out的参数在传递之前不需要初始化，需要在方法返回之前赋值
* ref重在修改参数的数据，out重在带回执行结果
*/

using System;

namespace 类和对象的高级应用
{
    class Program
    {
        static void Main(string[] args)
        {
            //ref关键字
            int val = 0;
            M1(ref val);
            Console.WriteLine("val的值是{0}", val);
            //out关键字

            int val2;
            M2(out val2);
            Console.WriteLine("val2的值是{0}", val2);
            Console.WriteLine("-----------------------------------------------");
            int n1= 10;
            int n2 = 20;
            Console.WriteLine("交换前两个数值分别是{0},{1}", n1, n2);
            swap(ref n1, ref n2);
            Console.WriteLine("交换后两个数值分别是{0},{1}", n1, n2);


            Console.ReadKey();
        }

        private static void swap(ref int n1, ref int n2)
        {
            int temp;
            temp = n1;
            n1 = n2;
            n2 = temp;
        }

        private static void M2(out int i)
        {
            i= 45;
        }

        private static void M1(ref int i)
        {
            i = 44;
        }
    }
}

方法的重载

/*
* 概念：方法的重载就是方法的名称相同，参数不同
* 参数不同分两种：
* 1.如果参数的个数相同，那么参数的类型就不能相同
* 2.如果参数的类型相同，那么参数的个数就不能相同
* 注意：
* 方法的重载跟它的返回值类型没有关系
*
*/

using System;

namespace 方法重载
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(1);
            Console.WriteLine(3.14);
            Console.WriteLine(true);
            Console.WriteLine('A');
            Console.WriteLine(1000M);
            int sumIntTwo = M(10,20);
            double sumDoubleTwo = M(3.14,2.15);
            Console.WriteLine("两个int类型的数相加的和是{0}", sumIntTwo);
            Console.WriteLine("两个double类型的数相加的和是{0}", sumDoubleTwo);
            Console.ReadKey();
        }

        private static int M(int v1, int v2)
        {
            return v1 + v2;
        }
        private static double M(double v1, double v2)
        {
            return v1 + v2;
        }
        public static int M(int n1, int n2, int n3)
        {
            return n1 + n2 + n3;
        }
    }
}

访问修饰符

/*
* 面向对象的三大特征：
* 1.封装：将数据或者函数等集合在一个个单元中（类）
* 2.继承：类似于现实世界的继承
* 3.多态：一个事物（类）有多种表现形式
*
* 我们可以通过调用封装好的单元，获取其中的数据和函数，但有些数据和函数不希望被每个人获得
* 所以就用到了访问修饰符，利用访问修饰符封装成员变量和方法，限制类成员的访问权限
* public：公共的，无限制条件，任何代码都可以访问
* private:私有的，只有所在类的成员才能访问
*
* 总结：访问修饰符的作用是修饰类的成员变量，对类成员变量的可访问性进行限制
* 1.声明命名空间、类前面如果不加访问修饰符的话，默认访问权限是internal——访问仅限于当前的程序集
* 2.声明类成员（属性和方法）如果不加访问修饰符的话，默认是private——访问仅限于当前类
*
*/

using System;

namespace 访问修饰符
{
    class Program
    {
        static void Main(string[] args)
        {
            //实例化一个Student
            student stu = new student();
            //对象的初始化
            stu.id = 1001;
            stu.name = "张三";
            stu.age = 18;
           
            stu.ModifyScore();
            Console.ReadKey();
        }
    }

   class student
    {
        //创建三个公开的成员变量
        public int id;
        public string name;
        public int age;

        //私有成员变量
        private int score;
        public void ModifyScore()
        {
            this.score = 90;
            Console.WriteLine("{0}的分数是{1}", this.name, this.score);
           
        }
    }
}

类的静态成员

/*静态和非静态的区别：
* 1.在非静态类中，即可以有实例成员，也可以有静态成员
* 2.在调用实例成员的时候，需要使用对象名.实例成员
* 在调用静态成员的时候，需要使用类名.静态成员名
* 总结：静态成员必须使用类名去调用了，而实例成员使用对象名调用
*
* 静态方法中，只能访问静态成员，不允许访问实例成员
* 实例方法中，既可以访问静态成员，也可以访问实例成员
* 静态类中，只允许静态成员，不允许非静态成员
*
* 使用：
* 1) 如果你想要你的类当做一个“工具类”去使用的话，这个时候可以考虑将类写成静态的
* 2）静态类在整个项目中资源共享
* 只有在程序全部结束之后，这个静态类才会释放资源
*
*
*
*/

using System;

namespace 类的静态成员
{
    class Program
    {
        static void Main(string[] args)
        {
            //实例化Person类
            Personn p = new Personn();
            //调用实例方法
            p.M1();
            //调用静态方法
            Personn.M2();

            Console.ReadKey();
        }
    }
}
///Person类
 class Personn
    {
        //静态成员name 
        public static string name;
        //非静态的实例成员gender
        public char gender;

        public void M1()
        {
            this.gender = '男';
            name = "李四";
            //实例方法，既可以访问静态成员，也可以访问实例成员，访问时，不需要用对象
            Console.WriteLine("这是非静态的方法");
        }
        public static void M2()
        {
            name = "张三";
            //静态方法，只能访问静态成员，不能访问实例成员
            Console.WriteLine("这是一个静态方法");

        }
    }
    静态类和非静态类
    namespace 类的静态成员
{
    public static class student
    {
        public static string name;
        public static void M2()
        {

        }
        //public int age;  静态类不能有实例成员
        //public void M1()
        //{

        //}
        //静态类中不能有实例方法
    }
}

值类型和引用类型

/*值类型和引用类型
* 区别：
* 1.值类型和引用类型在内存上存储的地方不一样
* 2.在传递值类型和传递引用类型的时候，方式不一样
* 值类型我们称之为值传递，引用类型我们称之为引用传递
* 值类型有：int double bool char decimal struct enum
* 引用类型：string 自定义类，数组
* 存储：
* 值类型的值是存储在内存中的栈当中
* 引用类型的值是存储在内存中的堆当中
*

using System;

namespace 值类型和引用类型
{
    public class Student
    {
        public int id;
    }
    class Program
    {
        static void Main(string[] args)
        {
            //值类型
            //声明一个值类型的整数数据类型变量
            int n = 100;
            Console.WriteLine("该变量的初始值为{0}",n);
            Test(n);
            Console.WriteLine("该变量的此时的值为{0}", n);
            //引用类型
            Student stu = new Student();
            stu.id = 100;
            Console.WriteLine("该stu.id的初始值为{0}",stu.id);
            Test2(stu);
            Console.WriteLine("该stu.id的此时值为{0}",stu.id);
            //装箱
            int i = 123;
            object o = i;//值类型转成引用类型 装箱
            int j = (int)o;//拆箱
            Console.WriteLine(j);
            Console.ReadKey();
        }

        static  void Test(int i)
        {
            int temp = 10;
            i = temp * 20;
        }
        static void Test2(Student s)
        {
            int temp = 10;
            s.id = temp * 20;
        }
    }
}