Zadanko z dziedziczenia interfejsów

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();
}
1

pseudokod!

findByName(String name) {
 for IStudent student in students
if student.getName equals name
    return student;
else 
   return null;
}

I coś w tym stylu dla reszty.

0

Mógłbyś mi powiedzieć co to znaczy pseudokod i jak się odnosi do zadania ?

0

A możesz nam powiedzieć po co potrzebujesz to zadanie?

0

tak, jakiś czas temu dostałem coś w tym stylu na teście na praktyki

1
witu122 napisał(a):

Mógłbyś mi powiedzieć co to znaczy pseudokod i jak się odnosi do zadania ?

Mogę, cytat z wiki:
"Pseudokodem nazywany jest taki sposób zapisu algorytmu, który zachowując strukturę charakterystyczną dla kodu zapisanego w języku programowania, rezygnuje ze ścisłych reguł składniowych na rzecz prostoty i czytelności".
Na podstawie tego pseudokodu możesz sobie napisać kod w Javie.

0

hmmmm nie pamiętam zebym miał tam w poleceniu żeby zastosować pseudo kod, ale skoro było to zadanie na kartce to może rzeczywiście chodziło tylko o tok myslenia

1

aaaaaa dobra źle zrozumiałem hehe, juz wiem o co chodziło koledze

0
szweszwe napisał(a):

pseudokod!

findByName(String name) {
 for IStudent student in students
if student.getName equals name
    return student;
else 
   return null;
}

I coś w tym stylu dla reszty.

0
szweszwe napisał(a):

pseudokod!

findByName(String name) {
 for IStudent student in students
if student.getName equals name
    return student;
else 
   return null;
}

I coś w tym stylu dla reszty.

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

0

Fajne jest to, że po nieudanej rekrutacji na praktyki próbujesz się tego "nauczyć" ALE po pytaniach, które zadajesz widać, że jesteś jeszcze mocno w tyle.
Przerób sobie temat interfejsów i klas abstrakcyjnych od nowa a dopiero wtedy podejmuj się zadań tego typu.

Ogólnie polecam ten blog: https://www.samouczekprogramisty.pl/kurs-programowania-java/ Poza czytaniem artykułów przerabiaj sobie zadania konstruowane przez autora postów.

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 count powinna zwracac po prostu nodes.size() ?

0
witu122 napisał(a):

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

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

0

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

0

Nawet ta twoja klasa go nie implementuje.

0

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

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.

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 count powinna zwracac po prostu 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)));
    }
}

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