Why A isn't printed ?why isn't in outpout

Answer 1

Here try reading this:
https://www.sololearn.com/Blog/38/8-simple-rules-to-get-help-from-the-community/

Answer 2

because aliens?

it would help if we could see the code

Answer 3

Hi Jay there s a code i don't understand .I've published it.It's the only code i got published

Answer 4

https://code.sololearn.com/cC2CG3Ykc3dC/?ref=app

Answer 5

Hi Hamed,

Your question looks quite similar to one I had to ask myself while I studied the material on Polymorphism (Overriding & Overloading). Kindly take a look at the code below and see if this is where you need clarity.

class A {
    public void do() {
        System.out.println("A");
    }

    public void do(String str) {
        System.out.println(str);
    }
}

class B {
    public static void main(String[] args) {
        A object = new A();
        object.do("B");
    }
}

I took a closer look at the code in order to see what I was missing -- why the output did not have "A" printed to it like I (erroneously) expected it to. Here's what I found:

The first version of the do() method specified in class A of this code WILL ONLY print the String "A" to the output on one condition -- that is, if the do() method is called anywhere within the main method using the "object" instance created from class A as follows:

object.do();

However, according to the given code, that has not been done. Instead, just the second version of the do() method which takes a String argument/parameter has been called as shown below:

object.do ("B");

Answer 6

Another point to note (this was WHAT actually got me confused at first) is that the following code which creates the "object" instance of the class A...

A object = new A();

...WILL NOT print the String value "A" to the output. This would have happened if the first version of the do() method was specified AS A CONSTRUCTOR. Even then, the method name would have to be different from do() since it would need to have the same name as its class. Kindly look through the modified code below:

class A {
A() {
        System.out.println("A");
    }

public void do(String str) {
        System.out.println(str);
    }
}

class B {
    public static void main(String[] args) {
        A object = new A();
        object.do("B");
    }
}

Now, the output of this code will be:

A
B

This is because the previous do() method has been re-specified as a constructor with the "in-built" functionality of printing the String value "A" to the output each time a new instance of class A is created. Therefore, this piece of code...

A object = new object();

...is precisely what becomes responsible for printing "A" to the output, while another piece of code...

object.do("B");

...prints the String value "B" to the output right after "A".

I hope this helped.