C# 典型案例/纯写代码的笔记 个人复习用 -2

本篇主要是在做类和对象的练习时遇到的一些自己需要记录的东西

1.枚举类型

注意，这里的枚举类型Time的定义是和class Course并列的
此例包含构造函数中限定有参构造函数的范围

namespace p3
{
    public enum Time
    {
        春季学期,
        秋季学期
    };
    internal class Course
    {
        //类中具有 Name（课程名）、Time（开课时间）、Count（选课人数）三个属性，
        //其中开课时间为枚举值{春季学期、秋季学期}，选课人数范围 0~100；
        public string Name;
        
        public Time CourseTime;
        public int Count;
        

        //类中有一个静态变量 Counter，每创建一个 Course 实例，将该变量值加 1；
        public static int Counter = 0;

        public Course()
        {
            //age = 21;
            Name = "《数据结构》";
            CourseTime = Time.春季学期;//枚举类型赋值
            Count = 50;

            Counter++;
        }
        public Course(string name, Time time,  int count)
        {
            this.Name=name;
            this.CourseTime = time;

            if(count>0&&count<100)
            {
                this.Count = count;//构造函数中限定范围
            }
            else
            {
                Console.WriteLine("错误！");
            }

            Counter++;
        }

    }
}

枚举类型的一些等和“实例化”
所以说尽量不要写中文

	enum operater { Add, Sub, Mul, Div}
	internal class MyMath
    {
    	public operater symbol;

        public double Calculate(int a, int b)
        {

            if (symbol == operater.Add)
                return a + b;
            else if (symbol == operater.Sub)
                return a - b;
            else if (symbol == operater.Mul)
                return a * b;
            else
                return a / b;
        }
 }

2. 静态变量同样也需要一个静态构造函数，并且不能带public等访问修饰符

		//类中有一个 int 类型公开静态变量 staticNumber
        //和一个 int 类型公开的实例变量 number；
        public static int staticNumber;
        public int number;

        //提供一个静态构造函数，将静态变量 staticNumber 的初值设为 50；
        //不能带访问修饰符
        static A()
        {
            staticNumber = 50;
            Console.WriteLine("The staticNumber is {0}", staticNumber);
        }
		
		
		public static string string2;
        //用static声明的静态成员在外部只能通过类名称来引用，不能用实例名来引用
        //C#不支持在方法范围内声明静态的局部变量
        public static string InputS(string str2)
        {
            string2= str2;
            return string2;
        }

3. 抽象与继承

abstract
override

	//抽象类：这个类不能被实例化，且至少有一个抽象成员
    abstract class Shape
    {
        //Shape 类具有一个抽象方法 PrintArea()；
        public abstract void PrintArea();
    }
    
	class Triangle:Shape
    {
        //Triangle 类中包括三个数据公开字段：两条边长，和这两条边的夹角；
        double c1, c2;
        double j1;

        //Triangle 类中定义 1 个布尔类型公开属性 IsAreTriangle（是否正三角形）
        public bool IsAreTriangle;

        //原本的抽象成员是没有被实现的，所以在这里需要重写
        public override void PrintArea()
        {
            Console.WriteLine("The Area is :{0}",(c1*c2*Math.Sin(j1)/2));
        }


    }

4. 继承之后的函数要怎么写

public Student(string Name, int Age, string Sex, int[] Score) : base(Name, Age, Sex)

internal class Person
    {
        //具有姓名（Name）、年龄（Age）、性别（Sex）等 3个公开的属性；
        public string Name;
        public int Age;
        public string Sex;

        public Person()
        {
            Name = "默认姓名";
            Age = 0;
            Sex = "默认性别";
        }

        public Person(string name,int age,string sex)
        {
            Name = name;
            Age = age;
            Sex = sex;
        }

    }

    //从 Person 类派生一个 Student 类，      
    internal class Student : Person
    {
        //具有一个能够存放 5 门课程成绩的字段，
        public int[] Score = new int[5];

        public Student()
        {
            for(int i = 0; i < Score.Length; i++)
            {
                Score[i] = -1;
            }
        }

        //给 Student 类提供三个构造函数：
        //①无参；
        public Student(string Name,int Age,string Sex):base(Name,Age,Sex)
        {
            Name = "默认姓名";
            Age = -1;
            Sex = "默认性别";
        }

        //③具有姓名、年龄、性别、成绩数组四个参数的构造函数；
        public Student(string Name, int Age, string Sex, int[] Score) : base(Name, Age, Sex)
        {
            Name = "默认姓名";
            Age = -1;
            Sex = "默认性别";
            
        }

        //并具有 SetScores 方法（输入学生的 5 门成绩）
        public void SetScores(int[] s)
        {
            for(int i=0;i<Score.Length;i++)
            {
                Score[i] = s[i];
            }
        }

        //和 GetAverage 方法（求平均成绩）；
        public double GetAverage()
        {
            double sum = 0;
            for (int i = 0; i < Score.Length; i++)
            {
                sum+=Score[i];
            }

            return sum/Score.Length;
        }
    }

5. 虚拟方法，继承，重写

	internal class A
    {
        //定义一个类 A，
        //A 中有一个虚拟方法 Method，该方法返回”A.Method”
        public virtual string Method()
        {
            return "A.Method";
        }
    }

    class B : A
    {
        //类 B 从类 A 继承，B 中重写类 A 中的 Method 方法，返回”B.Method”
        public override string Method()
        {
            return "B.Method";
        }
    }