diff --git a/src/btp/oneP/Byteset.java b/src/btp/oneP/Byteset.java
new file mode 100644
index 0000000..35a79c7
--- /dev/null
+++ 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
new file mode 100644
index 0000000..d20f854
--- /dev/null
+++ 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>{}
\ No newline at end of file
diff --git a/src/btp/oneP/CaptureConversion.java b/src/btp/oneP/CaptureConversion.java
new file mode 100644
index 0000000..964ae23
--- /dev/null
+++ 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
new file mode 100644
index 0000000..cf99872
--- /dev/null
+++ 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
new file mode 100644
index 0000000..b80fa8c
--- /dev/null
+++ 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
new file mode 100644
index 0000000..ba87d94
--- /dev/null
+++ 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;
+	}
+}
\ No newline at end of file
diff --git a/src/btp/oneP/Covarance.java b/src/btp/oneP/Covarance.java
new file mode 100644
index 0000000..9fecfcf
--- /dev/null
+++ 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)");
+	}
+}
\ No newline at end of file
diff --git a/src/btp/oneP/Employee.java b/src/btp/oneP/Employee.java
new file mode 100644
index 0000000..0a98de3
--- /dev/null
+++ 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>{}*/
\ No newline at end of file
diff --git a/src/btp/oneP/GenericErase.java b/src/btp/oneP/GenericErase.java
new file mode 100644
index 0000000..ac37850
--- /dev/null
+++ 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
new file mode 100644
index 0000000..caa27e1
--- /dev/null
+++ 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
new file mode 100644
index 0000000..e26e6cf
--- /dev/null
+++ 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
new file mode 100644
index 0000000..9c4cae4
--- /dev/null
+++ 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);
+		}
+	}
+
+}
diff --git a/src/btp/oneP/SelfBounded.java b/src/btp/oneP/SelfBounded.java
new file mode 100644
index 0000000..2c23aff
--- /dev/null
+++ b/src/btp/oneP/SelfBounded.java
@@ -0,0 +1,52 @@
+package btp.oneP;
+
+//泛型归根到底就是一种限定
+public class SelfBounded<T extends SelfBounded<T>>{
+	T element;
+	SelfBounded<T> set(T t){
+		this.element = t;
+		return this;
+	}
+	T get(){
+		return this.element;
+	}
+	
+	public static void main(String[] args) {
+		AS as = new AS();
+		as.set(new AS());
+		as=as.set(new AS()).get();
+		as = as.get();
+		CS cs = new CS();
+		cs = cs.set(new CS()).get();
+		
+		BS bs = new BS();
+		bs.set(new AS());
+		as = bs.get();
+		as = bs.set(new AS()).get();
+	}
+
+}
+/*
+ * T为AS
+ * AS继承自SelfBounded
+ */
+class AS extends SelfBounded<AS>{}
+
+/*
+ * T为BS
+ * BS继承自SelfBounded
+ */
+class BS extends SelfBounded<AS>{}
+
+class CS extends SelfBounded<CS>{}
+
+class D{}
+/*
+ * D不是集成自SelfBounded，所以出错
+ */
+//class E extends SelfBounded<D>{}
+/*
+ * SelfBounded渴望一个类型参数，但是没有，所以会出警告
+ */
+class F extends SelfBounded{}
+
diff --git a/src/btp/oneP/ThrowGenericException.java b/src/btp/oneP/ThrowGenericException.java
new file mode 100644
index 0000000..295bcea
--- /dev/null
+++ b/src/btp/oneP/ThrowGenericException.java
@@ -0,0 +1,83 @@
+package btp.oneP;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ThrowGenericException {
+
+	public static void main(String[] args) {
+		ProcessRunner<String,Failure1> runner = new ProcessRunner<String,Failure1>();
+		for(int i=0;i<3;i++){
+			runner.add(new Processor1());
+		}
+		try{
+			System.out.println(runner.processAll());
+		}catch(Failure1 e){
+			e.printStackTrace();
+		}
+		
+		ProcessRunner<Integer,Failure2> runner2 = new ProcessRunner<Integer,Failure2>();
+		for(int i=0;i<3;i++){
+			runner2.add(new Processor2());
+		}
+		
+		try{
+			System.out.println(runner2.processAll());
+		}catch(Failure2 e){
+			e.printStackTrace();
+		}
+	}
+
+}
+
+interface Processor<T,E extends Exception>{
+	void process(List<T> resultCollector) throws E;
+}
+
+class ProcessRunner<T,E extends Exception>
+	extends ArrayList<Processor<T,E>>{
+		List<T> processAll() throws E{
+			List<T> resultCollector = new ArrayList<T>();
+			for(Processor<T,E> p:this){
+				p.process(resultCollector);
+			}
+			return resultCollector;
+		}
+}	
+
+class Failure1 extends Exception{}
+
+class Processor1 implements Processor<String,Failure1>{
+	static int count = 3;
+	@Override
+	public void process(List<String> resultCollector) throws Failure1 {
+		if(count-- > 1){
+			resultCollector.add("Hep!");
+		}else{
+			resultCollector.add("Ho!");
+		}
+		if(count < 0){
+			throw new Failure1();
+		}
+	}
+	
+}
+
+
+class Failure2 extends Exception{}
+
+class Processor2 implements Processor<Integer,Failure2>{
+	static int count = 3;
+	@Override
+	public void process(List<Integer> resultCollector) throws Failure2 {
+		if(count-- == 0){
+			resultCollector.add(47);
+		}else{
+			resultCollector.add(11);
+		}
+		if(count < 0){
+			throw new Failure2();
+		}
+	}
+	
+}
diff --git a/src/btp/oneP/Wildcards.java b/src/btp/oneP/Wildcards.java
index 6dbdec3..4a5cec9 100644
--- a/src/btp/oneP/Wildcards.java
+++ b/src/btp/oneP/Wildcards.java
@@ -62,6 +62,21 @@ public static void main(String[] args) {
 		System.out.println(r3);
 		Long r4 = exact1(bounded);
 		System.out.println(r4);
+		
+		Long r5 = exact2(raw,lng);
+		Long r6 = exact2(qualified,lng);
+		//Long r7 = exact2(unbounded,lng);
+		//Long r8 = exact2(bounded,lng);
+		
+		Long r9 = wildSubtype(raw,lng);
+		Long r10 = wildSubtype(qualified,lng);
+		Object r11 = wildSubtype(unbounded,lng);
+		Long r12 = wildSubtype(bounded,lng);
+		
+		wildSupertype(raw,lng);
+		wildSupertype(qualified,lng);
+		//wildSupertype(unbounded,lng);
+		//wildSupertype(bounded,lng);
 	}
 
 }