Question

首先，我要说的是一个白痴问题，我真的很抱歉，但是我刚刚开始学习班级，我以为我设法理解了这个问题，但是这让我很困惑，所以好像我没有't

我正在做这个C＃OOP edx课程，在这里我必须在不同的班级文件中开设5个班级（学生，老师，UProgram，学位，课程），并且有以下任务：

实例化一个称为“信息技术”的UProgram对象。

实例化一个学位对象（如学士学位），说明UProgram对象。

在“度”对象中实例化一个名为“ softeng”的“课程”对象。

完成后，（希望如此）没有问题
和3.-嗯。

我的想法（请记住，我是初学者）：首先，我想到了嵌套类，但是我不确定它们是如何工作的，也不认为我可以将它们放在不同的文件中，因为它们应该嵌套（？）。然后我尝试使用构造函数，但看不到如何使它起作用

因此，现在我的最后尝试是在类中创建方法（“教师和学生”除外，因为他们不会像“课程”中包含学生和老师一样，没有任何“属于他们”

所以我有以下形式的方法（-假设我们在学位课程中，有一个用于为该学位创建多个课程的方法-）：

public void Newcourse(string Cname, Course sth)
{
    sth = new Course();
    sth = Cname;
}

在我可以使用它之前，我必须先写

Course softeng = new Course();

在我可以完成任务的3.点之前，也要先创建Course类的实例

整个代码：

UProgram.cs

public class UProgram
{
    public void Newdegree(string Dname, Degree sth)
    {
        sth = new Degree();
        sth.Dname = Dname;
    }
}

Degree.cs

public class Degree : UProgram
{
    public string Dname { get; set; }
    public void Newcourse(string Cname, Course sth)
    {
        sth = new Course();
        sth.Cname = Cname;
    }
}

Course.cs

public class Course : Degree
{
    public void NewTeacher(string FirstName, string LastName, Teacher sth)
    {
        sth = new Teacher();
        sth.FirstName = FirstName;
        sth.LastName = LastName;
    }
    public void NewStudent(string FirstName, string LastName, Student sth)
    {
        sth = new Student();
        sth.FirstName = FirstName;
        sth.LastName = LastName;
    }
    public string Cname { get; set; }
}

Teacher.cs

public class Teacher : Course
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Student.cs

public class Student : Course
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

Program.cs

class Program
    {
        static void Main(string[] args)
        {
            var Information_Technology = new UProgram();
            Degree bachelors = new Degree();
            Information_Technology.Newdegree("Bachelors", bachelors);
            Course softeng = new Course();
            bachelors.Newcourse("Software Engineering", softeng);
            Teacher t1 = new Teacher();
            softeng.NewTeacher("Colin", "Firth", t1);
            Student s1 = new Student();
            softeng.NewStudent("Mary", "Sue", s1);
            Student s2 = new Student();
            softeng.NewStudent("Joseph", "Jojo", s2);
            Console.ReadLine();
        }
    }

我知道-我知道，这非常令人费解，我什至不确定这是否好，但这就是我能想到的一切，如果有人可以帮助我，我将非常感激（不会让我哭泣的语气）

一次又一次地谢谢您，对于这段混乱的代码，我尝试过

Answer 1

措辞确实有些奇怪，但是我相信他们只是在说这个类应该包含它打算“包含”的类型的属性，并在构造函数中实例化它。例如：

var degree = new Degree();
degree.Course = new Course();
degree.Course.Student = new Student();

创建学位实例后，将在其中创建课程的实例，并在其中创建学生的实例。因此，学位包含一个包含学生的课程。

上面的示例使用构造函数实例化这些实例，但是由于它们是公共属性，因此也可以从其外部创建它们（在这种情况下，不需要上面的构造函数）：

Project

Answer 2

仅几条评论：

我非常怀疑您是否需要继承。例如：学生：课程-我怀疑“学生就是课程” :)。因此，您可能需要在这里进行一些组合。我不知道（也不记得）图片中的钻石究竟意味着什么，但是可以猜到填充的钻石-是一项（或至少一项，不确定），而空则意味着很多项。因此，这里是我要怎么做（您可以将每个类拆分为单独的文件）：

public class UProgram
{
    public string Name { get; set; }
    public Degree Degree { get; set; }

    public UProgram(string name, Degree degree)
    {
        Name = name;
        Degree = degree;
    }
}

public class Degree
{
    public string Name { get; set; }
    public Course Course { get; set; }

    public Degree(string name, Course course)
    {
        Name = name;
        Course = course;
    }
}

public class Course
{
    public List<Teacher> Teachers { get; set; }
    public List<Student> Students { get; set; }
    public string Name { get; set; }

    public Course(string name, List<Teacher> teachers, List<Student> students)
    {
        Name = name;
        Teachers = teachers;
        Students = students;
    }
}

public class Teacher
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class Student
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

和主要功能：

static void Main(string[] args)
    {
        var teachers = new List<Teacher>
        {
            new Teacher
            {
                FirstName = "Colin",
                LastName = "Firth"
            }
        };
        var students = new List<Student>
        {
            new Student
            {
                FirstName = "Mary",
                LastName = "Sue"
            },
            new Student
            {
                FirstName = "Joseph",
                LastName = "Jojo"
            }
        };

        var softEngCourse = new Course("Software Engineering", teachers, students);
        var bachelorDegree = new Degree("Bachelor", softEngCourse);

        var technologyProgram = new UProgram("Technology", bachelorDegree);

        Console.ReadLine();
    }

我仍然不确定这是否是您期望的课程，这就是我编写这样的代码的方式（有一些小的更改，但这并不重要）。为什么这样呢？因为在对象显式接收到所需的所有内容时，以“工作”状态构建对象几乎总比创建以“无效”状态开始的原始对象要好得多。其次，通常最好不要“引入”内部的参数值，而要给类使用者（在这里是指“开发人员”）进行配置。

Answer 3

您误解了任务。由于Course不是Degree，因此Course不应继承Degree。相反，您将需要在Course类中定义Degree数据成员。 Student和Teacher都不是Course，因此您不应从Course继承它们。他们是成员。

我假设一个Degree可以实现一个Course。

我假设一个Course有一个Teacher。

我假设一个Course可以有多个Students。

这意味着您具有Person类，因为Student和Teacher都是Person：

public class Person {
    protected String firstName;
    protected String lastName;

    public String getFirstName() {
        return this.firstName;
    }

    public String getLastName() {
        return this.lastName;
    }

    public Student(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }
}

现在，从Teacher继承Person：

public class Teacher : Person {
    public Teacher(String firstName, String lastName) : base(firstName, lastName) {
    }
}

和Student：

public class Student : Person {
    public Student(String firstName, String lastName) : base(firstName, lastName) {
    }
}

现在，让我们定义Course：

public class Course {
    protected Teacher teacher;
    protected List<Student> students;
    protected String name;

    public String getName() {
        return this.name;
    }

    public Teacher getTeacher() {
        return this.teacher;
    }

    public List<Student> getStudents() {
        return this.students;
    }

    public void setTeacher(Teacher teacher) {
        this.teacher = teacher;
    }

    public void setTeacher(String firstName, String lastName) {
        this.teacher = new Teacher(firstName, lastName);
    }

    public void addStudent(Student student) {
        this.students.Add(student);
    }

    public void addStudent(String firstName, String lastName) {
        this.students.Add(new Student(firstName, lastName));
    }

    public Course(String name) {
        this.name = name;
        this.students = new List<Student>();
    }
}

现在，让我们定义Degree：

public class Degree {
    protected String name;
    protected Course course;

    public String getName() {
        return this.name;
    }

    public Course getCourse() {
        return this.course;
    }

    public void setCourse(Course course) {
        this.course = course;
    }

    public void setCourse(String name) {
        this.course = new Course(name);
    }

    public Degree(String name) {
        this.name = name;
    }
}

现在，这是您实现所需目标的方法：

Degree degree = new Degree("mydegree");
degree.setCourse("myCourse");
Course course = degree.getCourse();
course.setTeacher("John", "Smith");
course.addStudent("James", "Doe");

实例化另一个对象内部的对象？（c＃）

3 个答案:

实例化另一个对象内部的对象？ （c＃）

3 个答案:

实例化另一个对象内部的对象？（c＃）