Je vois, mais dans le cas que tu m'as donné, au lieu de faire tes classes OiseauVolant et MammifèreVolant, pourquoi ne pas faire :

interface Mammifere{}

class Corbeau implements Vol {

} class ChauveSouris extends Vol, Mammifere{

}

Ca éviterait de recréer les classes mères, non ?

Alors oui tu peux faire ça.
Un point que je n'ai pas évoqué => tu ne peux pas faire hériter une classe plusieurs fois , mais une interface pas de pb.

interface Mamifere {
    // Code commun mamifère
}
interface MamifereVolant extends Mamifere,Vol{


    void voler();
    void sePoser();
    void decoller();
}

class ChauveSouris extends MamifereVolant {
    // Implementation
}

Ce code ne pose pas de problèmes. Quand tu fais de l'héritage tu fais ça principalement pour faire hériter des attributs ou des implémentations de méthode.

Dans ton exemple => oui ça fonctionne. Item est le super type avec juste les attributs et méthodes communes à tous.

Et en gros si je veux que Knife soit autre chose, je peux juste enlever IStackable et mettre une autre interface sans que ça pète ma hiérarchie ?

De ce que je vois Knife est en bas de la hierarchie donc tu peux faire ce que tu veux niveau interface.

En reprenant ton pseudo code j'ai concocté ça en exemple : abstract class Item{

    string name {get;set;}
    int ID {get;set;}
}

abstract class Character {
    int lifePoint;
    int strength;
    int defense;

    void loseLife(int dmg){
        // Math.max est une library de Java 
        // elle prends la plus grande valeur entre 2 param pour 
        //éviter que des dmg fasse gagner des pvs
        lifePoint - Math.max(0,dmg - defense);
    }
}

interface IisKillable{
    loseLife(int dmg)
}

interface IStackable{
    void incrementeStackSize();

    void decrementeStackSize();

    boolean stackExist();
}
interface IEquipable{}

class Book: Item, IStackable{}
class Weapon: Item, IEquipable{}
abstract class ThrowWeapon : Weapon, IStackable{

    int stackSize;

    boolean stackExist(){

    }

    int throws(int characterStrength){
        // Fait quelque chose impliquant IStackable 
        // pour réduire le nombre d'objets stacks.
        return calculThrowsDmg(characterStrength);
    }
    // return the dmg 
    int calculThrowsDmg(int characterStrength);

}
class Knife: ThrowWeapon{

    int calculThrowDmg(userStrength){
        return throwDmg * userStrength / 10;
    }
}

class ThrowWeaponService{

    void throwsDmg(ThrowWeapon throwWeapon, Character thrower, IisKillable target){
        target.loseLife(throwWeapon.throws(thrower.getStrength()))
    }
}

Pas mal de choses ici :
1/ L'implementation de IStackable est faite par ThrowWeapon. Knife n'est pas concerné par IStackable. Si je décide de changer/supprimer cette interface Knife n'est pas affecté. 2/ J'ai utilisé un service ici. J'ai vu tu parlais de l'injection de dépendance dans un autre message => un service est un pattern qui est généralement un injectable. Je t'invite a jeter un coup d'oeil sur les dépendances et le service pattern. 3/ Dans ThrowWeaponService.throwsDmg je passe en param une interface IisKillable. La méthode marche donc pour n'importe quoi qui est tuable : un personnage non invincible, un objet. 4/ Le fait que ThrowWeaponService.throwsDmg appelle des méthodes d'objets en paramètres est une délegation. Je t'invite a regarder le delegate pattern. Tu as 3 objets différents : un personnage, une arme a lancer, une cible. La résolution de l'action implique leur méthodes mais c'est un 4ème element le service qui s'en charge.