Using inheritance, one class can acquire the properties of others. Consider the following Animal class:
class Animal{
void walk(){
System.out.println("I am walking");
}
}
This class has only one method, walk. Next, we want to create a Bird class that also has a fly method. We do this using extends keyword:
class Bird extends Animal {
void fly() {
System.out.println("I am flying");
}
}
Finally, we can create a Bird object that can both fly and walk.
public class Solution{
public static void main(String[] args){
Bird bird = new Bird();
bird.walk();
bird.fly();
}
}
The above code will print:
I am walking
I am flying
This means that a Bird object has all the properties that an Animal object has, as well as some additional unique properties.
The code above is provided for you in your editor. You must add a sing method to the Bird class, then modify the main method accordingly so that the code prints the following lines:
I am walking
I am flying
I am singing
in java
class Animal{
void walk(){
System.out.println("I am walking");
}
}
class Bird extends Animal {
void fly() {
System.out.println("I am flying");
}
void sing() {
System.out.println("I am singing");
}
}
public class Solution{
public static void main(String[] args){
Bird bird = new Bird();
bird.walk();
bird.fly();
bird.sing();
}
}
To add a `sing` method to the Bird class, you can simply add the following code within the Bird class definition:
```java
void sing() {
System.out.println("I am singing");
}
```
Here's the modified `Bird` class with the `sing` method added:
```java
class Bird extends Animal {
void fly() {
System.out.println("I am flying");
}
void sing() {
System.out.println("I am singing");
}
}
```
Now, to modify the `main` method in the `Solution` class so that it prints "I am walking", "I am flying", and "I am singing", add a call to the `sing` method after the call to `fly`. Here's the modified `main` method:
```java
public static void main(String[] args) {
Bird bird = new Bird();
bird.walk();
bird.fly();
bird.sing();
}
```
When you run the updated code, it will print:
```
I am walking
I am flying
I am singing
```
To add the sing method to the Bird class, you can simply define the method in the Bird class similar to how the walk and fly methods are defined.
Here's the modified Bird class:
```java
class Bird extends Animal {
void fly() {
System.out.println("I am flying");
}
void sing() {
System.out.println("I am singing");
}
}
```
Now, to modify the main method in the Solution class to print the desired lines, you need to call the sing method on the bird object after calling the walk and fly methods.
Here's the updated main method:
```java
public class Solution {
public static void main(String[] args) {
Bird bird = new Bird();
bird.walk();
bird.fly();
bird.sing();
}
}
```
When you run the code, it will output:
```
I am walking
I am flying
I am singing
```
This demonstrates how inheritance allows the Bird class to acquire the walk method from the Animal class, and the sing method added to the Bird class can also be accessed.