オブジェクト指向： 継承

<?php
namespace src\name_parent;

継承禁止
final class classTest{
　　～
}

class classP{
　　private $val;

　　public function getVal(){
　　　　return $this->val;
　　}

　　public function setVal($prm){
　　　　$this->val = $prm;
　　}
}

<?php
namespace src\name_child;
use src\name_parent\classP;
require_once 'src/name_parent/classP.php';

class classC extends classP{}

<?php
require_once 'src/name_child/classC.php';
use src\name_child\classC;

$c = new classC();
$c->setVal("aaa");
echo $c->getVal();

class Parent:
　〜

class Child(Parent):
　〜

※基底クラス
private class Parent
{
　public void SubRoutine1(){ ～; }
}

※派生クラス
private class Child : Parent
{
　public void SubRoutine2(){ ～; }
}

public static void main()
{
　Child c = new Child();
　c.SubRoueint1();　//OK
　c.SubRoueint2();　//OK
}

class Parent
{
protected:
　　int _member;
public:
　　int Member();
　　void Member(int member);
};

int Parent::Member()
{
　　return this->_member;
}
void Parent::Member(int member)
{
　　this->_member = member;
}

継承修飾子
・public：基底クラスで設定したアクセス修飾子の設定をそのまま引き継ぐ
・protected：基底クラスでpublicだったものを、protectedにして引き継ぐ。他はそのまま。
・private：基底クラスのメンバを全てprivateで引き継ぐ。

class Child : 継承修飾子(例：public) Parent
{
public:
　　void Plus();
};

void Child::Plus()
{
　　this->_member *= 2;
}

int main(array<System::String ^> ^args)
{
　　Child *child = new Child();
　　child->Member(10);
　　child->Plus();
　　// →20
　　Console::WriteLine(child->Member());
　　
　　return 0;
}

※基底クラス
Public Class Parent
　Public Sub SubRoutine1()
　　～
　End Sub
End Class

※派生クラス
Public Class Child Inherits Parent
　Public Sub SubRoutine2()
　　～
　End Sub
End Class

Public Static Sub main()
　　Dim c As Child()
　　Call c.SubRoutine1()　’OK
　　Call c.SubRoutine2()　’OK
End Sub

※スーパークラス(基底クラス)
class SuperClass {
　　public void SubRoueint1(){}
}

※サブクラス(派生クラス)
public class SubClass extends SuperClass {
　　public void SubRoueint2(){}
}

public static void main()
{
　Child s = new SubClass();
　s.SubRoueint1();　//OK
　s.SubRoueint2();　//OK
}

class Child :
private Parent1,
protected Parent2,
public Parent3
{
private:
　　～
public:
　　～
};

同一の基底クラスを継承した派生クラスを多重継承した場合に、
基底クラスのメンバーを派生クラスにおいて重複して継承してしまう問題を回避する場合の処理については、
「オブジェクト指向： 特殊なクラス/仮想基本クラス」参照

public class A
{
　　public String myStr = "A";
　　public void myMethod() {
　　　　System.out.println(this.myStr);
　　}
}

public class B extends A
{
　　public String myStr = "B";
}

public static void main(String[] args) {
　　A a = new A();
　　A b = new B();
　　
　　System.out.println(a.myStr);　⇒ A
　　System.out.println(b.myStr);　⇒ A
　　※型のインスタンス変数が優先される
　　
　　a.myMethod();　⇒ A
　　b.myMethod();　⇒ A
　　※定義されているメソッドの場所が優先される
　　
　　B b = new B();
　　System.out.println(b.myStr);　⇒ B
　　※型のインスタンス変数が優先される
　　b.myMethod();　⇒ A
　　※定義されているメソッドの場所が優先される
}

全クラスの基底クラス
全クラスはObjectクラスのメソッドを使用できる

Objectクラスの主なメソッド

メソッド名	機能
boolean equals(Object obj)	オブジェクトの比較結果取得
final Class<?> getClass()	実行時クラス情報取得
int hashCode()	ハッシュコードの取得
String toString()	文字列情報取得
void finalize()	廃棄処理オブジェクトへの参照が無い場合にガベージコレクタによって呼び出される

class magic_method
{
　　private $values = array();

　　public function __set($name, $value){
　　　　print "未定義SET呼び出しエラー\r\n";
　　　　$this->values[$name] = $value;
　　}

　　public function __get($name){
　　　　print "未定義GET呼び出しエラー\r\n";
　　　　return $this->values[$name];
　　}

　　public function __isset($name){
　　　　print "未定義ISSET呼び出しエラー\r\n";
　　　　return isset($this->values[$name]);
　　}

　　public function __unset($name){
　　　　print "未定義UNSET呼び出しエラー\r\n";
　　　　unset($this->values[$name]);
　　}
　　
　　public function __call($name){
　　　　print "未定義CALL呼び出しエラー\r\n";
　　}
}

require_once 'magic_method.php';

$magic = new magic_method();

$magic->magic = "PHP";
→ 未定義SET呼び出しエラー
print $magic->magic;
→ 未定義GET呼び出しエラー
→ PHP
print isset($magic->magic);
→ 未定義ISSET呼び出しエラー
→ 1(true)
unset($magic->magic);
→ 未定義UNSET呼び出しエラー
print $magic->magic("PHP");
→ 未定義CALL呼び出しエラー

private class Parent
{
　public int member{ get; set; }
　
　public virtual void SubRoutine()
　{ this.member += 10; }
}

private class Child : Parent
{
　//オーバーライド
　public override void SubRoutine()
　{
　　Console.WriteLine(member);
　}
}

Parentクラスの定義は「継承方法」参照

class Child : public Parent
{
public:
　　void Plus();
};

void Child::Plus()
{
　　this->_member *= 2;
}

class GrandChild : public Child
{
public:
　　再定義するメソッドを定義
　　virtual void Plus();
};

void Child::Plus()
{
　　// 基底クラスのメソッド呼び出し
　　Child::Plus();
　　(_member *= 2)
　　this->_member += 5;
}

int main(array<System::String ^> ^args)
{
　　Child *child = new Child();
　　child->Member(10);
　　child->Plus();
　　Console::WriteLine(child->Member());
　　// →20
　　delete child;
　　
　　
　　GrandChild *gChild = new GrandChild();
　　gChild ->Member(10);
　　gChild ->Plus();
　　Console::WriteLine(gChild ->Member());
　　// →25
　　delete gChild ;
　　
　　return 0;
}

Public Class Parent
　Private _member As Integer

　※Overridesされるメソッド
　Public Overridable Sub SubRoutine()
　　member += 10
　End Sub

End Class

Public Class Child
　Inherits Parent

　Public Overrides Sub SubRoutine()
　　Call MsgBox(member)
　End Sub

End Class

オーバーライド条件
・メソッド名、引数が同じ
・戻り値が同じ、またはそのサブクラス
・修飾子が同じ、またはスーパークラスより広い
※この条件から外れるとエラーか、オーバーロード扱いされる

※スーパークラス(基底クラス)
class SuperClass {
　　//オーバーライドされるメソッドに修飾子はない(virtual等)
　　public void method1(){}
　　public void method2(){}
　　private void method3(){}
}

※サブクラス(派生クラス)
public class SubClass extends SuperClass {
　　//オーバーライドするメソッドに修飾子はない(override等)
　　サブクラスのインスタンスから呼ばれたメソッドはサブ⇒スーパーの順序で探されて実行される。
　　public void method1(){}
　　
　　エラー
　　publicのメソッドをprivateでオーバーライドできない。
　　private void method2(){}
　　
　　元メソッドより広い範囲のアクセス修飾子はOK
　　public void method3(){}
}

<?php
namespace src\name_parent;

class classP{
　　private $val;
　　
　　オーバーライド禁止
　　public final function test(){
　　　　～
　　}
　　
　　public function getVal(){
　　　　return $this->val;
　　}
　　
　　public function setVal($prm){
　　　　$this->val = $prm;
　　}
}

<?php
namespace src\name_child;
use src\name_parent\classP;

require_once 'src/name_parent/classP.php';

class classC extends classP{
　　public function getVal(){
　　　　return parent::getVal() . "(overrided)";
　　}
}

<?php
require_once 'src/name_child/classC.php';
use src\name_child\classC;

$c = new classC();
$c->setVal("aaa");
echo $c->getVal();
→ aaa(overrided)

class Parent
{
　public int i;
　public void Show()
　{
　　Console.WriteLine(value: this.i);
　}
}

class Child : Parent
{
　新しく定義(規定クラスのiを隠蔽)
　new int i;
　
　public Child(int prm)
　{
　　i = prm;
　　this.i = prm;
　}
　
　public int GetChildI()
　{
　　return i;
　　return this.i;
　}
　
　public int GetParentI()
　{
　　return base.i;
　}
　
　コンパイルエラー：基底クラスと同名のメソッドは定義できない
　public void Show()
　{
　　Console.WriteLine(value: i);
　　Console.WriteLine(value: this.i);
　}
　
　新しく定義(規定クラスのShow()を隠蔽)
　new public void Show()
　{
　　Console.WriteLine(value: i);
　　Console.WriteLine(value: this.i);
　}
}

class Program
{
　static void Main(string[] args)
　{

　　Child c = new Child(10);
　　c.i = 5;
　　int ret1 = c.i;
　　ret1：5
　　int ret2 = c.GetChildI();
　　ret2：10
　　int ret3 = c.GetParentI();
　　ret3：5
　　
　　c.Show();
　　→10
　}
}

C#では全てのオーバーライドされるメソッドは強制的に仮想関数

class MyParent
{
public:
　virtual void fnFunc();
};

void MyParent::fnFunc()
{
　cout << "MyParent" << '\n';
　return;
}

class MyChild : public MyParent
{
public:
　virtual void fnFunc();
};

void MyChild::fnFunc()
{
　cout << "MyChild" << '\n';
　return;
}

int _tmain(int argc, _TCHAR* argv[])
{

　MyParent *parent;
　
　parent = new MyParent();
　parent->fnFunc();
　→MyParent(virtual：無)
　→MyParent(virtual：有)

　parent = new MyChild();
　parent->fnFunc();
　→MyParent(virtual：無)
　→MyChild(virtual：有)

　Virtual無し時：静的な型のメソッドが呼ばれる。
　Virtual有り時：動的な型のメソッドが呼ばれる。

　return 0;
}

VB.NETでは全てのオーバーライドされるメソッドは強制的に仮想関数

JAVAでは全てのオーバーライドされるメソッドは強制的に仮想関数

<?php
namespace src\name_I;

interface I{
　　const CONST_VAL = "III";
　　public function iMethod();
}

<?php
namespace src\name_parent;
require_once 'src/name_I/I.php';
use src\name_I\I;

class classP implements I
{
　　public function iMethod(){
　　　　print I::CONST_VAL;
　　}
}

<?php
namespace src\name_child;
use src\name_parent\classP;
require_once 'src/name_parent/classP.php';

class classC extends classP{
}

<?php
require_once 'src/name_child/classC.php';
use src\name_child\classC;

$c = new classC();
print $c->iMethod();

interface Person {
　name: string;
　age: number;
}

let person: Person = {
　name: “type_script”;
　age: 10;
};

console.log(person); → { name: “type_script”, age: 10 }
console.log(person.age); → 10

public interface faceTest
{
　インターフェイスではフィールドを定義できない(≠JAVA)
　int member;　×
　void SubRoutin1();
}

public class clsParent : faceTest
{
　//インターフェイス・メンバーの実装
　インターフェイス・メンバーはpublicで宣言する必要あり
　public void SubRoutin1(){ ～ }

//インターフェイスには無いメンバーの定義
　public int member1{ get; set; }
　public int member2{ get; }
　public void SubRoutin2(int prm1, int prm2)
　{ ～ }
}

public void main(int prm1, int prm2)
{
　clsParent p = new clsParent();
　p.member1 = 5;
　p.SubRoutin1();
　p.SubRoutin2(5,5);
}

C++ではインターフェイス用の予約語は無い。
ゲッター/セッターの事をインターフェイスと呼ぶ(人もいる)
派生クラスに基底クラスのメンバーメソッドの再定義を強制する場合、
インターフェイス用クラスにて純粋仮想関数(抽象クラス)をプロトタイプ定義する。

「抽象クラス」参照

Interface faceTest
　Property member As Integer
　Sub SubRoutin1()
End Interface

Public Class clsParent
　Implements faceTest

　Private _member As Integer
　Public Property member As Integer Implements faceTest.member
　　～
　End Property

　Public Sub SubRoutin1() Implements faceTest.SubRoutin1
　　～
　End Sub

　Public Sub SubRoutin2()
　　～
　End Sub
End Class

interface
・定義できるメソッドは抽象メソッドのみ
※コンパイル時にpablic abstractが付与される
　(インターフェイスではprivate/protected修飾子禁止)
・実装時、オーバーライドする際にはpublic修飾必須。
・インスタンス変数を定数として定義できる。
※コンパイル時にpublic static finalが付与される
　(インターフェイスでは初期値が必要)。
・インスタンス化不可
・インターフェイスを継承するインターフェイスはextendsで継承
・インターフェイスにおいて、インターフェイスの複数継承は可。
・インターフェイスを実装するクラスはimplementsで実装
・インターフェイスは複数実装可能。
・継承と実装を同時に行う場合、継承、実装の順に定義

interface MyInter1{
　　abstract void method1();
}

interface MyInter2{
　　abstract void method2();
}

class MyClass1 implements MyInter1, MyInter2{
　　public void method1(){}
　　public void method2(){}
}

interface MyInter3 extends MyInter1, MyInter2 {
　　public static final String constValue = "ConstValue";
　　void method1();
　　void method2();
}

class MyClass2 extends MyClass1 implements MyInter1, MyInter2, MyInter3{
　　public void method1(){};
　　public void method2(){};
　　
　　String a = MyInter3.constValue;;
}

//抽象クラス
public abstract class Person
{
　　//抽象メソッド
　　public abstract string getName(); ⇒ OK
　　
　　※エラー。抽象メソッドは中身を書けない。
　　public abstract string getName(){ return ""; }
}

//抽象クラスを継承(1)
⇒エラー(抽象メソッドを再定義していない)
public class Taro : Person {}

//抽象クラスを継承(2)　⇒OK
public class Taro : Person
{
　　//抽象メソッドをオーバーライド
　　public override string getName()
　　{
　　　　return "My Name Is 太郎";
　　}
}

public partial class Form1 : Form
{
　　private void Form1_Load(object sender, EventArgs e)
　　{
　　　　// ↓ はエラー。抽象クラスはインスタンス化できない。
　　　　Person person = new Person();
　　　　
　　　　Taro taro = new Taro();　⇒ OK
　　　　Person someone = new Taro();　⇒ OK
　　}
}

抽象クラス(純粋仮想関数を含むクラス)
class MyParent
{
public:
　純粋仮想関数(=抽象メソッド)
　virtual void fnFunc() = 0;
};

void MyParent::fnFunc()
{
　～
　return;
}

class MyChild : public MyParent{};

int _tmain(int argc, _TCHAR* argv[])
{
　MyParent *parent;
　
　parent = new MyParent();
　コンパイルエラー(抽象クラスをインスタンス化できない)
　
　parent = new MyChild();
　コンパイルエラー(派生クラスは仮想関数を実装していない)
　
　return 0;
}

class MyChild : public MyParent{
public:
　仮想関数を実装
　void fnFunc();
};

void MyChild::fnFunc()
{
　基底クラスの仮想関数を呼ぶ
　MyParent::fnFunc();
　return;
}

int _tmain(int argc, _TCHAR* argv[])
{
　MyParent *parent = new MyChild();
　parent->fnFunc();
　派生クラスのfnFunc()の中から、基底クラスのfnFunc()が呼ばれる。
　
　return 0;
}

Public MustInherit Class Person
　　Public MustOverride Function GetName() As String
　　
　　※エラー。抽象メソッドは中身を書けない。
　　Public MustOverride Function GetName() As String
　　　　Return ""
　　End Function
End Class

‘抽象クラスを継承(1)
⇒エラー(抽象メソッドを再定義していない)
Public Class Taro
　　Inherits Person
End Class

‘抽象クラスを継承(2)
Public Class Taro
　　Inherits Person
　　Public Overrides Function GetName() As String
　　　　Return "My Name Is 太郎"
　　End Function
End Class

Public Class Form1
　　Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load

　　　　‘エラー。抽象クラスはインスタンス化できない。
　　　　’Dim person As Person = New Person

　　　　Dim taro As Person = New Taro　‘⇒　OK
　　　　Dim someone As Person = New Taro　‘⇒　OK
　　End Sub
End Class

抽象クラス/抽象メソッド
abstract修飾子を付ける
インスタンス化禁止
抽象クラス内の抽象メソッドは必ずサブクラスで再定義しなければならない

abstract class Super{
　　abstract void methodA{}
　　void methodB(){ ～ }
}

抽象クラスを継承した抽象クラスでは、抽象メソッドを再定義する必要はない。
再定義は具象クラスで必要。
abstract class Sub extends Super{
　　abstract void methodC{}
}

class SubSub extends Sub {
　　void methodA(){ ～ }
　　void methodC(){ ～ }
}

目的
・スーパークラスでサブクラスに対し、メソッド名を強制できる
　(同機能のメソッドの乱立を防ぐ、コーディング規約的使い方)
・ポリモーフィズムの利用の為

インタフェイスを実装した抽象クラス

interface MyInterFace
{
　　int myInt = 0;　// 固定値。static final が自動的に付加される
　　void myMethod();　// 抽象メソッド。abstract が自動的に付加される
}

public abstract class Parent implements MyInterFace {
　　// 抽象クラスではインターフェイスにおける抽象メソッドを再定義しなくても良い
　　// 抽象クラスの具象クラスでは必要
}

public class Child extends Parent {
　　@Override
　　public void myMethod() {}
}

Child c = new Child();
c.myMethod();

<?php
namespace src\name_ab;
抽象クラス宣言
abstract class classAb
{
　　const CONST_VAL = "aaa";

　　抽象メソッド宣言(中身無し)
　　abstract public function method($pam);
}

<?php
namespace src\name_parent;
require_once 'src/name_ab/classAb.php';
use src\name_ab\classAb;
class classP extends classAb
{
　　public function method($pam){
　　　　print classAb::CONST_VAL;
　　}
}

<?php
namespace src\name_child;
use src\name_parent\classP;
require_once 'src/name_parent/classP.php';

class classC extends classP{}
<?php
require_once 'src/name_child/classC.php';
use src\name_child\classC;
$c = new classC();
print $c->method(123);

public abstract class Parent
{
　　public virtual void method() { }
}

public class Child1 : Parent
{
　　//オーバーライド禁止(自分は良い。以降の派生クラスで禁止)
　　public sealed override void method(){}
}

public class Grandson : Child1
{
　　public override void method() { }
　　⇒ ビルドエラー(オーバーライド失敗)
}

//継承禁止(自分は良い。以降の派生クラスで禁止)
public sealed class Child2 : Parent
{
　　public override void method(){}
}

public class Grandson : Child2
{
　　⇒ ビルドエラー(継承失敗)
}

final修飾子
変数、メソッド、クラスに付加可。

//定数
final int a = 5;

//オーバーライド禁止(オーバーロードは可)
final void method(){ ～ }

//継承禁止
final class MyClass{ ～ }

final修飾子
変数、メソッド、クラスに付加可。

//定数
final int a = 5;

//オーバーライド/オーバーロード禁止
final void method(){ ～ }

//継承禁止
final class MyClass{ ～ }