OneCodeOneTime · OneCodeOneTime · May 29, 2017 · May 27, 2017 · May 28, 2017
diff --git a/src/btp/oneP/Byteset.java b/src/btp/oneP/Byteset.java
@@ -0,0 +1,14 @@
+package btp.oneP;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+public class Byteset {
+	Byte[] possibles = {1,2,3,4,5,6,7,8,9};
+	Set<Byte> myset = new HashSet<Byte>(Arrays.asList(possibles));
+
+	Set<Byte> myset2 = new HashSet<Byte>(Arrays.<Byte>asList(new Byte[]{1,2,3,4,5,6,7,8,9}));
+	//The parameterized method <Byte>asList(Byte...) of type Arrays is not applicable for the arguments (Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer, Integer)
+	//Set<Byte> myset3 = new HashSet<Byte>(Arrays.<Byte>asList(1,2,3,4,5,6,7,8,9));
+}
diff --git a/src/btp/oneP/CRGWithBasicHolder.java b/src/btp/oneP/CRGWithBasicHolder.java
@@ -0,0 +1,27 @@
+package btp.oneP;
+
+public class CRGWithBasicHolder {
+
+	public static void main(String[] args) {
+		Subtype st1 = new Subtype(),st2 = new Subtype();
+		st1.set(st2);
+		Subtype st3 = st1.get();
+		st1.f();
+	}
+
+}
+
+class BasicHolder<T>{
+	T element;
+	void set(T t){
+		element = t;
+	}
+	T get(){
+		return this.element;
+	}
+	void f(){
+		System.out.println(this.element.getClass().getName());
+	}
+}
+
+class Subtype extends BasicHolder<Subtype>{}
diff --git a/src/btp/oneP/CaptureConversion.java b/src/btp/oneP/CaptureConversion.java
@@ -0,0 +1,24 @@
+package btp.oneP;
+
+public class CaptureConversion {
+
+	static <T> void f1(Holder<T> holder){
+		T t = holder.get();
+		System.out.println(t.getClass().getSimpleName());
+	}
+
+	static void f2(Holder<?> holder){
+		f1(holder);
+	}
+	public static void main(String[] args) {
+		Holder raw = new Holder<Integer>(1);
+		f1(raw);
+		f2(raw);
+		Holder rawBasic = new Holder();
+		rawBasic.set(new Object());
+		f2(rawBasic);
+		Holder<?> wildcarded = new Holder<Double>(1.0);
+		f2(wildcarded);
+	}
+
+}
diff --git a/src/btp/oneP/CheckedList.java b/src/btp/oneP/CheckedList.java
@@ -0,0 +1,39 @@
+package btp.oneP;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class CheckedList {
+
+	@SuppressWarnings("unchecked")
+	static void oldStyleMethod(List probablyDogs){
+		probablyDogs.add(new Cat());
+	}
+
+	public static void main(String[] args) {
+		List<Dog> dogs1 = new ArrayList<Dog>();
+		oldStyleMethod(dogs1);
+		System.out.println(dogs1);
+		List<Dog>s2 = Collections.checkedList(new ArrayList<Dog>(), Dog.class);
+		try{
+			oldStyleMethod(s2);
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+
+		//work fine 
+		List<Pet> pets = Collections.checkedList(new ArrayList<Pet>(), Pet.class);
+		pets.add(new Dog());
+		pets.add(new Cat());
+		pets.add(new Pet());
+		oldStyleMethod(pets);
+		System.out.println(pets);
+	}
+
+}
+
+class Pet{}
+class Dog extends Pet{}
+class Cat extends Pet{}
+
diff --git a/src/btp/oneP/ClassCasting.java b/src/btp/oneP/ClassCasting.java
@@ -0,0 +1,26 @@
+package btp.oneP;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.util.List;
+
+public class ClassCasting {
+
+	public void f(String...args) throws FileNotFoundException, IOException, ClassNotFoundException{
+		ObjectInputStream in = new ObjectInputStream(
+				new FileInputStream(args[0]));
+		//List<Widget> lwl = List<Widget>.class.ClassCasting(in.readObject());
+		//List<Widget> lw2 = (List<Widget>)List.class.cast(in.readObject());
+		List<Widget> lw2 = List.class.cast(in.readObject());
+	}
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
+
+class Widget{}
diff --git a/src/btp/oneP/ComparablePet.java b/src/btp/oneP/ComparablePet.java
@@ -0,0 +1,30 @@
+package btp.oneP;
+
+public class ComparablePet implements Comparable<ComparablePet> {
+
+	@Override
+	public int compareTo(ComparablePet o) {
+		return 0;
+	}
+
+}
+
+//�����Ǵ���ģ�����ͬʱ�������Ͳ���
+//class Cat extends ComparablePet implements Comparable<Cat>{}
+
+
+class Hamster extends ComparablePet implements Comparable<ComparablePet>{
+	//��ʵ��͵�����д������Hamster��д�˸���ComparablePet�ķ���
+	@Override
+	public int compareTo(ComparablePet o) {
+		return 0;
+	}
+}
+
+//Gecko��Hanster��Ч��һ��
+class Gecko extends ComparablePet{
+	@Override
+	public int compareTo(ComparablePet o) {
+		return 0;
+	}
+}
diff --git a/src/btp/oneP/Covarance.java b/src/btp/oneP/Covarance.java
@@ -0,0 +1,90 @@
+package btp.oneP;
+
+public class Covarance {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		BaseX bx = new BaseX();
+		DerivedX dx = new DerivedX();
+		DerivedSetter d = new DerivedSetter();
+		d.set(dx);
+		d.set(bx);
+		//----------------
+		DerivedGS dgs = new DerivedGS();
+		dgs.set(bx);
+		dgs.set(dx);
+
+	}
+
+}
+
+class BaseX{}
+class DerivedX extends BaseX{}
+
+interface OrdinaryGetter{
+	BaseX get();
+}
+
+interface DerivedGetter extends OrdinaryGetter{
+	DerivedX get();
+}
+
+class CovariantReturnTypes{
+	void test(DerivedGetter d){
+		DerivedX d2 = d.get();
+	}
+}
+
+interface GenericGetter<T extends GenericGetter<T>>{
+	T get();
+}
+
+interface Getter extends GenericGetter<Getter>{
+
+}
+
+class GenericsAndReturnTypes{
+	void test(Getter g){
+		Getter result = g.get();
+		GenericGetter gg = g.get();
+	}
+}
+
+
+class OrdinarySetter{
+	void set(BaseX base){
+		System.out.println("OrdinarySetter.set(BaseX)");
+	}
+}
+
+class DerivedSetter extends OrdinarySetter{
+	//�ⲻ����д����������
+	void set(DerivedX derived){
+		System.out.println("DerivedSetter.set(Derived)");
+	}
+}
+
+interface SelfBoundSetter<T extends SelfBoundSetter<T>>{
+	void set(T arg);
+}
+
+interface GSetter extends SelfBoundSetter<GSetter>{}
+
+class SelfBoundingAndCovariantArgument{
+	void testA(GSetter s1,GSetter s2,SelfBoundSetter sbs){
+		s1.set(s2);
+		//s1.set(sbs);
+	}
+}
+
+class GenericSetter<T>{
+	void set(T t){
+		System.out.println("GenericSetter.set(Base)");
+	}
+}
+
+class DerivedGS extends GenericSetter<BaseX>{
+	void set(DerivedX derivedx){
+		System.out.println("DerivedGS.set(Derived)");
+	}
+}
diff --git a/src/btp/oneP/Employee.java b/src/btp/oneP/Employee.java
@@ -0,0 +1,33 @@
+package btp.oneP;
+
+public class Employee implements Payable{
+
+	@Override
+	public void getPay() {
+		// TODO Auto-generated method stub
+
+	}
+
+}
+
+
+interface Payable<T>{
+	void getPay();
+}
+
+class Hourly extends Employee implements Payable{}
+
+
+
+/*public class Employee implements Payable<Employee>{
+
+	@Override
+	public void getPay() {
+		// TODO Auto-generated method stub
+
+	}
+
+}
+
+
+class Hourly extends Employee implements Payable<Hourly>{}*/
diff --git a/src/btp/oneP/GenericErase.java b/src/btp/oneP/GenericErase.java
@@ -0,0 +1,22 @@
+package btp.oneP;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+
+public class GenericErase {
+
+	public static void main(String[] args) {
+		ArrayList<String> sl = new ArrayList<String>();
+		sl.add("Magic");
+		Class<? extends ArrayList> clazz = sl.getClass();
+		try{
+			Method method = clazz.getMethod("add", Object.class);
+			method.invoke(sl, 1);
+			System.out.println(sl);
+			//out:[Magic, 1]
+		}catch(Exception e){
+			e.printStackTrace();
+		}
+	}
+
+}
diff --git a/src/btp/oneP/GenericEvaluate.java b/src/btp/oneP/GenericEvaluate.java
@@ -0,0 +1,29 @@
+package btp.oneP;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class GenericEvaluate {
+
+	public static void main(String[] args) {
+		Collection<Pair<String,Long>> c1 = new ArrayList<Pair<String,Long>>();
+		Collection<Pair<String,Long>> c2 = c1;
+		//Collection<Pair<String,?>> c3 = c1;
+		Collection<? extends Pair<String,?>> c4 = c1;
+
+		Collection<SubTypeOfPair<String,Long>> c5 = new ArrayList<SubTypeOfPair<String,Long>>();
+		//Collection<Pair<String,Long>> c6 = c5;
+		Collection<SubTypeOfPair<String,Long>> c7 = c5;
+		//Collection<Pair<String,?>> c8 = c5;
+		Collection<? extends Pair<String,?>> c9 = c5;
+	}
+
+}
+
+class Pair<K,V>{
+
+}
+
+class SubTypeOfPair<K,V> extends Pair<K, V>{
+
+}
diff --git a/src/btp/oneP/GenericExceptionTest.java b/src/btp/oneP/GenericExceptionTest.java
@@ -0,0 +1,11 @@
+package btp.oneP;
+//The generic class GenericExceptionTest<T> may not subclass java.lang.Throwable
+//public class GenericExceptionTest<T> extends Exception  X
+public class GenericExceptionTest{
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+
+	}
+
+}
diff --git a/src/btp/oneP/ListCopy.java b/src/btp/oneP/ListCopy.java
@@ -0,0 +1,24 @@
+package btp.oneP;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class ListCopy {
+
+	public static <T> void copy(List<? extends T> src,List<? super T> dest){
+		for(T t:src){
+			dest.add(t);
+		}
+	}
+
+	public static void main(String[] args) {
+		List<String> sList = new ArrayList<String>(Arrays.<String>asList(new String[]{"hehe","xixi","caca"}));
+		List<Object> oList = new ArrayList<Object>();
+		copy(sList,oList);
+		for(Object o:oList){
+			System.out.println(o);
+		}
+	}
+
+}