访问修饰符、封装、继承

一、访问修饰符：
1、pubulc:公共的，只要引用了命名空间，就可以随意进行访问     *常用

2、private:私有的，只有当前类内部才可以访问        *常用

3、internal：内部的，当前程序集内可以访问，程序集就是命名空间，此修饰符是默认的

4、protected:被保护的，当前类和它的子类才可以访问

二、命名空间：

也叫程序集，项目中每一个文件夹都是一个独立的命名空间

如果要使用某一个命名空间下的类文件，那么必须首先引用此命名空间

三、封装

打包，封起来，保护起来

public int Ids - 属性，封装基本结构
{
      get{ return _Ids; }
      set{ _Ids = value; }
}

private int _Ids;   - 私有的成员变量

四、一个成员变量可以有很多个属性

属性返回类型可以是任意类型，不是必须要与成员变量类型相同

属性可以是只读的，也可以是只写的，也可以两者都有

public int Ids - -只读
{
      get{ return _Ids; }
}

public int Ids - -只写
{
      set{ _Ids = value; }
}

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

namespace ConsoleApplication1.App_Code
{
    public class Student
    {
        //封装id
        private int _id;
        public int id
        {
            get { return _id; }
            set { _id = value; }
        }

        //封装学号
        private string _code; //成员变量
        public string code  //一个成员变量可以有好多个属性
        {
            get { return _code; }   //通过属性，获取，读取
            set { _code = value; }//写入,判断条件要在set里面进行            
        }

        //封装姓名
        private string _name;
        public string name
        {
            get { return _name; }
            set { _name = value; }
        }

        //封装生日
        private DateTime _brithday;
        public DateTime brithday
        {
            get { return _brithday; }
            set { _brithday = value; }
        }
        public string sbrithday
        {
            get { return _brithday.ToString("yyyy年MM月dd日"); }//只读取,把生日转换成"yyyy年MM月dd日"这种格式。
        }

        //封装学号
        private decimal _score;
        public decimal score
        {
            get { return _score; }
            set { _score = value; }            
        }

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
using ConsoleApplication1.App_Code;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList al = new ArrayList();
            Console.Write("请输入学生人数：");
            int n = Convert.ToInt32(Console.ReadLine());
            //1.输入学生信息
            for (int i = 0; i < n; i++)
            {
                Student st = new Student();
                //序号
                st.id = i + 1;
                //输入学号
                while (true)
                {
                    Console.Write("请输入第" + (i + 1) + "个人的学号：");
                    st.code = Console.ReadLine();
                    if (st.code != "")
                    {
                        break;
                    }
                    else
                    {
                        Console.WriteLine("您输入的学生编号有误，请重新输入！");
                    }
                }
                //输入姓名
                while (true)
                {
                    Console.Write("请输入第" + (i + 1) + "个人的姓名：");
                    st.name = Console.ReadLine();
                    if (st.name != "")
                    {
                        break;
                    }
                    else
                    {
                        Console.WriteLine("姓名不能为空，请重新输入！");
                    }
                }
                //输入成绩
                while (true)
                {
                    Console.Write("请输入第" + (i + 1) + "个人的成绩：");
                    st.score =Convert.ToDecimal(Console.ReadLine());
                    if (st.score >= 0 && st.score <= 100)
                    {
                        break;
                    }
                    else
                    {
                        Console.WriteLine("成绩必须在0~100之间！");
                    }
                }
                al.Add(st);
                Console.WriteLine("------------------------------");
            }
            //2.排序，冒泡法
            for (int i = 0; i < n - 1; i++)
            {
                for (int j = i + 1; j < n; j++)
                {
                    Student st1 = (Student)al[i];
                    Student st2 = (Student)al[j];
                    if (st1.score < st2.score)
                    {
                        object zhong = al[i];
                        al[i] = al[j];
                        al[j] = zhong;
                    }
                }
            }
            //3.输出学生信息
            Console.WriteLine("===============学生信息===============");
            Console.WriteLine("序号" + "	" + "学号" + "	" + "姓名" + "	" + "成绩");
            for (int i=0;i<n;i++)
            {
                Student st3=(Student)al[i];
                Console.WriteLine(st3.id+"	"+st3.code+"	"+st3.name+"	"+st3.score);
            }
               
            Console.ReadLine();
        }
    }
}

学号、姓名不能为空，成绩要在0~100之间，如果输入错误会一直循环输入，直到输入正确

五、继承

1、子类可以继承父类所有的public方法和属性

     父类不可以调用子类的方法和属性，哪怕是public的

2、子类可以转换成父类，转换成的这个父类也可以转换回相应子类

     子类转换成父类，这个父类不可以转换成其它的子类

3、父类----就是成为父类

     子类----又称为某个类的子类，派生类，超类

     Plane这个类是Fly的派生类，
     Plane这个类派生自Fly

类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    public class Fly
    {
        public string Fly1()
        {
            return "我可以飞行！";
        }


        //private //这个是父类Fly私有的，子类不可以继承，只可以继承公共的

    }
}

类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    public  class Bird : Fly  //需要Bird这个类继承Fly里面的东西，那就在Bird后面加上英文状态下的“:”，在加上Fly
    {
        public string name()
        {
            return "我叫小鸟！";
        }

    }
}

类
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication2
{
    public class Plan:Fly
    {
        public string name()
        {
            return "我叫飞机！";
        }
    }
}

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

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            //第一个
            Fly f = new Fly();//实例化
            string s = f.Fly1();
            Console.WriteLine(s);

            //第二个
            Bird b = new Bird();//先实例化这个类
            //Bird这个类里面什么都不写的话，完全继承Fly这个父类里的东西，
            //所以，Bird也可以点出Fly1这个方法
            string bb = b.Fly1();
            Console.WriteLine(bb);

            //第三个
            Plan p = new Plan();//实例化            
            Console.WriteLine(p.Fly1());

            //第四个
            Bird bbb = new Bird();
            bbb.name();//没有强转成父类时有name这个方法
            Fly fff = (Fly)bbb;//把子类强转成父类，子类里面的所有方法都不能用，那是子类特有的，父类不可以用
            Console.WriteLine(fff.Fly1());

            //第五个
            Bird b1 = (Bird)fff;//新建一个b1的Bird类，把转成的父类fff转回到相应的Bird子类
            Console.WriteLine(b1.name());//转换回来的b1下面有name这个方法

            //第六个
            Plan pp = (Plan)fff;//报错：无法将类型为“ConsoleApplication2.Bird”的对象强制转换为类型“ConsoleApplication2.Plan”。
            Console.WriteLine(pp.name());
            //父类与子类的转换是两者之间的转换，子类与子类之间不能进行转换，
            //Bird强转为父类，这个父类不可以再转为其他子类，如果转换牵扯到Plan与Bird之间的转换
            //即子类与子类的转换，程序不允许所以报错，但是在代码中不显示语法错误


            Console.ReadLine();
        }
    }
}

第一个                                                         第二个                                                       第三个

第四个（把父类转换为子类）                                    第五个（转换成的这个父类也可以转换回相应子类）

第六个（子类转换成父类，这个父类不可以转换成其它的子类）