Based on the code, the animals capable of walking are 'Pig' and 'Duck', as their 'canWalk()' method returns true. This demonstrates the concepts of inheritance, where subclasses extend the functionality of a superclass, and method overriding, where subclasses provide a specific implementation for a method defined as abstract in their superclass .

The 'getName()' method is not abstract in the 'Animal' class because it provides a common behavior for retrieving the name of any animal, which is implemented in the superclass itself with no need for subclass-specific logic. Its implementation in the superclass allows consistent and reusable object interaction across all 'Animal' subclasses without requiring each subclass to individually implement this method, ensuring straightforward data encapsulation and retrieval .

When the main method in the 'Farm' class is executed, it prints a list of animals that can either swim or walk: '- Lợn' (Pig), '- Vịt' (Duck), '- Cá' (Fish). Object behavior is determined by invoking the 'canSwim()' and 'canWalk()' methods on each 'Animal' object in the array. If either method returns true, the animal's name is printed, utilizing polymorphism and subclass-specific method overrides .

If the 'Fish' class is modified to make 'canWalk()' return true, the output of the 'printMovableAnimals' method remains unchanged because all current animals ('Pig', 'Duck', 'Fish') already appear in the list, due to either 'canSwim()' or 'canWalk()' being true for each. However, it changes the conceptual understanding that now 'Fish' is attributed the property of walking alongside swimming .

The methods implemented in the 'Pig', 'Duck', and 'Fish' classes are designed to mimic the real-world characteristics of these animals. In the 'Pig' class, 'canWalk()' returns true as pigs walk, and 'canSwim()' returns false since they typically do not swim. In the 'Duck' class, both 'canSwim()' and 'canWalk()' return true, representing a duck's ability to do both. For the 'Fish' class, 'canSwim()' returns true while 'canWalk()' returns false, reflecting fish's natural swimming ability and inability to walk .

The 'printMovableAnimals' method illustrates the principle of encapsulation and conditional logic. By abstracting the movement capabilities into methods ('canSwim()', 'canWalk()') encapsulated within each subclass, the method operates independently of the detailed implementation of these abilities. It uses conditional logic ('if' statement) to decide to print an animal's name based on these encapsulated properties, thereby separating concerns and maintaining clear and logical flow control in object behavior analysis .

The class hierarchy demonstrates polymorphism through the use of the 'Animal' abstract class, which defines abstract methods 'canSwim()' and 'canWalk()'. Each subclass (i.e., 'Pig', 'Duck', 'Fish') provides its own implementation of these methods. This allows objects of these subclasses to be treated as objects of the superclass type ('Animal') while still exhibiting their unique behavior when 'canSwim()' or 'canWalk()' is invoked .

Abstract classes in this program, such as 'Animal', serve as blueprints that define abstract behaviors ('canSwim()', 'canWalk()') without specifying how they should be executed. They promote code reusability by allowing concrete subclasses ('Pig', 'Duck', 'Fish') to inherit shared properties and methods ('getName()'), and enforce design consistency by requiring subclasses to implement any abstract methods. This enhances flexibility as new animal types can be added with minimal changes to existing code by extending the abstract class and providing specific behavior implementations .

The swimming capabilities across the classes demonstrate polymorphism through overridden implementations of 'canSwim()'. The 'Pig' class's 'canSwim()' returns false, indicating pigs do not swim, 'Duck's implementation returns true, reflecting ducks' swimming prowess, while 'Fish' also returns true, consistent with their aquatic nature. Despite being called on the same method signature, the method behaves differently across these subclasses due to polymorphic dynamic method binding, allowing diverse behaviors through a unified interface .

The concept of inheritance in this code base supports scalability by allowing the addition of new animal classes that inherit from the 'Animal' superclass. Future animals can be implemented by creating new subclasses and providing specific implementations for 'canSwim()' and 'canWalk()'. This accommodates easy expansion without modifying existing code, thus maintaining the integrity and scalability of the design through adherence to the open/closed principle .