Как повторно использовать методы?

Question

Я новичок и пытаюсь научить себя чистому кодированию.Я хочу передать функцию в качестве параметра, чтобы я мог повторно использовать метод, не повторяя код.В качестве примера у меня есть это:

public class Dog {
    private String name;
    private int id;
    private List<String> characteristic;

    public List<String> getCharacteristic() {
        return characteristic;
    }

    public void setCharacteristic(List<String> characteristic) {
        this.characteristic = characteristic;
    }
 }

public class Check{
    private List<Dog> dogs = new ArrayList();

    public void iterate() {
        while (dogs.size() > 0) {
            for (Dog dog : dogs) {
                List<String> restChara = new ArrayList<>();
                restChara= checkChara(dog, restChara);
                if (restChara.size()>0) {
                    dog.setCharacteristic(restChara);
                } else {
                    dogs.remove(dog);
                }
            }
        }
    }

    private List<String> checkChara(Dog dog, List<String> restChara) {
        for (String chara : dog.getCharacteristic()) {
            boolean charaChecked = doSomething(chara);
            if (!charaChecked) {
                restChara.add(chara);
            } else {
                dog.getCharacteristic().remove(chara);
            }
        }
        return restChara;
    }

    private boolean doSomething(String chara){
        //do sth.
        return true;
    }
    private boolean doSomething2(String chara){
        //do sth.
        return true;
    }
}

Как бы вы определили метод checkChara для использования в нем различных функций?

Моей первой мыслью было передать функцию в качестве параметра (я думаю, что это было бы в делегатах C #)

Большое спасибо!

РЕДАКТИРОВАТЬ:

Я думаю, я нашел другой шаблон дизайна стратегии образца

https://www.freecodecamp.org/news/the-strategy-pattern-explained-using-java-bc30542204e0/

Answer 1

Java не поддерживает «непосредственно» вложенные методы.Многие функциональные языки программирования поддерживают метод внутри метода.Но вы можете достичь функциональности вложенного метода в Java 7 или более ранней версии, определив локальные классы, класс внутри метода, так что это компилируется.И в java 8 и более новой версии вы достигаете этого с помощью лямбда-выражения.

Метод 1 (Использование анонимных подклассов)

Это внутренний класс без имени и для которогосоздается только один объект.Анонимный внутренний класс может быть полезен при создании экземпляра объекта с некоторыми «дополнительными функциями», такими как методы перегрузки класса или интерфейса, без необходимости фактически создавать подкласс класса.

//Java program implements method inside method 
public class GFG { 

// create a local interface with one abstract 
// method run() 
interface myInterface { 
    void run(); 
} 

// function have implements another function run() 
static void Foo() 
{ 
    // implement run method inside Foo() function 
    myInterface r = new myInterface() { 
        public void run() 
        { 
            System.out.println("geeksforgeeks"); 
        }; 
    }; 
    r.run(); 
} 
public static void main(String[] args) 
{ 
    Foo(); 
} 
} 

Метод 2 (Использование локальных классов) Вы также можете реализовать метод внутри локального класса.Класс, созданный внутри метода, называется локальным внутренним классом.Если вы хотите вызвать методы локального внутреннего класса, вы должны создать экземпляр этого класса внутри метода.

// Java program implements method inside method 
public class GFG { 

// function have implementation of another  
// function inside local class 
static void Foo() 
{ 
    // local class 
    class Local { 
        void fun() 
        { 
            System.out.println("geeksforgeeks"); 
        } 
    } 
    new Local().fun(); 
} 
public static void main(String[] args) 
{ 
    Foo(); 
} 
} 

Метод 3 (Использование лямбда-выражения) Лямбда-выражения в основном выражают экземпляры функциональныхинтерфейсы (интерфейс с единственным абстрактным методом называется функциональным интерфейсом. Примером является java.lang.Runnable).Лямбда-выражения реализуют единственную абстрактную функцию и, следовательно, реализуют функциональные интерфейсы.

// Java program implements method inside method 
public class GFG { 
interface myInterface { 
    void run(); 
} 

// function have implements another function 
// run() using Lambda expression 
static void Foo() 
{ 
    // Lambda expression 
    myInterface r = () -> 
    { 
        System.out.println("geeksforgeeks"); 
    }; 
    r.run(); 
} 
public static void main(String[] args) 
{ 
    Foo(); 
} 
} 

Answer 2

Я не знаю точно, что вы имеете в виду, но я понимаю, что это может быть что-то вроде этого:

List<Runnable> runMyStuff = new ArrayList<Runnable>();
        String variable= "Hallo"; //needs to be effectively final 
        runMyStuff.add(() -> {
            System.out.println(variable);
            doSomething(variable);

        });

        runMyStuff.add(() ->{
            System.out.println("This is a test");
        });

        runMyStuff.add(() ->{
            System.out.println("2 + 2 = " + (2+2) );
        });

        runMyStuff.get(0).run();
        runMyStuff.get(2).run();
        runMyStuff.get(0).run();
        runMyStuff.get(1).run();
        runMyStuff.get(2).run();

приведет к:

Hallo
2 + 2 = 4
Hallo
This is a test
2 + 2 = 4

Когда вы положите переменныеили Передача параметров в тех запускаемых методах, они должны быть эффективно окончательными, иначе вы передадите их в контейнер.Вы можете перезапустить каждый метод.И в этих методах вы можете выполнять другие методы.

ПРИМЕЧАНИЕ : Если вы хотите получить возвращаемые параметры, вы можете сделать то же самое с Callable и чем ".call ()" вместо run.

РЕДАКТИРОВАТЬ : Под этим условием подразумевается символ Проверка или что-то подобное Пример для проходного метода charaCheck с интерфейсом:

    public interface CharacterChecker{
        //is a template returns boolean, need a String param
        public boolean call(String chara);

    }

Метод, который выполняет метод проходовтип "CHaracterChecker"

public static void excecutePassedMethod(CharacterChecker checker, String chara) {
        System.out.println(chara + ": " + checker.call(chara));
    }

Две разные реализации "Проверка символов"

        CharacterChecker goodChecker = new CharacterChecker() {

            @Override
            public boolean call(String chara) {
                return "good".equals(chara);

            }
        };

        CharacterChecker lazyCheker = new CharacterChecker() {

            @Override
            public boolean call(String chara) {
                return "lazy".equals(chara);

            }
        };

Методы, которые переданы "метод" (Больше похоже на объект класса anonymos сметод)

        excecutePassedMethod(goodChecker, "bad");
        excecutePassedMethod(goodChecker, "good");
        excecutePassedMethod(goodChecker, "jolly");

        excecutePassedMethod(lazyCheker, "frisky");
        excecutePassedMethod(lazyCheker, "lazy");

результат будет:

bad: false
good: true
jolly: false
frisky: false
lazy: true