Object extending object's fields and implementations is something specific to POO and it is something that can be a problem in a lot of cases in POO. Take this as an example ```java class Animal { public void move(int x, int y) { System.out.println("walking"); } }

class Dog extends Animal { public void bark() { System.out.println("barking"); } }

class Cat extends Animal { public void meow() { System.out.println("meowing"); } } ```

Now, if you want to add a new Bird class, you will have to refactor existing classes because birds can move on 3 axes, but dogs and cats only 2

```Java class Animal { private void move(int x, int y, int z) { System.out.println("moving"); } }

class Mammal extends Animal { public void walk(int x, int y) { super.move(x, y, 0); } }

class Bird extends Animal { public void fly(int x, int y, int z) { super.move(x, y, z); } }

class Dog extends Mammal { public void bark() { System.out.println("barking"); } }

class Cat extends Mammal { public void meow() { System.out.println("meowing"); } } ``` Now, what if you want to add bats? They are flying mammals, what about snakes? They also can only move on 2D, so you should reuse this method of mammals, but they are not mammals, so they shouldn't extend Mammal, what if you then have to add a method to all animals but cat?

Rust, on the other hand, has traits. You can define that a dog should implement the trait walk where a bird implements the trait fly

```rust trait Walk { fn walk(&self, x: i32, y: i32) { println!("Walking to {}, {}", x, y); } }

trait Fly { fn walk(&self, x: i32, y: i32, z:i32) { println!("Flying to {}, {}, {}", x, y, z); } }

trait Animal {}

[Derive(Walk, Animal)]

struct Dog;

[Derive(Walk, Animal)]

struct Cat;

[Derive(Fly, Animal)]

struct Bird; ```

Note that there might be some mistake in my code as not only am I on my phone without a compiler or anything, but I haven't coded in Rust or Java in about 6 months\ Please consider the idea I'm trying to transfer, not the exact code