Stwierdzenie problemu: środowisko uczenia się zawiera zarówno studentów, jak i pracowników, którzy mają wspólne atrybuty, ponieważ obaj są ludźmi. W niektórych instytucjach student może również pracować jako personel tam w tym samym czasie. Implikacje powyższego w Programowaniu obiektowym są następujące: :

  • Student dziedziczy Person
  • Staff dziedziczy Person
  • W niektórych przypadkach obiekt Student i obiekt Staff powinny być budowane na tej samej instancji Person (tj. współużytkują tę samą instancję klasy nadrzędnej)

Jak zaimplementować ostatnią implikację na liście za pomocą OOP? (najlepiej C#, Java, C++ lub Python)

0
Joe 18 styczeń 2022, 15:33
4
Nie. każda instancja jest instancją samą w sobie. To, co opisujesz, to skład, a nie dziedziczenie
 – 
Stultuske
18 styczeń 2022, 15:38
Czy wymienione przez Ciebie implikacje są wyszczególnione w opisie problemu, czy też są one Twoją własną interpretacją?
 – 
Angela Lopez
18 styczeń 2022, 15:39
Lopez Pierwsze dwa opierają się na tradycyjnych zasadach OOP. Trzeci to sposób, w jaki osobiście uważam, że opisywane seinario należy wdrożyć, ale jestem otwarty na inne sugestie.
 – 
Joe
18 styczeń 2022, 15:50

3 odpowiedzi

Nie sądzę, że dziedziczenie jest właściwym rozwiązaniem twojego problemu. Czy konieczne jest, aby Student i Staff były różnymi klasami?

Wydaje się, że bardziej odpowiednie byłoby, aby uczeń lub członek personelu były tylko przykładami Person, a istnieje właściwość członka role, która może zawierać "Student" lub "Staff" lub obie.

3
Karsten Gabriel 18 styczeń 2022, 15:43

Z interfejsem IPerson (interpretacja dziedziczenia trochę szersza) możesz zrobić coś takiego w Javie (jest blisko, ale prawdopodobnie nie ma cygara):

public interface IPerson
{

    default String getName() {
        return getPerson().getName();
    };

    default void setName(String name) {
        getPerson().setName(name);
    }

    IPerson getPerson();

}

public class Person implements IPerson
{

    private String name;

    @Override
    public String getName()
    {
        return name;
    }

    @Override
    public void setName(String name)
    {
        this.name = name;

    }

    public IPerson getPerson() {
        return this;
    }
}

public class Staff implements IPerson
{

    private Person person;

    private String socialInsuranceNumber;

    public String getSocialInsuranceNumber()
    {
        return socialInsuranceNumber;
    }

    public void setSocialInsuranceNumber(String socialInsuranceNumber)
    {
        this.socialInsuranceNumber = socialInsuranceNumber;
    }

    public Staff(Person person)
    {
        super();
        this.person = person;
    }

    @Override
    public IPerson getPerson()
    {
        return person;
    }

}

public class Student implements IPerson
{

    private Person person;

    private String matriculationNumber;

    public String getMatriculationNumber()
    {
        return matriculationNumber;
    }

    public void setMatriculationNumber(String matriculationNumber)
    {
        this.matriculationNumber = matriculationNumber;
    }

    public Student(Person person)
    {
        super();
        this.person = person;
    }

    @Override
    public IPerson getPerson()
    {
        return person;
    }

    public static void main(String[] args) {
        Person peterP = new Person();
        peterP.setName("Peter");

        Staff peterStaff = new Staff(peterP);
        peterStaff.setSocialInsuranceNumber("123");

        Student peterStudent = new Student(peterP);
        peterStudent.setMatriculationNumber("456");

        peterStudent.setName("Dr. Peter");

        System.out.println(peterStaff.getName());

    }

}

Bez użycia interfejsu można by nadpisać wszystkie pobierające, ustawiające i tym podobne i przekazać je osobie (ignorując pola w podklasie, też nie jest to miłe. To jest kompozycja zamaskowana jako dziedziczenie):

public class Student extends Person
{

    private Person person;

    private String matriculationNumber;

    public String getMatriculationNumber()
    {
        return matriculationNumber;
    }

    public void setMatriculationNumber(String matriculationNumber)
    {
        this.matriculationNumber = matriculationNumber;
    }

    public Student(Person person)
    {
        super();
        this.person = person;
    }

    @Override
    public String getName()
    {
        return person.getName();
    }

    @Override
    public void setName(String name)
    {
        person.setName(name);
    }

}
0
Turo 18 styczeń 2022, 17:28

W javie możesz dziedziczyć tylko jedną klasę, nie możesz mieć class WorkingStudent extends Student, Staff. Ale możesz zaimplementować wiele interfejsów, więc zaproponuję Ci rozwiązanie z interfejsami. Najpierw zdefiniujmy funkcjonalność ucznia. Student musi się uczyć, więc:

    public interface Student {
        
        void study();
    }

Teraz dla personelu musi oczywiście pracować, więc:

    public interface Staff {

        void work();
    }

Bardzo prosta klasa osoby:

    public class Person {

        private final String name;


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

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

Przeciętny student po prostu studiuje lub nie, kto wie, ale załóżmy, że studiuje. Jest Osobą, a także zajmuje się sprawami Studenta.

    public class NormalStudent extends Person implements Student {

        public NormalStudent(String name) {
            super(name);
        }

        @Override
        public void study() {
            System.out.println(getName() + " studies a lot.");
        }
    }

I twój przeciętny personel, który nie wykonuje swojej pracy zbyt pobożnie. Jest Osobą i robi rzeczy związane ze sztabem.

    public class NormalStaff extends Person implements Staff {

        public NormalStaff(String name) {
            super(name);
        }

        @Override
        public void work() {
            System.out.println(getName() + " does whatever the staff does");
        }
    }

Teraz dla ucznia, który jest również członkiem personelu:

    public class WorkingStudent extends NormalStudent implements Staff {

        public WorkingStudent(String name) {
            super(name);
        }

        @Override
        public void work() {
            System.out.println(getName() + " has finished studying, but does not go to the party and instead does his obligations as a staff member of his university.");
            System.out.println(getName() + " has a bright future ahead of him. Probably.");
        }
    }

WorkingStudent to NormalStudent, również Person (dziedziczy funkcjonalność Studenta z NormalStudent i właściwości Person) i implementuje Staff, otrzymując w ten sposób odpowiednią funkcjonalność.

I mały przykład:

    NormalStudent james = new NormalStudent("James");
    james.study();
    WorkingStudent george = new WorkingStudent("George");
    george.study();
    george.work();
    NormalStaff john = new NormalStaff("John");
    john.work();
0
Chaosfire 18 styczeń 2022, 17:29