Sukumar Sat

Tim Holloway wrote:Well, technically, all Inversion of Control (IoC) requires is that instead of going out and finding things (Locator Pattern), someone/thing injects those things in.

But it's a lot more flexible if the injectable things are abstract, as that makes them plug-replaceable.

One of my favorite examples along those lines is using an email interface. If you have a class that generates emails, injecting an email sender Interface means that you can test the generating class with a dummy email sender injected in, then inject the actual email sender when you are ready to go live. Thus sparing the world a lot of junk email.

Tim,

I thank you for your valueable efforts.
I am yet requesting for your precise comments.
Let me put my two questions in different way: -

Q#	Question
1	Can interface be used as variable/ field? If yes, please quote reference under which scenario? please give an example to illustrate
2	Can interface be used as argument/ parameter? If yes, please quote reference under which scenario? please give an example to illustrate

With thanks,
Sukumar

Junilu Lacar wrote:

Sukumar Sat wrote:
I can rewrite code as following: -

You're "rewrite" doesn't work so there's really nothing to compare other than the original works and yours doesn't.

Please find below working and tested Java code rewritten for Original and for comparison: -

public interface EngineInterface {    public void start(); } public class PetrolEngine implements EngineInterface {    public void start() {        System.out.println("Petrol Engine Starts !");    } } public class DieselEngine implements EngineInterface {    public void start() {        System.out.println("Diesel Engine Starts !");    } } public class Car extends PetrolEngine {} public class DependencyInversion {    public static void main(String[] args) {        Car carObj = new Car();        carObj.start();    } }

Output: https://imgur.com/a/ksOs7HS

Junilu Lacar wrote:

Sukumar Sat wrote:
I can rewrite code as following: -

You're "rewrite" doesn't work so there's really nothing to compare other than the original works and yours doesn't.

Please review that both codes (original and rework) would not run (throw error by Java compiler).

Experts from Java should be able to recognise it as a conceptual question, and not as a coding question.

My two questions are about Syntax and not about entire code.

I am waiting for Java experts.

Junilu Lacar wrote:The code was given as an example of the Dependency Inversion Principle, i.e. depend on abstractions instead of concrete implementations. An interface is an abstraction, so. that's why the field and the method parameter are using the interface type instead of any specific implementation type. This way, the program can use any implementation. If someone comes up with a different implementation of the EngineInterface in the future, you can easily use it without changing any of the code in the Car class.

On the other hand, if the Car class depended on a specific implementation instead, the program code will need to be modified if you want to use a different engine implementation in the future.

I can rewrite code as following: -

public interface EngineInterface {    public void start(); } public class Car extends PetrolEngine  {    private String petrolEngine;    public Car(String pE) {        petrolEngine = pE;    }    public void start() {        engine.start();    } } public class PetrolEngine implements EngineInterface {   public void start() {...} } public class DieselEngine implements EngineInterface {   public void start() {...} }


Please review that my two questions remain same, as what difference aforesid Code makes syntactically to below Code : -

public interface EngineInterface {    public void start(); } public class Car {    private EngineInterface engine; // Why interface used as variable here?    public Car(EngineInterface e) { // Why interface used as Argument here?        engine = e;    }    public void start() {        engine.start();    } } public class PetrolEngine implements EngineInterface {   public void start() {...} } public class DieselEngine implements EngineInterface {   public void start() {...} }

I saw this first time and I am curious as how this happened?

public interface EngineInterface {    public void start(); } public class Car {    private EngineInterface engine; // Why interface used as variable here?    public Car(EngineInterface e) { // Why interface used as Argument here?        engine = e;    }    public void start() {        engine.start();    } } public class PetrolEngine implements EngineInterface {   public void start() {...} } public class DieselEngine implements EngineInterface {   public void start() {...} }

Source: https://www.educative.io/edpresso/what-are-the-solid-principles-in-java
License: Creative Commons -Attribution -ShareAlike 4.0 (CC-BY-SA 4.0)

Tim Moores wrote:The Domain class has no particular purpose except to illustrate the concept of BiPredicate - it models an internet domain (like "google.com") along with a "goodness" score of that domain.

The filterBadDomain method simply applies a Bipredicate to a List of domains. it's shown in action several times in the code; did you get that to run now? That should be the first step in learning from this example, as it makes it much easier to understand what's going on. (Although the source code does actually show the output of each of the System.out.println statements.)

Tim,

Thank you again,

I have amended code and shared working code below with some questions, for which I need your help to understand.

I understood that in Java 8, BiPredicate is a functional interface, which accepts two arguments and returns a boolean@FunctionalInterface public interface BiPredicate<T, U> {    boolean test(T t, U u); }

Please help me with answers to those Six requested questions asked in comments within below code.
Please give any Reference to elaborate my Learning.

/*    MIT License for https://mkyong.com/java8/java-8-bipredicate-examples/    Copyright (c) 2020 Mkyong.com    Permission is hereby granted, free of charge, to any person obtaining a copy    of this software and associated documentation files (the "Software"), to deal    in the Software without restriction, including without limitation the rights    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell    copies of the Software, and to permit persons to whom the Software is    furnished to do so, subject to the following conditions:    The above copyright notice and this permission notice shall be included in all    copies or substantial portions of the Software.    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE    SOFTWARE.                This example uses BiPredicate to filter bad domains by the domain name or threat score. */ import java.util.Arrays; import java.util.List; import java.util.function.BiPredicate; import java.util.stream.Collectors; public class BiPredicateExample2 {    public static void main(String[] args) {        List<Domain> domains = Arrays.asList(new Domain("MostlyCorrect.com", 1),          // Question # 1 : new keyword is used to create an Object. Why new Domain was used here?                new Domain("SomeSpamWeb.com", 10),                new Domain("SomethingCorrect.com", 0),                new Domain("AnythingCorrect.com", 2));        BiPredicate<String, Integer> bi = (domain, score) -> { // Question # 2 : domain is in lower case. Is it variable or an object?         // Question # 3 : Is this anonymous class after Lambda Expression ?            return (domain.equalsIgnoreCase("MostlyCorrect.com") || score == 0);         // Question # 4 :  Here, domain is in lower case and attached to a method. So, Is it an Object?        };        // if MostlyCorrect or score == 0        List<Domain> result = filterBadDomain(domains, bi);        // List is an interface,        // and usually, we use ArrayList as class and we write        // ArrayList aL = new ArrayList();        // Question # 5 : Why aforesaid line of code is different?        System.out.println(result); // MostlyCorrect.com, SomethingCorrect.com        //  if score == 0        List<Domain> result2 = filterBadDomain(domains, (domain, score) -> score == 0);        System.out.println(result2); // SomethingCorrect.com, AnythingCorrect.com        // if start with i or score > 5        List<Domain> result3 = filterBadDomain(domains, (domain, score) -> domain.startsWith("i") && score > 5);        System.out.println(result3); // SomeSpamWeb.com        // chaining with or        List<Domain> result4 = filterBadDomain(domains, bi.or(                (domain, x) -> domain.equalsIgnoreCase("AnythingCorrect.com"))        );        System.out.println(result4); // MostlyCorrect.com, SomethingCorrect.com, AnythingCorrect.com    } // end of public static void main    public static <T extends Domain> List<T> filterBadDomain(    // Before a method name, I have seen 3 keywords (e.g.,  public static void main).    // But there are 4 before filterBadDomain method. (public static <T extends Domain> List<T> )    // Question # 6 : Why?            List<T> list, BiPredicate<String, Integer> biPredicate) { return list.stream() .filter(x -> biPredicate.test(x.getName(), x.getScore())) .collect(Collectors.toList());    } } class Domain {    String name;    Integer score;    public Domain(String name, Integer score) {        this.name = name;        this.score = score;    }    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public Integer getScore() {        return score;    }    public void setScore(Integer score) {        this.score = score;    }    @Override    public String toString() {        return "Domain{" +                "name='" + name + '\'' +                ", score=" + score +                '}';    } }

Tim Moores wrote:Welcome to the Ranch.

Note this comment in the Domain class:

// getters , setters , toString

That means you need to add the usual getter and setter methods: setName, getName, setScore and getScore. (toString is not needed for this example.)

Tim,

Thank you,

Can you please help me by explaining class Domain and filterBadDomain method?

How it is helping entire program?

Sukumar

I was searching for BiPredicate examples.

I found it here 2. BiPredicate as function argument

But this code gave two compile time errors, which are attached herewith.

Though, comments are given along with code, but those comments are insufficient to understand flow of program

I request that any developer please help me with rectifying bugs as well as writing detailed comments after each line.