t.me/atinfo_chat Telegram группа по автоматизации тестирования

Тест не видит методы одного из наследуемых классов

java
testng
selenium
Теги: #<Tag:0x00007f9c50098320> #<Tag:0x00007f9c5009a0f8> #<Tag:0x00007f9c5009b548>

(Viktor) #21

Работает, онлайн затестил

import java.lang.Math; // headers MUST be above the first class

// one class needs to have a main() method
public class HelloWorld
{
  // arguments are passed using the text field below this editor
  public static void main(String[] args)
  {
     Child myObject = new Child();
    
    myObject
       .BaseMethod()
       .ChildMethod();
  }
}



public class Base<T> 
{ 
  @SuppressWarnings("unchecked")
  public T BaseMethod()
  {
    System.out.print("I Am Parren\n");
    return (T)this;
  }
}

public class Child extends Base<Child>
{
  public Child ChildMethod()
  {
    System.out.print("I Am Child\n");
    return this;
  }
}


(Михаил Братухин) #22

Второй уровень наследования тоже отработает?


(Viktor) #23


(Михаил Братухин) #24

Так будет работать, да. Я просто брал в расчёт что неизвестно сколько уровней наследования будет в будущем. С третим слоем как будете справляться? Переписывать родителя при появлении потомка. Как-то неправильно, как мне кажется.

public class HelloWord {
public static void main(String[] args)
{

    Child<Child> myObject = new Child();
    myObject
            .BaseMethod()
            .ChildMethod();


    Child2 myObject2 = new Child2();
    myObject2
            .BaseMethod()
            .ChildMethod()
            .ChildMethod2();
}

public static class Base<T>
{
    public T BaseMethod()
    {
        System.out.print("I Am Parent\n");
        return (T)this;
    }
}

public static class Child<T> extends Base<T>
{
    public T ChildMethod()
    {
        System.out.print("I Am Child\n");
        return (T) this;
    }
}

public static class Child2 extends Child<Child2>
{
    public Child2 ChildMethod2()
    {
        System.out.print("I Am Child2\n");
        return this;
    }
}

}


(Viktor) #25
  1. Mожно сделать сколько угодно уровней наследования
  2. Вы родителя ни как не цепляете при добавлении потомка
  3. Ничего не переписывается потому что T самый нижний потомок
  4. Вообще все базовые страницы должны быть абстрактными мы не должны создавать их экземпляры
  5. Вы понимаете что написали не рабочий код? Cтатика с наследованием не совместимы

(Михаил Братухин) #26

Нерабочий код? Серьезно? :flushed:


(Viktor) #27

Прикольно, C# такое не разрешает


(Михаил Братухин) #28

Это вложенные классы.
Вот пример ближе к вашему, но с правильным пакетным доступом. В Java в одном файле может быть только один публичный невложенный класс:

public class HelloWord {
    public static void main(String[] args) {

        Child<Child> myObject = new Child();
        myObject
                .BaseMethod()
                .ChildMethod();


        Child2 myObject2 = new Child2();
        myObject2
                .BaseMethod()
                .ChildMethod()
                .ChildMethod2();
    }
}

class Base<T> {
    public T BaseMethod() {
        System.out.print("I Am Parent\n");
        return (T) this;
    }
}

class Child<T> extends Base<T> {
    public T ChildMethod() {
        System.out.print("I Am Child\n");
        return (T) this;
    }
}

class Child2 extends Child<Child2> {
    public Child2 ChildMethod2() {
        System.out.print("I Am Child2\n");
        return this;
    }
}

(Viktor) #29

Так вы вставили класс в HelloWord, поэтому работает, наружу вытащите как по нормальному, тогда не будет работать


(Михаил Братухин) #30

Выше уже написал


(Viktor) #31

да, это такой способ обойти ограничение и показать пример на одной страничке,


(Михаил Братухин) #32

Сделал немного костыльное решение, но зато оно будет точно работать и расширяемо. При этом не будет задевать родительские классы:

public class HelloWord {
    public static void main(String[] args) {

        Child<Child> myObject = new Child();
        myObject
                .BaseMethod()
                .ChildMethod();


        Child2<Child2> myObject2 = new Child2();
        myObject2
                .BaseMethod()
                .ChildMethod()
                .ChildMethod2();

        Child3<Child3> myObject3 = new Child3<>();
        myObject3
                .BaseMethod()
                .ChildMethod()
                .ChildMethod2()
                .ChildMethod3();
    }
}

class Base<T extends Base> {
    public T BaseMethod() {
        System.out.print("I Am Parent\n");
        return (T) this;
    }
}

class Child<T extends Child> extends Base<T> {
    public T ChildMethod() {
        System.out.print("I Am Child\n");
        return (T) this;
    }
}


class Child2<T extends Child2> extends Child<T> {
    public T ChildMethod2() {
        System.out.print("I Am Child2\n");
        return (T) this;
    }

    @Override
    public T ChildMethod() {
        return super.ChildMethod();
    }
}

class Child3<T extends Child3> extends Child2<T> {
    public T ChildMethod3() {
        System.out.print("I Am Child3\n");
        return (T) this;
    }

    @Override
    public T ChildMethod2() {
        return super.ChildMethod2();
    }

    @Override
    public T ChildMethod() {
        return super.ChildMethod();
    }
}

(Viktor) #33

Не понял, что вам в прошлом примере не расширяемым показалось


(Михаил Братухин) #34

Добавьте ещё один слой и поймете.


(Viktor) #35

Так я уже добавлял

https://automated-testing.info/uploads/default/original/2X/c/c6abf9ef4bcc71631628b0aaf358b2196e1bcad3.png


(Михаил Братухин) #36

Это частный пример. Как в теореме Абеля-Руффини, при степени n > 5 не существует общего решения уравнения.

Добавьте в своей последней реализации ещё один слой.


(Viktor) #37

У вас в реальных тестах не будет такого варианта, чтобы добавлять снизу, так как вы сразу проектируете страницу наследуя от базовых(их может быть сколько угодно) и добавляя общие блоки композицией. Даже если и будет, то это очень уникальный случай, сомневаюсь что под под очень маловероятный случай нужно подгонять весь код.


(Михаил Братухин) #38

Ну, я выше про тоже писал. И с тем что композиция часто приоритетнее наследования не спорю.

Просто привел общее решение с дженериками, которое не ломается от увеличения слоев наследования. Это чисто умозрительная задача.