extendsは 拡張 クラスのためのものです。
implementsは 実装用 インターフェースです
インタフェースと通常のクラスの違いは、インタフェースでは宣言されたメソッドを実装できないことです。メソッドを実装できるのは、インタフェースを「実装する」クラスだけです。 C++に相当するインタフェースは抽象クラスになります（厳密には同じではありませんが、ほとんど）。
また、Javaはクラスの多重継承）をサポートしていません。これは複数のインタフェースを使用することで解決されます。
public interface ExampleInterface {
public void doAction();
public String doThis(int number);
}
public class sub implements ExampleInterface {
public void doAction() {
//specify what must happen
}
public String doThis(int number) {
//specfiy what must happen
}
}
今クラスを拡張する
public class SuperClass {
public int getNb() {
//specify what must happen
return 1;
}
public int getNb2() {
//specify what must happen
return 2;
}
}
public class SubClass extends SuperClass {
//you can override the implementation
@Override
public int getNb2() {
return 3;
}
}
この場合
Subclass s = new SubClass();
s.getNb(); //returns 1
s.getNb2(); //returns 3
SuperClass sup = new SuperClass();
sup.getNb(); //returns 1
sup.getNb2(); //returns 2
オブジェクト指向プログラミングにおける動的束縛、多態性、一般的な継承について）さらに研究を進めることをお勧めします
あなたのプロフィールにいくつかのC++の質問があることに気づきました。 多重継承 C++からの概念（他の複数のクラスから特性を継承するクラスを指す）を理解している場合、Javaはこれを許可していませんが、キーワードinterfaceを持っています。 C++の仮想クラス。多くの人が言っているように、あなたはクラスをextendし（そしてあなたは1つだけから拡張することができます）、そしてあなたはimplementインターフェースを - あなたのクラスはあなたが好きなだけ多くのインターフェースを実装できます。
つまり、これらのキーワードとその使用を管理する規則によって、Javaでの多重継承の可能性が明確になります（スーパークラスを1つだけ持つことができますが、複数のインターフェースを実装することができます）。
extendsは、 基本クラス から継承している場合（つまり、その機能を拡張している場合）のものです。
implementsは interface を実装しているときのためのものです。
ここから始めるのに良い場所です： インタフェースと継承 。
一般的に implements はinterfaceを実装するために使用され、 extends は基本クラスの振る舞いのextensionまたはabstract classに使用されます。
extends ：派生クラスは基本クラスを拡張できます。確立された関係の振る舞いを再定義することができます。派生クラス "is a"の基本クラス型
implements ：あなたは契約を履行しています。インタフェース "a"の機能を実装するクラス。
Java 8リリースでは、interfaceはinterface内にdefaultメソッドを持つことができます。これはインタフェース自体に実装を提供します。
それぞれを使用する場合については、この質問を参照してください。
物事を理解するための例。
public class ExtendsAndImplementsDemo{
public static void main(String args[]){
Dog dog = new Dog("Tiger",16);
Cat cat = new Cat("July",20);
System.out.println("Dog:"+dog);
System.out.println("Cat:"+cat);
dog.remember();
dog.protectOwner();
Learn dl = dog;
dl.learn();
cat.remember();
cat.protectOwner();
Climb c = cat;
c.climb();
Man man = new Man("Ravindra",40);
System.out.println(man);
Climb cm = man;
cm.climb();
Think t = man;
t.think();
Learn l = man;
l.learn();
Apply a = man;
a.apply();
}
}
abstract class Animal{
String name;
int lifeExpentency;
public Animal(String name,int lifeExpentency ){
this.name = name;
this.lifeExpentency=lifeExpentency;
}
public void remember(){
System.out.println("Define your own remember");
}
public void protectOwner(){
System.out.println("Define your own protectOwner");
}
public String toString(){
return this.getClass().getSimpleName()+":"+name+":"+lifeExpentency;
}
}
class Dog extends Animal implements Learn{
public Dog(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName()+" can remember for 5 minutes");
}
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " will protect owner");
}
public void learn(){
System.out.println(this.getClass().getSimpleName()+ " can learn:");
}
}
class Cat extends Animal implements Climb {
public Cat(String name,int age){
super(name,age);
}
public void remember(){
System.out.println(this.getClass().getSimpleName() + " can remember for 16 hours");
}
public void protectOwner(){
System.out.println(this.getClass().getSimpleName()+ " won't protect owner");
}
public void climb(){
System.out.println(this.getClass().getSimpleName()+ " can climb");
}
}
interface Climb{
public void climb();
}
interface Think {
public void think();
}
interface Learn {
public void learn();
}
interface Apply{
public void apply();
}
class Man implements Think,Learn,Apply,Climb{
String name;
int age;
public Man(String name,int age){
this.name = name;
this.age = age;
}
public void think(){
System.out.println("I can think:"+this.getClass().getSimpleName());
}
public void learn(){
System.out.println("I can learn:"+this.getClass().getSimpleName());
}
public void apply(){
System.out.println("I can apply:"+this.getClass().getSimpleName());
}
public void climb(){
System.out.println("I can climb:"+this.getClass().getSimpleName());
}
public String toString(){
return "Man :"+name+":Age:"+age;
}
}
出力：
Dog:Dog:Tiger:16
Cat:Cat:July:20
Dog can remember for 5 minutes
Dog will protect owner
Dog can learn:
Cat can remember for 16 hours
Cat won't protect owner
Cat can climb
Man :Ravindra:Age:40
I can climb:Man
I can think:Man
I can learn:Man
I can apply:Man
理解するべき重要な点：
- DogとCatは動物で、
rememberからname,lifeExpentencyを共有することでprotectOwner（）とAnimal（）を拡張しました。 - 猫は登ることができますが（）犬はできません。犬は考えることができます（）ができませんが、猫はできません。これらの特定の機能は、その機能を実装することによって
CatおよびDogに追加されます。 - 人間は動物ではありませんが、彼は
Think,Learn,Apply,Climbできます
これらの例に目を通すことによって、あなたはそれを理解することができます
無関係のクラスはインターフェースを通じて機能を持つことができますが、関連クラスは基本クラスの拡張によって振る舞いをオーバーライドします。
classはinterfaceを「実装」することしかできません。クラスはclassを "拡張"するだけです。同様に、interfaceは別のinterfaceを拡張することができます。
classは他のclassを1つだけ拡張できます。 classはいくつかのinterfaceを実装できます。
代わりに、abstract classesとinterfacesをいつ使用するかを知りたい場合は、次のスレッドを参照してください。 Interface vs Abstract Class（一般的なオブジェクト指向）
インターフェイスは、オブジェクトが実行できるアクションの説明です。たとえば、ライトスイッチを切り替えると、ライトが点灯しますが、どのようにしても構いません。オブジェクト指向プログラミングでは、インターフェイスは、オブジェクトが「X」になるために必要なすべての機能の記述です。繰り返しになりますが、例として、ライトを「実行」するものには、turn_on（）メソッドとturn_off（）メソッドがあります。インターフェイスの目的は、コンピュータにこれらのプロパティを適用させ、TYPE Tのオブジェクト（インターフェイスが何であれ）にX、Y、Zなどの関数が必要であることを認識させることです。
インターフェイスは、コンピュータがオブジェクト（クラス）に特定のプロパティを適用できるようにするプログラミング構造/構文です。たとえば、車のクラスとスクーターのクラス、トラックのクラスがあるとします。これら3つのクラスはそれぞれstart_engine（）アクションを持つべきです。各車両の「エンジンの始動方法」は各クラスに任されていますが、start_engineアクションが必要なのは、 interface のドメインです。
AはBを拡張します。
AとBは両方ともクラスまたは両方のインターフェース
AはBを実行します
Aはクラス、Bはインタフェースです
AがインターフェースでBがクラスの残りのケースは、Javaでは正しくありません。
Extends ：これは、親クラスの属性を基本クラスにするために使用され、子クラスでオーバーライドできる定義済みのメソッドを含むことができます。
Implements ：これは、子クラスで定義することによってインタフェース（関数シグネチャのみを持つが定義は持たない親クラス）を実装するために使用されます。
特別な条件が1つあります。「新しいインタフェースを既存のインタフェースの子にしたい場合はどうすればよいですか？」上記の条件では、子インターフェース extends 親インターフェース。
Implementsはインターフェースに使用され、extendsはクラスを拡張するために使用されます。
よりわかりやすく表現するために、インターフェースはサウンドのようなものです。つまり、インターフェースです。モデルには、自分のアイデアと共にそれを適用し、従う必要があります。
Extendはクラスに使用されます。ここでは、より多くの機能を追加することによって既存のものを拡張しています。
もう少しメモ：
インタフェースは他のインタフェースを拡張できます。
また、特定のシナリオに対してインターフェースの実装とクラスの拡張のどちらかを選択する必要がある場合は、インターフェースの実装に進みます。クラスは複数のインタフェースを実装できますが、1つのクラスしか拡張できないためです。
下の図に示すように、クラスは別のクラスを拡張し、インタフェースは別のインタフェースを拡張しますが、クラスはインタフェースを実装します。 
もっと 詳細
サブクラスがクラスを拡張すると、サブクラスはスーパータイプで定義されたコードを継承（再利用）してオーバーライドすることができます。クラスがインタフェースを実装すると、そのクラスから作成されたオブジェクトを、そのインタフェースの値を必要とするあらゆるコンテキストで使用できるようになります。
ここでの真のキャッチは、我々が何かを実装している間、それは単にそれらがそれらのメソッドをそのまま使っていることを意味するということです。値と戻り値の型を変更する余地はありません。
しかし、我々が何かを拡張しているとき、それはあなたのクラスの拡張になります。変更したり、使用したり、再利用したりできます。スーパークラスと同じ値を返す必要はありません。
どちらのキーワードも、Java言語で独自の新しいクラスを作成するときに使用されます。
違い：implementsは、クラス内でJavaインタフェースの要素を使用していることを意味します。 extendsは、拡張している基本クラスのサブクラスを作成していることを意味します。子クラスで拡張できるクラスは1つだけですが、必要なだけインターフェイスを実装できます。
詳細については、 interface にあるOracleのドキュメントページを参照してください。
これは、インターフェースが何であるか、そしてそれらを使用することに関する慣習を明確にするのを助けることができます。
最も単純な用語では、extendsはclassから継承するために使用され、implementsはクラスにinterfaceを適用するために使用されます。
extends：
public class Bicycle {
//properties and methods
}
public class MountainBike extends Bicycle {
//new properties and methods
}
implements：
public interface Relatable {
//stuff you want to put
}
public class RectanglePlus implements Relatable {
//your class code
}
まだ混乱がある場合は、これをお読みください。 https://docs.Oracle.com/javase/tutorial/Java/IandI/subclasses.htmlhttps://docs.Oracle.com/javase/ tutorial/Java/IandI/usinginterface.html
これら2つのキーワードは、継承と直接結び付いています。これがOOPの中心的な概念です。あるクラスを別のクラスに継承するときは extends を使用できますが、クラスを継承できない場合は implements を使用して使用できます。 別のインターフェースからインターフェースを継承するための キーワードを拡張します。
SubClass extends SuperClass を使用するのは、サブクラスが SuperClass ですでに宣言されている機能（メソッドまたはインスタンス変数）を使用する場合だけです。 SuperClass （メソッドのオーバーライド）の機能を少し変更する。しかし、たとえば、たとえば、私はAnimalクラス（ SuperClass ）とDogクラス（ SubClass ）があり、Animalクラスで定義したメソッドはほとんどありません。 doEat （）; 、 doSleep （）; ... などなど。
さて、私のDogクラスは単純にAnimalクラスを拡張することができます、私の犬にAnimalクラスで宣言されたメソッドのいずれかを使用させたい場合は、単にDogオブジェクトを作成することによってそれらのメソッドを呼び出すことができます。だからこのように私は私が食べることができて眠ることができる犬を飼っていることを保証することができて、そして私がその犬にさせたい他のことは何でもします。
さて、ある日、猫の恋人が私たちのワークスペースにやってきて、彼女がAnimalクラスを拡張しようとしているとします（猫も食べて眠ります）。彼女はCatオブジェクトを作り、メソッドの呼び出しを開始します。
しかし、誰かがAnimalクラスのオブジェクトを作ろうとしているとしましょう。猫の眠り方、犬の食べ方、ゾウの飲み方がわかります。しかし、それはAnimalクラスのオブジェクトを作るのには意味がありません。それはテンプレートであり、我々は一般的な食事のやり方を望んでいないので。
そうではなく、誰もインスタンス化できないが他のクラスのテンプレートとして使用できる抽象クラスを作成したいと思います。
結論として、Interfaceはメソッド実装を含まず、定義（テンプレート）のみを含む抽象クラス（純粋な抽象クラス）に他なりません。そのため、インターフェースを実装する人は誰でも、 doEat （）のテンプレートがあることを知っているだけです。および doSleep （）。しかし彼らは独自の doEat （）を定義する必要があります。および doSleep （）。必要に応じてメソッド。
SuperClassの一部を再利用したい場合にのみ拡張し（ただし、必要に応じてSuperClassのメソッドをいつでもオーバーライドできます）、テンプレートを作成して自分で定義したい場合に実装します。 （あなたの必要性に従って）。
私はあなたとコードの一部を共有するつもりです：あなたは入力の異なるセットでそれを試してみて、結果を見てください。
class AnimalClass {
public void doEat() {
System.out.println("Animal Eating...");
}
public void sleep() {
System.out.println("Animal Sleeping...");
}
}
public class Dog extends AnimalClass implements AnimalInterface, Herbi{
public static void main(String[] args) {
AnimalInterface a = new Dog();
Dog obj = new Dog();
obj.doEat();
a.eating();
obj.eating();
obj.herbiEating();
}
public void doEat() {
System.out.println("Dog eating...");
}
@Override
public void eating() {
System.out.println("Eating through an interface...");
// TODO Auto-generated method stub
}
@Override
public void herbiEating() {
System.out.println("Herbi eating through an interface...");
// TODO Auto-generated method stub
}
}
定義済みインタフェース ：
public interface AnimalInterface {
public void eating();
}
interface Herbi {
public void herbiEating();
}
拡張
- クラスは1つのクラスのみを拡張します
- インターフェイスは1つ以上のインターフェイスを拡張します
実装
- クラスは1つ以上のインタフェースを実装します
- インターフェースは何も実装できません
抽象クラスもクラスのように振る舞い、拡張と実装をする
Extendsは、子クラス/インタフェースに親クラス/インタフェースの属性が必要な場合に使用され、クラス内のインタフェースの属性が必要な場合はimplementsが使用されます。
例：
クラスの使用を拡張します
クラスParent {
}
childクラスはParentクラスを継承します。
}
インタフェースを使用して拡張します
インタフェースParent {
}
インタフェースChildはParentを継承します{
}
実装
インタフェースA {
}
クラスBはA {を実装しています
}
拡張と実装の組み合わせ
interface A{
}
class B
{
}
class C implements A,extends B{
}