First of all, there is really only one way to do inheritance in
Java: by creating a subtype of some type (creating a subclass, or implementing an interface).
The terms "type inheritance" and "implementation inheritance" are more about why you are using inheritance. Type inheritance means that your intention is to create a new type, which is a specialization of its supertype. Implementation inheritance means that you are using inheritance because you want to reuse code in the superclass for multiple subclasses, so that you don't have to copy and paste the same code in the subclasses.
In my opinion, using inheritance purely because you want to reuse code is not a good idea. There are other ways to reuse code (for example by using composition instead of inheritance).
In the standard JDK classes you can find examples of how inheritance is misused in this way, leading to badly designed classes. One example is the class java.sql.Timestamp. It inherits from java.util.Date, but users should not regard a java.sql.Timestamp as if it's a subtype of java.util.Date, as its API documentation explains:
Due to the differences between the Timestamp class and the java.util.Date class mentioned above, it is recommended that code not view Timestamp values generically as an instance of java.util.Date. The inheritance relationship between Timestamp and java.util.Date really denotes implementation inheritance, and not type inheritance.
This is just very bad design - it makes it very easy for users of class java.sql.Timestamp to make mistakes and use it in a way that it was not intended.