在另一个对象中实例化一个对象？ （C＃）

Question

首先我想说，如果这是一个愚蠢的问题，我真的很抱歉，但我刚开始学习课程，我以为我设法理解了它，但这让我很困惑，所以好像我没有't

我正在做这个 C# OOP edx 课程，我必须在不同的类文件中创建 5 个类（学生、教师、UProgram、学位、课程），并且有这个任务：

1. 实例化一个名为 Information Technology 的 UProgram 对象。
2. 在 UProgram 对象中实例化 Degree 对象，例如 Bachelor。
3. 在 Degree 对象中实例化一个名为 softeng 的 Course 对象。

1. 已经完成，（希望）那个没有问题
2. 和 3. - 嗯。

我的想法（请记住，我是初学者）： 首先，我想到了嵌套类，但我不太确定它们是如何工作的，并且认为我不能将这些类放在不同的文件中，因为它们应该嵌套（？） 然后我用构造函数尝试了一些东西，但我看不出如何让它工作

所以现在我最后的尝试是在类中创建方法（除了教师和学生的方法，因为他们不会有任何“属于他们”的东西，比如课程有学生和教师属于它

所以我有以下形式的方法（-假设我们在 Degree 类中，有一个方法可以为这个学位创建几个 Courses -）：

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

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

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

    public Degree()
    {
        Course = new Course();
    }
}

public class Course
{
    public Student Student { get; set; }

    public Course()
    {
        Student = new Student();
    }
}

public class Student
{
    public Student()
    {

    }
}

在创建 Degree 的实例时，它会在其中创建 Course 的实例，这将在其中创建 Student 的实例。因此，Degree 包含一个包含学生的课程。

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

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

Answer 2

只有几厘米：

我很怀疑你在这里需要任何继承。例如：Student : Course - 我怀疑“学生是一门课程”:)。所以，你可能需要一些组合在这里。我不知道（也不记得）你图片中的钻石到底是什么意思，但可以猜到填充的钻石 - 是一件（或至少一件，不确定），空的意味着很多件。 所以，我将如何做到这一点（您可以将每个类拆分为单独的文件）：

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。相反，您需要在 Degree 类中定义 Course 数据成员。 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;
    }
}

现在，从Person 继承Teacher：

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");