对象交互噢噢

1、显示学生所选课程的信息——对象交互

实例描述：学生成功的选上了一门公选课，请将该学生基本信息，该门课程的信息及该学生所选择的所有学分数输出在屏幕上。

实现过程：设计一个控制台程序InteractionObject，定义名为Student的学生信息类，包括学号、姓名、已修学分、选修的某门课程（Course类）4个字段，方法UpdateCredit将新选课程的学分添加到已修学分上更新已修学分。定义Course类，包含课程号，课程名称，学分和授课教师4个信息。在主函数中给出至少1个对象实例，将该学生基本信息，所选课程的信息及该学生所选择的所有学分数输出在屏幕上。

namespace InteractionObject
{
    class Program
    {
        public class Student
        {
            public int snumber;
            public string sname;
            public int sscore;
            public Course course;
            public void UpdateCredit(int score, Course c)
            {
                sscore = score;
                course = c;
                sscore += c.Credit;
            }
        }
        public class Course
        {
            string number;
            public string Number
            {
                get { return number; }
                set { number = value; }
            }
            string name;
            public string Name
            {
                get { return name; }
                set { name = value; }
            }
            int credit;
            public int Credit
            {
                get { return credit; }
                set
                {
                    if (credit >= 0)
                        credit = value;
                }
            }
            string teacher;
            public string Teacher
            {
                get { return teacher; }
                set { teacher = value; }
            }
        }

        static void Main(string[] args)
        {
            Student s1 = new Student();
            s1.sname = "阿陈";
            s1.snumber = 14;
            s1.sscore = 30;
           
            Course c = new Course();
            c.Number = "NB2021";
            c.Name = "面向对象";
            c.Credit = 5;
            c.Teacher = "可爱庄老师";
            s1.course = c;//记得要赋值
            Console.WriteLine("学生信息：");
            Console.WriteLine("姓名：{0}，学号：{1}，原有学分：{2}。", s1.sname, s1.snumber, s1.sscore);
            s1.UpdateCredit(s1.sscore,s1.course);
            Console.WriteLine("该生所选课程名为：{0}，课程号为：{1}，该门课程学分为：{2}，授课教师为：{3}，选修该课程后的学分为：{4}", c.Name, c.Number, c.Credit, c.Teacher, s1.sscore);
        }
    }
}

2.输出学生信息——继承

实现过程：设计一个控制台程序Inheritance1，定义一个教师类Teacher，包含教工号、姓名两个字段，由类派生出一个导师类Advisor类，添加字段研究方向。

定义名为Student的学生基类，包含学号和姓名两个字段成员，一个输出基本信息的方法。由Student类派生出本科生UnderGraduate类和研究生Graduate类，在本科生类中加入新的字段成员班主任(Teacher类)，在研究生类中加入新的字段成员导师(Advisor类)和研究方向 。在主函数中分别输出一个本科生对象和一个研究生对象的所有信息。

PS：每个类中封装的其它成员按需定义

namespace Inheritance1
{
    class Program
    {
        public class Teacher
        {
            int no;
            string name;
            public int No
            {
                get { return no; }
                set { no = value; }
            }
            public string Name
            {
                get { return name; }
                set { name = value; }
            }
        }
        public class Advisor:Teacher
        {
            string studydirect;
            public string Studydirect
            {
                get { return studydirect; }
                set { studydirect = value; }
            }
        }
        public class Student
        {
            int number;
            string name;
            public Student(){}//要先构造一个无参的函数才能被继承！
            public Student(int num, string sn)
            {
                number = num;
                name = sn;
                Console.WriteLine("学号为：{0}，姓名为：{1}", number, name);
            }
        }
        public class UnderGraduate:Student
        {
            public Teacher t;
            public UnderGraduate(int num, string sn):base(num,sn)
            { }
        }
        public class Graduate : Student
        {
            public Advisor a;
            public Graduate(int num, string sn) : base(num, sn)
            { }
        }
        static void Main(string[] args)
        {
            UnderGraduate u = new UnderGraduate(14,"陈哒哒");
            u.t = new Teacher();//先对t实例化才能给它所含的字段赋值
            u.t.No = 1;
            u.t.Name = "吴青峰";
            Console.WriteLine("该本科生班主任的教工号为：{0}，姓名为：{1}", u.t.No, u.t.Name);
            Graduate g = new Graduate(66, "陈加油");
            g.a = new Advisor();
            g.a.No = 2;
            g.a.Name = "吴小猫";
            g.a.Studydirect = "信息";
            Console.WriteLine("该研究生导师的教工号为：{0}，姓名为：{1}，研究方向为：{2}", g.a.No, g.a.Name, g.a.Studydirect);
        }
    }
}

2.计算圆柱体的表面积——派生类的构造函数

实例描述：定义一个圆形类，该类包含计算圆形面积的方法，由圆类派生出圆柱体类，并通过调用计算圆的面积公式来计算圆柱体的表面积。在主函数中分别计算一个圆和一个圆柱的面积并输出到屏幕上。

实现过程：设计一个控制台程序Inheritance2，定义名为Circle的圆形类，包括字段成员半径，有参数的构造函数和计算面积的方法。从圆形类派生出圆柱类Cylinder，添加新的字段成员圆柱的高和派生类的构造函数。在派生类中计算圆柱的表面积时用base关键字调用Circle类中计算圆形面积的方法。在主函数中分别定义圆类和圆柱类的对象，通过构造函数初始化，并计算它们的表面积数出在屏幕上。

PS. π = Math.PI,

       圆柱体的表面积=两个底面圆的面积+侧面矩形的面积
 

namespace Inheritance2
{
    class Program
    {
        public class Circle
        {
            public const double PI = Math.PI;
            protected double r, q;
            public Circle() { }
            public Circle(double r1, double q1)
            {
                r = r1;
                q = q1;
            }
            public virtual double Area()
            {
                return r * r * PI;
            }
        }
        public class Cylinder : Circle
        {
            public Cylinder(double r, double h) : base(r, h) { }
            public override double Area()
            {
                return (r * r * 2 * PI + 2 * r * PI * q);
            }
        }
        static void Main(string[] args)
        {
            double r = 100, q = 100;
            Circle c = new Circle(r, 0);
            Circle cy = new Cylinder(r, q);
            Console.WriteLine("半径为{0}的圆面积为{1:F2}", r, c.Area());
            Console.WriteLine("半径为{0}，高为{1}的圆柱体的表面积为{2:F2}", r, q, cy.Area());
        }
    }
}

1.计算圆柱体和圆锥体的表面积——多态

实例描述：定义一个圆形类，该类包含计算面积的方法，圆柱体和圆锥体都继承了面积的计算方法，在主程序中虽然调用计算面积的方法，实现圆柱体和圆锥体的表面积

实现过程：设计一个控制台程序Ploymorphism，定义名为Circle的圆形类，包括半径和计算面积的虚方法。从圆形类派生出圆柱类Cylinder和圆锥类Cone。在两个派生类中重写计算面积的虚方法，计算圆柱体和圆锥体的表面积。

namespace Ploymorphism
{
     public class Circle
    {
        public const double PI = Math.PI;
        protected double r,q;
        public Circle() { }
        public Circle(double r1,double q1)
        {
            r = r1;
            q = q1;
        }
        public virtual double Area()
        {
            return r * r * PI;
        }
    }
    public class Cylinder:Circle
    {
        public Cylinder(double r,double h) : base(r, h) { }
        public override double Area()
        {
            return (r *r*2 *PI +2*r*PI* q);
        }
    }
    public class Cone : Circle
    {
        public Cone(double r, double h) : base(r, h) { }
        public override double Area()
        {
            return PI*r*(r + Math.Sqrt(q*q+r*r));
        }
    }
    class Program
    {
       
        static void Main(string[] args)
        {
            double r = 100, q = 100;
            Circle cy = new Cylinder(r, q);
            Circle co = new Cone(r, q);
            Console.WriteLine("半径为{0}，高为{1}的圆柱体的表面积为{2:F2}", r, q, cy.Area());
            Console.WriteLine("半径为{0}，高为{1}的圆锥体的表面积为{2:F2}", r, q, co.Area());
        }
    }
}

2.输出不同员工的工资——new或虚方法

实例描述：在一家公司普通员工的工资为基本工资（1000元）加上工龄工资（每年增加30元）。本科生员工的工资为普通员工工资的2倍，研究生员工的工资是本科生员工工资的1.5倍。将三种不同员工的工资输出在屏幕上。分别用new或虚方法实现多态。

提示：使用base关键字会简化代码

namespace EmployeeSalary
{
    class Program
    {
        public class Employee  //普通员工
        {
            const int BaseSalary = 1000; //基本工资
            const int AgeSalary = 30;  //工龄工资
            public int Age;  //工龄
            public Employee(int age)
            {
                Age = age;
            }
            public virtual double Salary()  //虚方法
            {
                int salary;
                salary = BaseSalary + Age * AgeSalary;
                return salary;
            }
        }
        public class UnderGraduate : Employee  //本科生
        {
            public UnderGraduate(int age) : base(age)
            {
                Age = age;
            }
            public override double Salary()  //重写
            {
                return 2 * base.Salary();
            }
        }
        public class Graduate : UnderGraduate  //研究生
        {
            public Graduate(int age) : base(age)
            {
                Age = age;
            }
            public override double Salary()  //重写
            {
                return 1.5 * base.Salary();
            }
        }
        static void Main(string[] args)
        {
            Employee e1 = new Employee(3);
            UnderGraduate u1 = new UnderGraduate(2);
            Graduate g1 = new Graduate(1);

            Console.WriteLine("工龄为{0}的普通员工的工资为：{1}", e1.Age, e1.Salary());
            Console.WriteLine("工龄为{0}的本科生员工的工资为：{1}", u1.Age, u1.Salary());
            Console.WriteLine("工龄为{0}的研究生员工的工资为：{1}", g1.Age, g1.Salary());

            Console.ReadKey();
        }
    }
}

3. 图书馆管理学生借书权限——抽象类

实例描述：定义一个抽象类，在抽象类中定义一个抽象方法描述图书馆的借书权限，本科生可以借5本书，硕士生可以借8本书，博士生可以借10本书

实现过程：设计一个控制台程序AstractClass，定义名为Student的抽象学生类，包括一个抽象方法Authority。从抽象学生类中派生三个具体的学生类：Undergraduate、Postgraduate和Doctor，在每个派生类中实现抽象方法。并在主函数中实例化三种学生，输出他们的信息和借阅权限

namespace 图书馆借书
{
    class Program
    {
        abstract class Student
        {
            public abstract void Authority();
        }
        class Undergraduate : Student  
        {
            public override void Authority()
            {
                Console.WriteLine("本科生可借5本书");
            }
        }
        class Postgraduate : Student 
        {
            public override void Authority()
            {
                Console.WriteLine("硕士生可借8本书");
            }
        }
        class Doctor : Student  
        {
            public override void Authority()
            {
                Console.WriteLine("博士生可借10本书");
            }
        }
        static void Main(string[] args)
        {
            Undergraduate u1 = new Undergraduate();
            u1.Authority();
            Postgraduate p1 = new Postgraduate();
            p1.Authority();
            Doctor d1 = new Doctor();
            d1.Authority();
        }
    }
}

4. 教师和学生信息的显示——抽象类

实例描述：定义一个抽象Person类，在抽象类中定义编号、姓名的抽象属性和输出信息的抽象方法。从这个类中派生出一个学生类一个教师类，实现学生和教师类的数据输入和输出，学生类包含学号，姓名，班级，成绩等字段，教师类包含工号、姓名、职称和部门等字段。在主函数中用相关数据测试

namespace 抽象类
{
    class Program
    {
        abstract class Person
        {
            public int id; 
            public abstract string name { get; set; } 
            public abstract void GetInfo();  
        }
        class Student : Person
        {
            public string sclass;
            public int score;
            public string Name;
            public override string name
            {
                set
                { Name = value; }
                get
                { return Name; }
            }
            public override void GetInfo()
            {
                Console.WriteLine("学号为{0}的学生的姓名、班级、成绩分别为{1}、{2}、{3}。", id, name, sclass, score);
            }
        }
        class Teacher : Person
        {
            public string workname; 
            public string department; 
            public string Name;
            public override string name
            {
                set
                { Name = value; }
                get
                { return Name; }
            }
            public override void GetInfo()
            {
                Console.WriteLine("工号为{0}的教师的姓名、职称、部门分别为{1}、{2}、{3}。", id, name, workname, department);
            }
        }
        static void Main(string[] args)
        {
            Student s1 = new Student();
            s1.id = 101;
            s1.Name = "陈某";
            s1.sclass = "信息202";
            s1.score = 100;
            s1.GetInfo();
            Teacher t1 = new Teacher();
            t1.id = 505;
            t1.Name = "阿峰";
            t1.workname = "教授";
            t1.department = "音乐系";
            t1.GetInfo();
        }
    }
}

程序。