-
Notifications
You must be signed in to change notification settings - Fork 0
/
AnimalCatalog.java
154 lines (128 loc) · 4.41 KB
/
AnimalCatalog.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
// Write a program which will let the user catalog different kinds of animals based on their traits. It
// is known that all animals have their weight and a known amount of legs. Fish vary in the amount of fins
// and they can swim. Cats can have different kinds of fur patters and they walk. Ducks vary in the bill
// shape and can walk, fly and swim. Animals are naturally ordered by their weight.
// Based on the description and good programming practises create accurate classes and interfaces including
// their hierarchy. Then, in the main method create an array of all mentioned animals and sort it. Then
// create another three arrays that will hold animals that can: walk, fly and swim
import java.util.*;
// Interface for animals that can move
interface Movable {
void move();
}
// Interface for animals that can swim
interface Swimmable {
void swim();
}
// Interface for animals that can fly
interface Flyable {
void fly();
}
// Animal class with weight and number of legs properties
abstract class Animal implements Comparable<Animal> {
protected double weight;
protected int legs;
public Animal(double weight, int legs) {
this.weight = weight;
this.legs = legs;
}
@Override
public int compareTo(Animal other) {
return Double.compare(this.weight, other.weight);
}
}
// Fish class
class Fish extends Animal implements Swimmable {
private int fins;
public Fish(double weight, int legs, int fins) {
super(weight, legs);
this.fins = fins;
}
@Override
public void swim() {
System.out.println("The fish is swimming.");
}
}
// Cat class
class Cat extends Animal implements Movable {
private String furPattern;
public Cat(double weight, int legs, String furPattern) {
super(weight, legs);
this.furPattern = furPattern;
}
@Override
public void move() {
System.out.println("The cat is walking.");
}
}
// Duck class
class Duck extends Animal implements Movable, Flyable, Swimmable {
private String billShape;
public Duck(double weight, int legs, String billShape) {
super(weight, legs);
this.billShape = billShape;
}
@Override
public void move() {
System.out.println("The duck is walking.");
}
@Override
public void fly() {
System.out.println("The duck is flying.");
}
@Override
public void swim() {
System.out.println("The duck is swimming.");
}
}
public class AnimalCatalog {
public static void main(String[] args) {
// Create an array of animals
Animal[] animals = {
new Fish(0.5, 0, 2),
new Cat(4.5, 4, "Tabby"),
new Duck(2.0, 2, "Wide"),
new Fish(0.3, 0, 1),
new Duck(1.5, 2, "Narrow"),
new Cat(3.2, 4, "Calico")
};
// Sort the array of animals by weight
Arrays.sort(animals);
// Create arrays to hold animals that can walk, fly, and swim
List<Movable> walkingAnimals = new ArrayList<>();
List<Flyable> flyingAnimals = new ArrayList<>();
List<Swimmable> swimmingAnimals = new ArrayList<>();
// Populate the arrays based on the type of animal
for (Animal animal : animals) {
if (animal instanceof Movable) {
walkingAnimals.add((Movable) animal);
}
if (animal instanceof Flyable) {
flyingAnimals.add((Flyable) animal);
}
if (animal instanceof Swimmable) {
swimmingAnimals.add((Swimmable) animal);
}
}
// Print the sorted array of animals
System.out.println("Sorted animals:");
for (Animal animal : animals) {
System.out.println("Weight: " + animal.weight + ", Legs: " + animal.legs);
}
// Print animals that can walk
System.out.println("\nAnimals that can walk:");
for (Movable animal : walkingAnimals) {
animal.move();
}
// Print animals that can fly
System.out.println("\nAnimals that can fly:");
for (Flyable animal : flyingAnimals) {
animal.fly();
}
// Print animals that can swim
System.out.println("\nAnimals that can swim:");
for (Swimmable animal : swimmingAnimals) {
animal.swim();
}
}
}