jzman

//ジェネリッククラスの定義
class クラス名<T>{
    
}

/**
 * ジェネリッククラスの定義
 * @author jzman
 * @param <T>
 */
public class GenercityClass<T1,T2> {
	
	private T1 score;
	private T2 desc;
	
	public GenercityClass() {}
	
	public GenercityClass(T1 score, T2 desc) {
		this.score = score;
		this.desc = desc;
	}
	public T1 getScore() {
		return score;
	}
	public void setScore(T1 score) {
		this.score = score;
	}
	public T2 getDesc() {
		return desc;
	}
	public void setDesc(T2 desc) {
		this.desc = desc;
	}
	
	public static void main(String[] args) {
		//使用時に具体的な型を指定します。具体的な型は参照型のみで、基本型（intなど）は使用できません。
		GenercityClass<Integer, String> genercity = new GenercityClass<>(90,"A");
		int score = genercity.getScore();
		String desc = genercity.getDesc();
		System.out.println("score="+score+",desc="+desc);
	}
}

GenercityClass<Integer, String> genercityClass = new GenercityClass<>();
//指定された具体的な型に合致しています
genercityClass.setScore(80);
//Stringの値をInteger型の変数に代入することはできません
genercityClass.setScore("A");

//ジェネリックインターフェースの定義
interface インターフェース名<T>{
    戻り値の型 メソッド名<T t>;
}

/**
 * ジェネリックインターフェース：メソッド内でのみ指定されたジェネリックを使用できます
 * @author jzman
 */
public interface GenercityInterface<T> {
	//ジェネリックは静的プロパティの前で使用できません
//	T a;
	//メソッド内でジェネリックを使用
	void start(T t);
}

//ジェネリックメソッドの定義
修飾子 <T> 戻り値の型 メソッド名{
    
}

package com.manu.genericity;

public class PersonBean {
	private String name;
	private int age;
    //Getter、Setterなどのメソッドは省略
    //...
}

/**
 * ジェネリックメソッド
 * @author jzman
 */
public class GenercityMethod {
	public static void main(String[] args) {
		PersonBean bean = new PersonBean("tom",10);
		printA("string");
		printA(bean);
		printB(bean);
	}
	//ジェネリックはそのスーパークラスを指定しない場合、型が不明なため、その情報にアクセスすることしかできません
	public static <T> void printA(T t) {
		System.out.println(t);
	}
	//ジェネリックはスーパークラスを指定することで、そのジェネリックが表す実体情報を変更できます
	public static <T extends PersonBean> void printB(T t) {
		t.setName("haha");
		System.out.println(t);
	}
}

string
PersonBean [name=tom, age=10]
PersonBean [name=haha, age=10]

/**
 * ジェネリック親クラス
 * @author jzman
 */
public abstract class GenercityEClass<T> {
	T name;
	public abstract void print(T t);
}

/**
 * 子クラスがジェネリッククラスで、型は使用時に決定されます
 * @author jzman
 * @param <T>
 */
class Child1<T> extends GenercityEClass<T>{
	T t; //子クラスのプロパティは子クラスによって決定されます
	@Override
	public void print(T t) {
		//親クラスのプロパティは親クラスによって決定されます
		T name = this.name;
	}
}

/**
 * 子クラスが具体的な型を指定します
 * @author jzman
 */
class Child2 extends GenercityEClass<String>{
	Integer t; //子クラスのプロパティは子クラスによって決定されます
	@Override
	public void print(String t) {
		//親クラスのプロパティは親クラスによって決定されます
		String name = this.name;
	}
}

/**
 * 親クラスのジェネリックの消去
 * 子クラスはジェネリッククラスで、親クラスは型を指定せず、ジェネリック消去はObjectを使用して代替されます
 * @author jzman
 * @param <T>
 */
class Child3<T/*,T1*/> extends GenercityEClass{
	T t;
	String t1; //子クラスのプロパティは子クラスによって決定されます
	@Override
	public void print(Object t) {
		//親クラスのプロパティは親クラスによって決定されます
		Object obj = this.name;
	}
}

/**
 * 子クラスと親クラスが同時にジェネリック消去を行います
 * @author jzman
 */
class Child4 extends GenercityEClass{
	//具体的な型のみ使用できます
	String str; //子クラスのプロパティは子クラスによって決定されます
	@Override
	public void print(Object t) {
		//親クラスのプロパティは親クラスによって決定されます
		Object obj = this.name;
	}
}

/**
 * 親クラスのジェネリックの消去
 * 子クラスはジェネリッククラスで、親クラスは型を指定せず、ジェネリック消去はObjectを使用して代替されます
 * @author jzman
 * @param <T>
 */
class Child3<T/*,T1*/> extends GenercityEClass{
	T t;
	String t1; //子クラスのプロパティは子クラスによって決定されます
	@Override
	public void print(Object t) {
		//親クラスのプロパティは親クラスによって決定されます
		Object obj = this.name;
	}
}

/**
 * 子クラスと親クラスが同時にジェネリック消去を行います
 * @author jzman
 */
class Child4 extends GenercityEClass{
	//具体的な型のみ使用できます
	String str; //子クラスのプロパティは子クラスによって決定されます
	@Override
	public void print(Object t) {
		//親クラスのプロパティは親クラスによって決定されます
		Object obj = this.name;
	}
}
/**
 * 子クラスが消去され、親クラスがジェネリックを使用する（エラー）
 * @author jzman
 *
class Child5 extends GenercityEClass<T>{
	@Override
	public void print(T t) {
		
	}
}
 */

class Child1<T> extends GenercityEClass<T>{
	T t; //子クラスのプロパティは子クラスによって決定されます
	@Override
	public void print(T t) {
		//親クラスのプロパティは親クラスによって決定されます
		T name = this.name;
	}
	
	public static void main(String[] args) {
		//1.使用時のジェネリック消去
		Child1 child1 = new Child1();
		Object obj = child1.name;//プロパティnameは消去後の型Objectになります
		//2.使用時に型を指定
		Child1<String> child2 = new Child1();
		String name = child2.name;//プロパティnameは指定された型Stringになります
	}
}

//ジェネリックの使用可能な型を制限する
class <T extends AnyClass>{
    
}

/**
 * ジェネリックの使用可能な型制限
 * @author jzman
 */
public class LimitGenercityClass<T extends List> {
	public static void main(String[] args) {
		// T extends：<上限、Tは上限の子クラスまたはその本体であることができます
		LimitGenercityClass<ArrayList<String>> limitClass1 = new LimitGenercityClass<>();
		LimitGenercityClass<LinkedList<String>> limitClass2 = new LimitGenercityClass<>();
		//HashMapはListインターフェースを実装していないため、HashMapはジェネリッククラスインスタンスの型をインスタンス化できません
//		LimitGenercityClass<HashMap<String,String>> limitClass3 = new LimitGenercityClass<>();	
	}
}

//型ワイルドカードを使用する
ジェネリッククラス名<? extends AnyClass> a ;

/**
 * ワイルドカードの使用
 * ？ extends AnyClass:ジェネリックの具体的な型はAnyClassの子クラスのみ
 * ？ super AnyClass:ジェネリックの具体的な型はAnyClassのスーパークラスのみ
 * @author jzman
 */
public class CommonCharGenercityClass<T> {
	public static void main(String[] args) {
		//1.型ワイルドカードを型宣言に使用
		CommonCharGenercityClass<? extends List> commA = null;
		//ワイルドカード内でextendsキーワードを使用して、ジェネリックはListの子クラスのみであることを制限しました
		commA = new CommonCharGenercityClass<ArrayList<String>>();
		commA = new CommonCharGenercityClass<LinkedList<String>>();
//		commA = new CommonCharGenercityClass<HashMap<String>>();
		
		CommonCharGenercityClass<? super List> commB = null;
		//エラー、ワイルドカード内でsuperキーワードを使用して、ジェネリックはListのスーパークラスのみであることを制限しています。例えばObject
//		commB = new CommonCharGenercityClass<ArrayList<String>>();
		commB = new CommonCharGenercityClass<Object>();
		
		List<String> listA = new ArrayList<>();
		listA.add("tom");
		
		List<?> listB = listA;
		//ワイルドカードを使用した場合、具体的な型が不明なため、データの取得と削除しかできず、データの追加はできません
//		listB.add("new");
		listB.remove(0);
		System.out.println(listB);	
	}
	
	//2.メソッドパラメータにワイルドカードを使用
	public static void test(CommonCharGenercityClass<? extends List> list) {
		//...
	}
}