Question

Please I need help with the following questions in JAVA programming language. Please comment the code to help me understand, thanks.

Exercise 1: Inheritance

1. Firstly, create and compile a simple class called Parent. Give it the following behaviour:
a. A default constructor that does nothing other than print out “Parent default
constructor” using System.out
b. A single method called getMessage which returns a String, e.g. “Parent message”
2. Next, create and compile a class called Child. Give it the following behaviour
a. Do not give it a constructor
b. Override the parent’s getMessage method to return an alternative String. E.g.
“Child message”
c. A main method which creates an instance of the Child object, and then writes the
value returned by its getMessage method to the command line.
d. What happens when the class is run?
3. Alter the Child class to give it a default constructor which prints out “Child default
constructor”. Compile and run the application again and identify what happens.
4. Alter the implementation of the getMessage method in the Child class so that it first
calls the parent class method, then concatenates the result with its own value to build a
combined message. E.g. returning “Parent message and Child message”.
5. Alter the Parent class by
a. Adding a new constructor that accepts a String argument. This should be used to
initialise a private member variable, myMessage. Again write a message to the
console that indicates that the constructor has been called.
b. Alter the getMessage method so that it returns the value of the myMessage
rather than a fixed message.
c. Now alter the Child class so that it from its default constructor it calls the new
constructor on the parent class.
6. Alter the myMessage member variable in the Parent class so that it is declared to be
protected. Confirm that the Child class can now refer to the variable directly, rather
than having to call its parent’s version of getMessage to build the combined message.
Can you think of the pros and cons of the two different mechanisms?


Exercise 2: Abstract Classes and Methods

1. Create an abstract class called AbstractParent. Give it the following two methods:
a. A public method called getMessage that accepts no parameters and returns a
String. This method should call a second method, generateString that again
just returns a String.
b. Define generateString so that it a protected abstract method.
2. Create a second class called SecondChild, which extends AbstractParent.
a. Implement the generateString method defined by its parent to return a
suitable String
b. Add a main method that creates an instance of SecondChild and invokes its
getMessage method. Can you identify what is happening here?

Answer 1

Exercise 1: Inheritance

2.

d. What happens when the class is run?

public class Parent {
    public Parent(){
        System.out.println("Parent default constructor");
    }


    public String getMessage(){
        return "Parent Message";
    }

}

public class Child extends Parent {


    @Override
    public String getMessage() {
        return "Child Message";
    }

    public static void main(String[] args) {
        Child c = new Child();
        System.out.println(c.getMessage());
    }

}

OUTPUT

Parent default constructor
Child message

3.

public class Parent {
    public Parent(){
        System.out.println("Parent default constructor");
    }


    public String getMessage(){
        return "Parent Message";
    }

}

public class Child extends Parent {

    public Child() {
        System.out.println("Child default constructor");
    }

    @Override
    public String getMessage() {
        return "Child Message";
    }

    public static void main(String[] args) {
        Child c = new Child();
        System.out.println(c.getMessage());
    }

}

OUTPUT

Parent default constructor
Child default constructor
Child Message

4.

public class Parent {
    public Parent(){
        System.out.println("Parent default constructor");
    }


    public String getMessage(){
        return "Parent Message";
    }

}

public class Child extends Parent {

    public Child() {
        System.out.println("Child default constructor");
    }

    @Override
    public String getMessage() {
        return super.getMessage()+" Child Message";
    }

    public static void main(String[] args) {
        Child c = new Child();
        System.out.println(c.getMessage());
    }

}

OUTPUT

Parent default constructor
Child default constructor
Parent Message Child Message

After point 6 code will look like

//Parent.java

public class Parent {
    protected String myMessage;
    public Parent(){
        System.out.println("Parent default constructor");
    }

    // 5.a
    public Parent(String myMessage) {
        this.myMessage = myMessage;
        System.out.println("Parent constructor with String argument ");
    }

    public String getMessage(){
        return myMessage; // 5.b
    }

}

//Child.java

public class Child extends Parent {

    public Child() {
        super(""); // 5.c
        System.out.println("Child default constructor");
    }

    @Override
    public String getMessage() {
        // modifying the parent class variable myObject as it was protected
        super.myMessage = "child object message"; // 6
        return super.getMessage() + " Child Message"; // 4
    }

    public static void main(String[] args) {
        Child c = new Child();
        System.out.println(c.getMessage());
    }

}

// OUTPUT

Parent constructor with String argument
Child default constructor
child object message Child Message

Can you think of the pros and cons of the two different mechanisms?

pros:

protected variable can be access like public but within the package only

cons:

as it is protected any object can alter this and lets suppose if any validation required that will never apply, that can result malformed.

Exercise 2: Abstract Classes and Methods

//AbstractParent.java
public abstract class AbstractParent {
    public String getMessage(){
        return generateString();
    }

    protected abstract String generateString();
}

//SecondChild.java

public class SecondChild extends AbstractParent {

    @Override
    protected String generateString() {
        return "SecondChild Message";
    }

    public static void main(String[] args) {
        SecondChild sc = new SecondChild();
        System.out.println(sc.getMessage());
    }
}

//OUTPUT

SecondChild Message

Can you identify what is happening here?

ParentAbstract is the abstract class with abstract generateString which is implemented in SecondChild class

when it calls the getMessage it invoke the abstract function and call where its implemented