02Net基础加强第二天-面向对象

构造函数的访问修饰符
构造函数的访问修饰符一定要写成public，因为在外部实例化该类对象时必须要调用构造函数。
构造函数也可以重载
如果不手动写构造函数，编译器会自动生成一个默认的无参的构造函数，当手动添加了任意一个构造函数的时候，默认的无参的的构造函数就被覆盖掉了

控件事件中的两个形参
sender:指的是触发当前事件的控件对象
e:指的是和事件相关的信息

  private void btnShowJianDao_Click(object sender, EventArgs e)
    {
    }

实现多个控件共用一个事件，减少代码冗余

 private void btnShowJianDao_Click(object sender, EventArgs e)//玩家出拳
        {
            //实现多个控件共用一个事件
            Button btn = (Button)sender;//强制类型转换
            if (btn != null)
            {
                int num1 = user.ShowFist(btn.Text.Trim());
                int num2 = computer.ShowFist();
                labUser.Text = user.FistName;
                labComputer.Text = computer.FistName;
                labResult.Text = CaiPanYuan.Judge(num1, num2);
            }
        }

修改编译器生成的设计文件：
三个控件指向同一个处理方法

   // btnShowJianDao
        // 
        this.btnShowJianDao.Click += new System.EventHandler(this.btnShowJianDao_Click);
        // 
        // btnShowShiTou
        // 
       this.btnShowShiTou.Click += new System.EventHandler(this.btnShowJianDao_Click);
        // 
        // btnShowBu
        // 
        this.btnShowBu.Click += new System.EventHandler(this.btnShowJianDao_Click);

引用程序集和添加命名空间
在一个项目中想要使用另一个项目中的类，首先要引用另一个项目的程序集，然后再引入命名空间就可以。
如果引入了程序集和命名空间还是无法访问这个类，说明这个类的访问修饰符不是public，定义类的时候默认类的访问修饰符是internal，默认在本项目中可用，所以在其他项目中引用的时候，类的访问修饰符需要写成public。
在类中直接声明变量和在方法中声明变量的区别
在类中直接声明的变量叫做类的成员变量。类的成员变量声明以后可以不赋初值直接使用，因为会有默认值。(数值类型的默认值为0，bool类型的默认值为false,引用类型的默认值为null）
在方法中声明的变量叫做局部变量。在声明以后必须赋值之后才能使用。
当成员变量和局部变量同名的时候，优先使用最近的变量。但是两个局部变量不能够重名。
继承中的构造函数的问题
子类继承了父类的属性和方法，但是没有继承父类的构造函数
//当一个子类继承一个父类以后，该子类中的所有构造函数默认情况下，在自己调用之前都会调用一次父类的无参数的构造函数。如果此时父类中没有无参数的构造函数，则提示报错！
//解决办法：1.在父类中手动写一个无参数的构造函数
//2.在子类的构造函数后面通过:base()关键字手动调用父类中有参数的构造函数

public class Person2
{
    //这个类中手动写了一个有参数的构造函数，所以默认的无参数的构造函数就被覆盖掉了
    public Person2(string name, char gender, int age)
    {
        this.Name = name;
        this.Gender = gender;
        this.Age = age;
    }
    public string Name
    {
        get;
        set;
    }
    public char Gender
    {
        get;
        set;
    }
    public int Age
    {
        get;
        set;
    }
}
public class Student2 : Person2
{
    public Student2(string name, char gender, int age, string studentID) : base(name, gender, age)//表示调用父类中的哪个构造函数
    //在这里指定调用父类中的构造函数，在实例化子类的对象的时候，先将用来实例化的参数传递给指定的父类的构造函数，通过父类的构造函数来帮助子类初始化继承自父类的成员，初始化完成之后，再初始化子类自己定义的成员。
    {
        this.studentID = studentID;
    }
    public string studentID
    {
        get;
        set;
    }
}
public class Teacher2 : Person2
{
    public Teacher2(string name, char gender, int age, string teacherID) : base(name, gender, age)//表示调用父类中的哪个构造函数
    {
        this.teacherID = teacherID;
    }
    public string teacherID
    {
        set;
        get;
    }
}

使用:this关键字调用本类中其他的构造函数
由于一个类中构造函数重载，那么就会产生代码冗余，使用:this关键字可以减少代码冗余

class Person3
    {
        public Person3(string name, char gender, int age, string id)
        {
            this.Name = name;
            this.Gender = gender;
            this.Age = age;
            this.ID = id;
        }
        public Person3(string name, int age) : this(name, ' ', 19, null)//调用本类的其他构造函数辅助初始化
        {
        }
        public Person3(char gender, string id) : this(null, gender, 0, id)//调用本类的构造函数辅助初始化
        {
        }
        public string Name
        {
            get;
            set;
        }
        public char Gender
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
        public string ID
        {
            get;
            set;
        }
        Person3 p1 = new Person3("张三", '男', 19, "37092319989890");
        Person3 p2 = new Person3('男', "37092428839939");
        Person3 p3 = new Person3("李四", 20);
    }

访问修饰符
private:只有在当前类内部可以访问
protected:在当前类内部以及所有的子类的内部
internal:在当前程序集内部可以访问，也就是在同一个项目文件中
protected internal:同时具有protected和internal二者的访问权限
public：在任何地方都能访问
命名空间里的所有类的访问修饰符只能是internal或者public，默认是internal
类中的成员默认访问修饰符是private
关于this.成员和base.成员
当调用从父类继承过来的成员的时候，如果子类没有重写，则this.成员和base.成员没有区别。如果子类重写了父类成员，则this.成员调用的是子类重写以后的。base.成员调用的依旧是父类中的成员。
访问性不一致的问题
1.当产生继承关系后，子类的访问性必须和父类的访问性一致，否则会暴露父类的成员
2.方法的返回值和参数必须和方法的访问性是一致的
3.属性返回值的访问性必须和属性的访问性一致
虚方法实现多态

 public class Person
    {
        public virtual void Say()
        {
            MessageBox.Show("saying。。");
        }
    }
    public class Student4:Person
    {
        public override void Say()
        {
            MessageBox.Show("我是一个学生");
        }
    }
    public class Teacher4 : Person
    {
        public override void Say()
        {
            MessageBox.Show("我是一个老师");
        }
    }

实例化对象，然后调用say()方法

            Person[] pArr = new Person[3];
            pArr[0] = new Student4();
            pArr[1] = new Teacher4();
            pArr[2] = new Student4();
            for (int i = 0; i < pArr.Length; i++)
            {
                pArr[i].Say();//这句话就体现出了多态
            }

使用new关键字隐藏从父类继承过来的成员

class Person
    {
        public void Say()
        {
            MessageBox.Show("我是人");
        }
    }
    class Student : Person
    {
        public new void Say()//由于已经从父类中继承过来了一个Say()方法，但是在这里又写了一个同样的方法，为了隐藏掉从父类继承来的那个Say()方法，使用new修饰符即可
        {
            MessageBox.Show("我是学生");
        }
    }