I have question

Question about the task

Extending AmigoOutputStream

Java Core, Level 8, Lesson 8

Under discussion

I validate but now i delete from QuestionFileOutputStream

implement AmigoOutputStream

and I delete every @Override above implement methods. Now looks like program worked the same. What's different if any is? I think I do now classic wrapper class without inheritance AmigoOutputStream interface? Tell me what you think becouse it's new to me.

package com.codegym.task.task18.task1812;

import java.io.*;

/*
Extending AmigoOutputStream

*/

public class QuestionFileOutputStream  {

    private AmigoOutputStream amigo;

    public QuestionFileOutputStream(AmigoOutputStream amigo) {
        this.amigo = amigo;
    }

    public void flush() throws IOException {
        amigo.flush();

    }


    public void write(int b) throws IOException {
        amigo.write(b);
    }


    public void write(byte[] b) throws IOException {
        amigo.write(b);
    }


    public void write(byte[] b, int off, int len) throws IOException {
        amigo.write(b, off, len);
    }


    public void close() throws IOException {
        System.out.println("Do you really want to close the stream? Y/N");
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String line = "";
        if ((line = reader.readLine()).equals("Y")) {
            amigo.close();
        }
    }
}

package com.codegym.task.task18.task1812;

import java.io.IOException;

public interface AmigoOutputStream {
    void flush() throws IOException;

    void write(int b) throws IOException;

    void write(byte[] b) throws IOException;

    void write(byte[] b, int off, int len) throws IOException;

    void close() throws IOException;
}

package com.codegym.task.task18.task1812;

import java.io.IOException;

public class Solution {
    public static void main(String[] args) throws IOException {
        AmigoOutputStream amigoOutputStream = new AmigoOutputStream() {
            @Override
            public void flush() throws IOException {

            }

            @Override
            public void write(int b) throws IOException {

            }

            @Override
            public void write(byte[] b) throws IOException {

            }

            @Override
            public void write(byte[] b, int off, int len) throws IOException {

            }

            @Override
            public void close() throws IOException {

            }
        };
        QuestionFileOutputStream questionFileOutputStream = new QuestionFileOutputStream(amigoOutputStream);
        questionFileOutputStream.close();
    }
}

Comments (5)

Popular
New
Old

You must be signed in to leave a comment

Guadalupe Gagnon

Level 37 , Tampa, United States

23 January 2023, 15:00

useful

The @Override is not code and is not necessary to add to your code. It is called an annotation and there are many different annotations that tell the compiler something specific about the code. In this case @Override tells the compiler that the method that follows is supposed to override a parent method, and if it does not actually override a parent method then you will get an error that prevents you from compiling. Imagine a hypothetical situation where you are hired to write code that trims unnecessary data from a database of some random client. They already have their own proprietary code that they require you to use since it was designed to work with their system and is secure. The problem is that their code deletes everything and they need a slick algorithm that selectively deletes ONLY unnecessary data. So:

public class Solution {
    public static void main(String[] args) {
        A test = new B();

        test.purge();
    }

    static class A {
        private void threaten(){
            System.out.println("PURGE ENTIRE DATABASE: UNRECOVERABLE");
        }
    }

    static class B extends A{
        //@Override
        void threaten() {
            System.out.println("Purge only unnecessary data artfully");
        }
    }
}

The "A" class would be their code and the "B" class would be your slick algorithm. It is VERY important that your code extends and overrides the original code otherwise very bad stuff would happen. If you run this code you will see the output indicates that very bad stuff happens. This is because "private" methods, such as purge() in the A class, cannot be overridden. Attaching @override to the purge() in B would not let the code compile and run as the IDE would tell you that the method was not actually overriding anything. This example is simple but imagine if you wrote 5000 lines of code without realizing that the parent methods were private.

Guadalupe Gagnon

Level 37 , Tampa, United States

23 January 2023, 15:24

useful

The reason your code above works when removing the "implements" is because there is no code that uses polymorphism that would break by removing implements. If your main method had this instead:

public static void main(String[] args) throws IOException {
   AmigoOutputStream amigoOutputStream = new AmigoOutputStream() {
      @Override
      public void flush() throws IOException { }

      @Override
      public void write(int b) throws IOException { }

      @Override
      public void write(byte[] b) throws IOException { }

      @Override
      public void write(byte[] b, int off, int len) throws IOException { }

      @Override
      public void close() throws IOException { }
   };
   // ↓↓ See change on this line
   AmigoOutputStream questionFileOutputStream = new QuestionFileOutputStream(amigoOutputStream);
   questionFileOutputStream.close();
}

With this change the code will not work until you put "implements" back in.

matemate123

Level 50 , Kraków, Poland

23 January 2023, 15:45

Thanks guys, it's not easy to grasp, but I hope in future when I will have more practice with that, I'll grip it harder, and it's be natural for mind. I was only curious, that it could have influence on performance or something like that. Yours explanation it's helpful and understandable.

Thomas

Level 41 , Bayreuth, Germany

22 January 2023, 17:52

useful

What you have is just an aggregation, a class containing an object of another class and you invoke methods on that object. That is of course doing what you want on the first view as it extends the class by the functionality of the object. But it is not a decorator and it has not its flexibility. That patter is eg. able to exchange decorators at runtime or even chain them together (showing that here and the usage of three decorators on one object).

interface Ufo {
    void fly();
}

class UfoImpl implements Ufo {
    @Override
    public void fly() {
        System.out.print("Ufo is flying. ");
    }
}

class RedUfo implements Ufo {
    Ufo ufo;

    public RedUfo(Ufo ufo) {
        this.ufo = ufo;
    }

    @Override
    public void fly() {
        ufo.fly();
        System.out.print("It's color is red. ");
    }
}

class LaserUfo implements Ufo {
    Ufo ufo;

    public LaserUfo(Ufo ufo) {
        this.ufo = ufo;
    }

    @Override
    public void fly() {
        ufo.fly();
        System.out.print("And it is equipped with a laser gun.");
    }
}

public class Main {
    public static void main(String[] args) {
        // the object to decorate
        Ufo objectToDecorate = new UfoImpl();
        objectToDecorate.fly();

        System.out.println();

        // here the magic begins
        // decorate the ufo with a laser
        Ufo ufo = new LaserUfo(objectToDecorate);
        ufo.fly();

        System.out.println();

        // replace decoration - now ufo has red color
        ufo = new RedUfo(objectToDecorate);
        ufo.fly();

        System.out.println();

        // you even can chain decorators, a red ufo with a laser
        ufo = new LaserUfo(new RedUfo(objectToDecorate));
        ufo.fly();
    }
}

This is an alternative to inheritance and may reduce a lot of overhead.

matemate123

Level 50 , Kraków, Poland

23 January 2023, 15:42