Coupling refers to dependencies between modular section of code, be they functions, classes, namespaces, header files, whatever.

Unneccessary coupling of code leads to code which is hard to maintain. Essentially what happens is a domino effect where changes to one section of code neccessitate changes in entirely unrelated sections of code. With some experience programmers quickly learn the harmful effects of over-coupling.

Judicious coupling (such as through inheritance) however is neccessary to a certain degree in order to maintain code cohesion, (i.e. logical grouping of related segments of code), and can be used to reduce unneccessary coupling elsewhere.

Within the context of OOP a class is the primary modular unit. A class which makes all of its fields public (without good reason) is an example of over-coupling. Any change to the class implementation will reverberate and affect any other class which plays with its member fields.

When one class inherits from another it increases coupling, obviously, but it does so in a very controlled manner. The thing that many programmers seem to be overlooking is that when using base classes, often what happens is that a new class is created solely to represent common functionality, so coupling between this base class and inherited classes is to be expected.

Consider the following example:

class Cat {
  void meow();
  void eat(); 
  void sleep(); 
};

class Dog {
  void bark();
  void eat(); 
  void sleep(); 
};

class Bird {
  void tweet(); 
  void eat(); 
  void sleep();
};

class Pet {
  void eat(); 
  void sleep();
}

class Cat : Pet {
  void meow();
};

class Dog : Pet { 
  void bark();
};

class Bird : Pet {
  void tweet(); 
};