One characteristic feature of object-oriented systems and knowledge bases (semantic data models, conceptual modeling languages, Al frames) is that they offer as a basic paradigm the notion of objects grouped into classes, which are themselves organized in subclass hierarchies. Through ideas such as inheritance and bounded polymorphism, this feature supports the technique of "abstraction by generalization", which has been argued to be of importance in designing Information Systems [11, 2). We provide in this paper examples demonstrating that in some applications over-generalization is likely to occur: an occasional natural subclass may contradict in some way one rf its superclass definitions, and thus turn out not to be a strict subtype of this superclass. A similar problem arises when an object is allowed to be a member of several classes which make incompatible predictions about its type. We argue that none of the previous approaches suggested to deal with such situations is entirely satisfactory. A language feature is therefore presented to permit class definitions which contradict aspects of other classes, such as superclasses, in an object-based language. In essence, the approach requires contradictions among class definitions to be explicitly acknowledged. We define a semantics of the resulting language, which restores the condition that subclasses are both subsets and subtypes, and deals correctly with the case when an object can belong to several classes. This is done by separating the notions of "class" and "type", and it allows query compilers to detect type errors as well as eliminate some run-time checks in queries, even in the presence of "contradictory" class definitions.