常連

### 前提・実現したいこと
Pythonの勉強本でわからないコードがあったので意味を教えてください。
raise NotImplementedError()とはどういう意味でしょうか。

### 該当のソースコード

```Python
import numpy as np


class Variable:
    def __init__(self, data):
        self.data = data


class Function:
    def __call__(self, input):
        x = input.data
        y = self.forward(x)
        output = Variable(y)
        return output

    def forward(self, in_data):
        raise NotImplementedError()###←ここがわからない。


class Square(Function):
    def forward(self, x):
        return x ** 2


x = Variable(np.array(10))
f = Square()
y = f(x)
print(type(y))
print(y.data)
```

raise NotImplementedError()の意味【継承】

### 実現したいこと

この問題を解くときの順序の理解が曖昧なのですが、私の解釈といたしまして、まず初めの

「public class SampleA extends SampleC{
    int calc(int num) {
       return num * 2;」

を飛ばして、

「SampleC sc = new SampleA();
     System.out.print(sc.calc(5));」

に飛び、「(sc.calc(5))」の「(5)」が「SampleA()」の「()」に呼ばれているので「()」の値は「5」になる。

この順序で合っていますでしょうか？

また、「 SampleC sc = new SampleA();」で「SampleA()」が呼ばれて「(sc.calc(5));」の「5」が呼ばれる経緯が分かりません。「SampleC sc」はこのソースではどういう役目を補っているのでしょうか？

上記の流れの後、初めの「return num * 2;」に戻り、「int calc(int num) 」の「(int num) 」が「5」なので「* 2」をして「10」が出力される。

ここで、

「 sc = new SampleB();  System.out.print(sc.calc(5));」

までいかず、最初に「10」を出力する経緯も分かりません。

この後、上記と同じように「SampleB()」の「（）]
に「(sc.calc(5));」の「(5)」が呼ばれますが、「sc＝new SampleB」のように初めの「Sample○○」のがないのはどうしてでしょうか？

またそこから

「public class SampleB extends SampleC{
    int calc(int num) {
        return num * num;」

に飛んで「return num * num」をしますが、どの段階でreturnしたんでしょうか？

また、

「public abstract class SampleC {
    abstract int calc(int num);」

の役割が分からないのですが、どこに関係するソースでしょうか？

長々と申し訳ありません。

### 該当のソースコード

```ここに言語名を入力

public class SampleA extends SampleC{
    int calc(int num) {
        return num * 2;
    }
    public static void main(String[] args) {
        SampleC sc = new SampleA();
        System.out.print(sc.calc(5));
        sc = new SampleB();
        System.out.print(sc.calc(5));
    }
}

public class SampleB extends SampleC{
    int calc(int num) {
        return num * num;
    }
}

public abstract class SampleC {
    abstract int calc(int num);
}

```

### 試したこと

SampleAがSampleCを継承していること、SampleBがSampleCを継承していることは分かりました。int calc(int num)に何の値が入るのか分からずじまいです。また、そこからどうして1025になるのか、わかりません。


Javaの問題です。継承の問題です。出力結果が1025になる理由が分かりません。

### エラー内容

メソッド print() は型 SampleC で未定義です

###


```ここに言語を入力

public class SampleA extends SampleB{
   void print(){
        System.out.println(changenum(5));
   }
    public static void main(String[] args) {
        SampleC sc = new SampleA();
        sc.print();
    }
}

public class SampleB extends SampleC{
    int changenum(int num){
        int sum = calc(num);
        return sum + num;
    }
}

public class SampleC {
    int calc(int num){
        return num * 5;
    }
}


```

Javaの問題です。恐らく多態性の問題です。出力結果がコンパイルエラーになる理由が分かりません。

### 前提・実現したいこと
抽象クラスのenumを継承したいです。


### 発生している問題・エラーメッセージ

```
ネットで調べたところ、列挙型のenumは継承できないとあり、
やり方が分からず躓いております。
```

### 該当のソースコード

```java
public enum Enum {
	a,
	b
}
public abstract class A {
	abstract public Enum getEnum();
}

public class B extends A {
	public Enum getEnum(){
		return Enum.a;
	}
}

public class C extends A {
	pubic Enum getEnum() {
		return Enum.b;
	}
}
```

### 試したこと

ここに問題に対して試したことを記載してください。

### 補足情報（FW/ツールのバージョンなど）

ここにより詳細な情報を記載してください。

enumの継承について

継承した場合のstatic変数/関数の扱いについて悩んでいます
```C#
//Program.cs
using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp1
{
	class Program
	{
		static void Main(string[] args)
		{
			var BoyDict = new Dictionary<string, int>() { { "Taro", 12 }, { "Jiro", 13 }, { "Sabu", 14 } };
			var GirlDict = new Dictionary<string, int>() { { "Ichi", 15 }, { "Ni", 16 }, { "San", 17 } };

			// DictionaryからBoyインスタンスを作成
			var BoyList = BoyDict.Select(_boy => new Boy(_boy.Key, _boy.Value)).ToList();
			Console.WriteLine(String.Join(",", Boy.NameList));  // Taro,Jiro,Sabuが出るし、それで正しい
			Console.WriteLine(String.Join(",", Girl.NameList)); // この時点はListが空であってほしいがTaro,Jiro,Sabuが出る

			// DictionaryからGirlインスタンスを作成
			var GirlList = GirlDict.Select(_girl => new Girl(_girl.Key, _girl.Value)).ToList();
			Console.WriteLine(String.Join(",", Boy.NameList)); // Taro,Jiro,Sabuが出てほしいがTaro,Jiro,Sabu,Ichi,Ni,Sanが出る
			Console.WriteLine(String.Join(",", Girl.NameList)); // Ichi,Ni,Sanが出てほしいが、Taro,Jiro,Sabu,Ichi,Ni,Sanが出る

		}
	}
}
```

```C#
// Person.cs
﻿using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
	abstract public class Person
	{
		string Name;
		int Age;
		public static List<string> NameList = new List<string>();

		public Person(string Name, int Age)
		{
			this.Name = Name;
			this.Age = Age;
			NameList.Add(Name);
		}

		public static void SaveNameList(){
			// NameListをcsvにする処理。これはBoy,Girlで共通
		}

	}

	public class Boy : Person
	{

		public Boy(string Name, int Age) : base(Name, Age)
		{

		}

	}

	public class Girl : Person
	{

		public Girl(string Name, int Age) : base(Name, Age)
		{

		}

	}


}
```
このようにPersonクラスを継承したBoyクラスとGirlクラスがあります．
Personクラスはインスタンス生成時に自身の場のNameListに生成された人の名前のリストを自動的に保存します．

こんな感じで，BoyとGirlでそれぞれNameListを持たせたいのですが，実際にこのコードを実行すると，２つ問題があります．
1:Person Boy GirlのNameListが同一のものになっているので別々に持たせたいです．
Boy Girl側でPublic new static List<string> NameListをしたら持たせられるのですが，Person側でできないでしょうか？
2:staticメソッドのSaveNameListもPersonクラスのNameListを参照するため，想定の動作をしません．
どのようにすればよいでしょうか？

また，そもそも設計思想が間違っているのでしょうか？
(NameListをPersonのstaticにすべきでないなど)

2021/2/2追記：

みなさまから多くの意見を頂き本当にありがとうございます．
まず最初に謝らせていただくこととして，このコード例は問題を具体化したかったために，作った
ものです．
やりたかったことはabstract classを継承した子クラスが，それぞれstaticな変数を持つ時に親クラスでstatic宣言した場合，親クラスのものと同一のものになるのではなく，子クラスでstaticなものを持っていてほしいということです．（Personの場，Boyの場,Girlの場があり，それぞれに同様の意味を持つstaticな変数を持たせたい）
そして，staticな関数の中で，自身の場を参照したいような時にも親クラスの場を参照してしまうという問題点を解決したいというものです．
適当な例としてstaticなNameListと，staticなNameListをCSV出力する関数を挙げたつもりでしたが不適切でした．確かにPersonがNameListを持つべきではありません

例えば染色体（Chromosomes）をPersonは持っています．これはどのPersonにもあり，インスタンスごとに違うものでもないのでstaticです（もしかしてここの理解が間違っているのでしょうか？）．ただし，Personの染色体はこの時点では不定なので，定義だけされています．
Personを継承したBoyも染色体を持ちます．Boyの場合はxyです．Girlの場合xxです．

この時Boy.Chromosomos="xy", Girl.Chromosomos="xx"だと思うので，親と,それを継承した子1, 子2......で別のstaticな変数が欲しいという場面はあると思います

またややこしい例を持ち出して申し訳ありませんが，私がNameListを例として挙げてしまったがために本筋と外れた議論になってしまったので追記させていただきます．

//追記その２
staticにすべき変数論に発散してしまったので，一度締めさせていただきます。
みなさまのご意見非常に勉強になりました．
頂いた意見の中では
- 抽象プロパティで定義する（もしかすると実際にはできない？）
- PersonMangerクラスで管理する
が特に参考になりました。

今回の例では具体的過ぎて，「Personであったらそのように実装すべきでない」という意見を数多く頂きましたが，実際クラスで一括管理したいstaticなものがあると思うのですが，どうやらstaticの認識がみなさまのものと違っているようです．もういちど勉強します・

継承した場合のstatic変数/関数について

[C++ Core Guidelines](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines)を読んでいて納得できない部分があります。


[C.139: Use final on classes sparingly](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c139-use-final-on-classes-sparingly)の項目です。

calssに対するfinalを控えめにするという項目で、理由として以下の様に書いてあります。

> Reason Capping a hierarchy with final classes is rarely needed for logical reasons and can be damaging to the extensibility of a hierarchy.


* 継承を禁止する論理的な理由があることはめったにない
* クラスの拡張性を損なう

という内容かと思いますが、個人的には納得できませんでした。
constを推奨するのと同じような理由でfinalは積極的に使っていきたいように感じます。


この理由について掘り下げて議論している書籍、Webの情報などが知りたいです。
独自見解、他言語での状況などでも大丈夫です。

基本的には納得してCore Guidelinesに従いたいと思っているので、こうするべきとされている理由をより深く知りたいです。

よろしくおねがいします。

C++でclassにfinalを控えめに使うべき理由について

### 前提・実現したいこと

matplotlibでグラフを作成しています。軸の値を10のN乗の指数表記にするため、matplotlibで軸の値を10のN乗の指数表記にするため、こちら(matplotlibで軸の値を10のN乗の指数表記にしたい)のサイトを参考にコードを書きました。コードはscalarformatterを継承した子クラスFixedOrderFormatterを作り、本来scalarformatterで計算されるorderOfMagnitude（10のN乗のNを制御する変数）を任意の数にするというものらしく、他の海外の方もこの方法を取っているようです。しかし、FixedOrderFormatterの引数をいくつにしても、10のN乗のNを変えることができません。解決策を教えてください。


### 該当のソースコード

```python
import pandas as pd
import matplotlib.pyplot as plt
from matplotlib.ticker import ScalarFormatter

#クラス設定  ※ScalarFormatterを継承
class FixedOrderFormatter(ScalarFormatter):
    def __init__(self, order_of_mag=0, useOffset=True, useMathText=True):
        self._order_of_mag = order_of_mag
        ScalarFormatter.__init__(self, useOffset=useOffset, 
                                 useMathText=useMathText)
    def _set_orderOfMagnitude(self, range):
        self.orderOfMagnitude = self._order_of_mag

#グラフ描画
x=[0,100]
y=[0,2000000]

fig=plt.figure()
ax=fig.add_subplot()

ax.plot(x,y)
ax = plt.gca()
ax.yaxis.set_major_formatter(FixedOrderFormatter(4 ,useMathText=True))

ax.yaxis.set_major_formatter(ScalarFormatter(useMathText=True))
ax.ticklabel_format(style="sci",  axis="y",scilimits=(0,4))


plt.show()
```



### 補足情報（FW/ツールのバージョンなど）
python 3.9.7
matplotlib 3.5.0

matplotlibで軸の値を10のN乗の指数表記にしたい

プロトタイプは、共有したい関数やプロパティがあるときに利用します。このプロトタイプを利用することを「オブジェクトを初期化する」と表現するサイトを見つけました。
 初期化は、元々あった事物を消し新たにすることと変数に値を代入することという二つの意味で認識しておりますがオブジェクトを初期化するとは、どちらの意味になりますか。或いはまた別に意味があるのでしょうか。

http://language-and-engineering.hatenablog.jp/entry/20080922/1222010471