Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/output-java-program-set-7/ below:

Output of Java Program | Set 7

Last Updated : 28 Jun, 2021

Intermediate Predict the output of following Java Programs.

public class Calculator
{
    int num = 100;
    public void calc(int num)  { this.num = num * 10;  }
    public void printNum()     { System.out.println(num); }

    public static void main(String[] args)
    {
        Calculator obj = new Calculator();
        obj.calc(2);
        obj.printNum();
    }
}

A) 20 B) 100 C) 1000 D) 2

Here the class instance variable name(num) is same as

method local variable name(num). So for referencing class instance variable from

method,

keyword is used. So in statement

,

represents local variable of the method whose value is 2 and

represents class instance variable whose initial value is 100. Now in

method, as it has no local variable whose name is same as class instance variable, so we can directly use

to reference instance variable, although

can be used.

public class MyStuff
{
    String name;

    MyStuff(String n) {  name = n;  }

    public static void main(String[] args)
    {
        MyStuff m1 = new MyStuff("guitar");
        MyStuff m2 = new MyStuff("tv");
        System.out.println(m2.equals(m1));
    }

    @Override
    public boolean equals(Object obj)
    {
        MyStuff m = (MyStuff) obj;
        if (m.name != null)  { return true;  }
        return false;
    }
}

A) The output is true and MyStuff fulfills the Object.equals() contract. B) The output is false and MyStuff fulfills the Object.equals() contract. C) The output is true and MyStuff does NOT fulfill the Object.equals() contract. D) The output is false and MyStuff does NOT fulfill the Object.equals() contract.

C) The output is true and MyStuff does NOT fulfill the Object.equals() contract.

As

method in Object class, compares two objects on the basis of equivalence relation. But here we are just confirming that the object is null or not, So it doesn't fulfill

contract. As

is not null, true will be printed.

class Alpha
{
    public String type = "a ";
    public Alpha() {  System.out.print("alpha "); }
}

public class Beta extends Alpha
{
    public Beta()  {  System.out.print("beta ");  }

    void go()
    {
        type = "b ";
        System.out.print(this.type + super.type);
    }

    public static void main(String[] args)
    {
        new Beta().go();
    }
}

A) alpha beta b b B) alpha beta a b C) beta alpha b b D) beta alpha a b

A) alpha beta b b

The statement

executes in two phases. In first phase

class constructor is called. There is no instance member present in

class. So now

class constructor is executed. As

class extends

class, so call goes to

class constructor as first statement by default(Put by the compiler) is

in the

class constructor. Now as one instance variable(

) is present in

class, so it will get memory and now

class constructor is executed, then call return to

class constructor next statement. So

is printed. In second phase

method is called on this object. As there is only one variable(

) in the object whose value is

. So it will be changed to

and printed two times. The

here is of no use.

public class Test
{
    public static void main(String[] args)
    {
        StringBuilder s1 = new StringBuilder("Java");
        String s2 = "Love";
        s1.append(s2);
        s1.substring(4);
        int foundAt = s1.indexOf(s2);
        System.out.println(foundAt);
    }
}

A) -1 B) 3 C) 4 D) A

is thrown at runtime.

C) 4

method,concatenate the str to

. The

method return the String from the given index to the end. But as there is no any String variable to store the returned string,so it will be destroyed.Now

method return the index of first occurrence of

. So 4 is printed as s1="JavaLove".

class Writer
{
    public  static void write()
    {
        System.out.println("Writing...");
    }
}
class Author extends Writer
{
    public  static void write()
    {
        System.out.println("Writing book");
    }
}

public class Programmer extends Author
{
    public  static void write()
    {
        System.out.println("Writing code");
    }

    public static void main(String[] args)
    {
        Author a = new Programmer();
        a.write();
    }
}

A) Writing... B) Writing book C) Writing code D) Compilation fails

B) Writing book

Since static methods can't be overridden, it doesn't matter which class object is created. As

is a

referenced type, so always

class method is called. If we remove

method from

class then

class method is called, as

class extends

class.

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4