Zadanko z dziedziczenia interfejsów

Odpowiedz Nowy wątek
2019-10-08 18:16
0

Witam serdecznie, potrzebuje nie bardzo mam pomysł jak "ugryźć" to zadanie. Generalnie muszę zaimplementować wszystkie metody w klasie MyClass. Ktoś mogłby mi podpowiedzieć jak to powinno wyglądać ?

interface IMyClass {
  // zwraca studenta o podanym name lub null
  IStudent findByName(String name);
  // zwraca studenta o podanym surname lub null
  IStudent findBySurname(String surname);
  //zwraca liczbę studentów
  int count();
}

public class MyClass implements IMyClass {
  private List<IStudent> students;
}

interface IStudent {
  String getName();
  String getSurname();
}

interface ICreateStudent extends IStudent {
  List<IStudent> getStudents();
}

Pozostało 580 znaków

2019-10-08 20:34
0

no oki, pewnie tak zrobię ale czy możecie mi wytłumaczyć jaką role w tym programie pełni ICreateStudents i lista getStudents ? i czy metoda countpowinna zwracac poprostu nodes.size() ?

edytowany 1x, ostatnio: witu122, 2019-10-08 20:34

Pozostało 580 znaków

2019-10-08 21:30
0
witu122 napisał(a):

a czy tego intefejsu ICreateStudentsi listy getStudents używamy jakoś ? metode count tez zaimplementujemy return nodes.size()?

Nie za bardzo widzę potrzebę. students.size() raczej a nie nodes.

Pozostało 580 znaków

2019-10-08 21:38
0

tak dokładnie students.size(), czyli ten interfejsICreateStudents nie bedzie nam w niczym potrzebny w implementacji tamtych metod ?

Pozostało 580 znaków

2019-10-08 21:59
0

Nawet ta twoja klasa go nie implementuje.

Pozostało 580 znaków

2019-10-08 22:00
0

no oki, czyli wnioskuje ze jest dodany z "czapy" tak bardziej dla zmyłki

Pozostało 580 znaków

2019-10-08 22:20
0

Interfejsów w klasie się nie dziedziczy, tylko się implementuje. Zmień nazwę tego tematu, bo oczy bolą.

EDIT: Żeby nie było:
Zadanie bardziej dotyczy klasy, a nie interfejsów, więc bardziej pasuje temat o implementacji interfejsu.

edytowany 3x, ostatnio: serek, 2019-10-08 22:34

Pozostało 580 znaków

2019-10-08 22:43
0
witu122 napisał(a):

no oki, pewnie tak zrobię ale czy możecie mi wytłumaczyć jaką role w tym programie pełni ICreateStudents i lista getStudents ? i czy metoda countpowinna zwracac poprostu nodes.size() ?

Metoda widziana publicznie powinna zwracać coś, co z punktu widzenia "z zewnątrz" ma sens. Liczba studentów może mieć sens. Jakieś coś co jest rozmiarem "nodes" nie bardzo.

Ty implementujesz tylko MyClass

package net.forprogrammers;

import java.util.List;
import java.util.function.Predicate;

public class MyClass implements IMyClass {

    private List<IStudent> students;

    public MyClass(ICreateStudent iCreateStudent) {

        this.students = iCreateStudent.getStudents();
    }

    @Override
    public IStudent findByName(String name) {

        Predicate<IStudent> byName = s -> s.getName().equals(name);

        return getStudent(byName);
    }

    @Override
    public IStudent findBySurname(String surname) {

        Predicate<IStudent> bySurname = s -> s.getSurname().equals(surname);

        return getStudent(bySurname);
    }

    @Override
    public int count() {

        return students.size();
    }

    private IStudent getStudent(Predicate<IStudent> criterion) {

        return this.students
                .stream()
                .filter(criterion)
                .findAny()
                .orElse(null);
    }
}

Masz tylko interfejsy, bez implementacji (sytuacja kiedy kto inny pracuje nad częścią systemu). Nie implementujesz ich, bo to albo zrobił ktoś inny, albo zrobi. Jeden fragment ekipa zrobi wcześniej, inny inna ekipa później. Trzeba to spiąć, jakoś wstępnie potestować.

package net.forprogrammers;

import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.mockito.Mockito;

import static org.junit.Assert.*;
import static org.hamcrest.Matchers.*;

import java.util.Arrays;
import java.util.Collection;
import java.util.List;

@RunWith(Parameterized.class)
public class MyClassTest {

    @Parameterized.Parameter(value = 0)
    public static String name;
    @Parameterized.Parameter(value = 1)
    public static String surname;
    @Parameterized.Parameter(value = 2)
    public static IStudent student;

    private static String sAName = "Adam";
    private static String sBName = "Barbara";
    private static String sASurname = "Ant";
    private static String sBSurname = "Brown";
    private static IStudent studentA = Mockito.mock(IStudent.class);
    private static IStudent studentB = Mockito.mock(IStudent.class);

    private MyClass sut;
    private ICreateStudent createStudent;

    @Parameterized.Parameters
    public static Collection<Object[]> data() {

        return Arrays.asList(new Object[][]{
                {sAName, sASurname, studentA},
                {sBName, sBSurname, studentB}
        });
    }

    @Before
    public void setUp() throws Exception {

        createStudent = Mockito.mock(ICreateStudent.class);

        List<IStudent> students = Arrays.asList(studentA, studentB);

        Mockito
                .when(studentA.getName())
                .thenReturn(sAName);

        Mockito
                .when(studentB.getName())
                .thenReturn(sBName);

        Mockito
                .when(studentA.getSurname())
                .thenReturn(sASurname);
        Mockito
                .when(studentB.getSurname())
                .thenReturn(sBSurname);

        Mockito
                .when(createStudent.getStudents())
                .thenReturn(students);

        sut = new MyClass(createStudent);
    }

    @Test
    public void shouldDoFindingByName() {

        IStudent byName = sut.findByName(name);
        assertThat(byName.getName(), is(equalTo(student.getName())));
    }

    @Test
    public void shouldfindingBySurname() {

        IStudent bySurname = sut.findBySurname(surname);
        assertThat(bySurname.getSurname(), is(equalTo(student.getSurname())));
    }

    @Ignore
    @Test
    public void shouldCreateStudents() {

        Mockito
                .verify(createStudent, Mockito.times(1))
                .getStudents();

        List<IStudent> students = createStudent.getStudents();
        assertThat(students.size(), is(2));

        assertThat(students.get(0).getName(), is(sAName));
        assertThat(students.get(1).getName(), is(sBName));
        assertThat(students.get(0).getSurname(), is(sASurname));
        assertThat(students.get(1).getSurname(), is(sBSurname));

        assertThat(studentA, is(not(equalTo(null))));
        assertThat(studentB, is(not(equalTo(null))));
    }

    @Test
    public void shouldReturnNullWhenStudentDoesntExist() {

        IStudent byName = sut.findByName("Joe");
        assertThat(byName, is(equalTo(null)));

        IStudent bySurname = sut.findBySurname("Doe");
        assertThat(bySurname, is(equalTo(null)));
    }
}

"Ktoś sobie uświadomił, że pisał pod pseudonimem rzeczy, które lepiej żeby w firmie nie wypatrzyli :-)"

"- Ledwo na studiach 3 tydzień się kończy i już ciężko?
- Niestety prowadzący jest dziwny i robi kartkówki"
edytowany 3x, ostatnio: BraVolt, 2019-10-08 22:50

Pozostało 580 znaków

Odpowiedz
Liczba odpowiedzi na stronę

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0