简化下 为了理解

laileon · laileon · commit 572500a24163 · 2018-07-11T16:48:54.000+08:00
diff --git a/src/com/blankj/custom/rxjava/Observable.java b/src/com/blankj/custom/rxjava/Observable.java
@@ -4,7 +4,8 @@ public class Observable<T> {
     //接口，每个Observable里面有一个OnSubscribe对象，只有一个方法（void call(Subscriber<? super T> subscriber);），
     // 用来产生数据流，这是典型的命令模式。
     public interface OnSubscribe<T> {
-        void call(Subscriber<? super T> subscriber);
+//        void call(Subscriber<? super T> subscriber);
+        void call(Subscriber<T> subscriber);
     }
 
     //接口实现类
@@ -20,9 +21,9 @@ public static <T> Observable<T> create(OnSubscribe<T> onSubscribe) {
         return new Observable<T>(onSubscribe);
     }
 
-    public void subscribe(Subscriber<? super T> subscriber) {
+    public void subscribe(Subscriber<T> subscriber) {
         System.out.println("will call subscriber");
-        subscriber.onStart();
+//        subscriber.onStart();
         //onSubscribe来call这个subscriber
         onSubscribe.call(subscriber);
     }
diff --git a/src/com/blankj/custom/rxjava/Subscriber.java b/src/com/blankj/custom/rxjava/Subscriber.java
@@ -2,6 +2,6 @@
 
 public abstract class Subscriber<T> implements Observer<T> {
     //抽象类可以抽象方法，或者具体实现，此处为具体实现
-    public void onStart() {
-    }
+//    public void onStart() {
+//    }
 }
diff --git a/src/com/blankj/custom/rxjava/Test.java b/src/com/blankj/custom/rxjava/Test.java
@@ -5,7 +5,7 @@ public static void main(String[] args) {
         Observable.create(new Observable.OnSubscribe<Integer>() {
             //实例化接口实现类，需要override
             @Override
-            public void call(Subscriber<? super Integer> subscriber) {
+            public void call(Subscriber<Integer> subscriber) {
                 System.out.println("call method execute");
                 for (int i = 0; i < 10; i++) {
                     System.out.println("Prepare data " + i);

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,8 @@ public class Observable<T> {`
`4`	`4`	`//接口，每个Observable里面有一个OnSubscribe对象，只有一个方法（void call(Subscriber<? super T> subscriber);），`
`5`	`5`	`// 用来产生数据流，这是典型的命令模式。`
`6`	`6`	`public interface OnSubscribe<T> {`
`7`		`- void call(Subscriber<? super T> subscriber);`
	`7`	`+// void call(Subscriber<? super T> subscriber);`
	`8`	`+ void call(Subscriber<T> subscriber);`
`8`	`9`	`}`
`9`	`10`
`10`	`11`	`//接口实现类`
`@@ -20,9 +21,9 @@ public static <T> Observable<T> create(OnSubscribe<T> onSubscribe) {`
`20`	`21`	`return new Observable<T>(onSubscribe);`
`21`	`22`	`}`
`22`	`23`
`23`		`- public void subscribe(Subscriber<? super T> subscriber) {`
	`24`	`+ public void subscribe(Subscriber<T> subscriber) {`
`24`	`25`	`System.out.println("will call subscriber");`
`25`		`- subscriber.onStart();`
	`26`	`+// subscriber.onStart();`
`26`	`27`	`//onSubscribe来call这个subscriber`
`27`	`28`	`onSubscribe.call(subscriber);`
`28`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,6 @@`
`2`	`2`
`3`	`3`	`public abstract class Subscriber<T> implements Observer<T> {`
`4`	`4`	`//抽象类可以抽象方法，或者具体实现，此处为具体实现`
`5`		`- public void onStart() {`
`6`		`- }`
	`5`	`+// public void onStart() {`
	`6`	`+// }`
`7`	`7`	`}`