add many things

lecture/src/lecture4_3.java

@@ -28,8 +28,6 @@ public static Dog max(Dog[] items){
 
     public static void getWords(String inputFileName){
         List<String> lst = new ArrayList<String>();
-        In in = new In();
-
     }
 }
 

lecture/src/lecutre4_1.java

@@ -27,5 +27,44 @@ public static String smallest(SList<String> input){
     }
 }
 
+class SLList<Item> implements List61B<Item>{
+
+    @Override
+    public void addFirst(Item x) {
+    }
+
+    @Override
+    public void addLast(Item y) {
+    }
+
+    @Override
+    public Item getFirst() {
+        return null;
+    }
+
+    @Override
+    public Item getLast() {
+        return null;
+    }
+
+    @Override
+    public Item removeLast() {
+        return null;
+    }
+
+    @Override
+    public Item get(int i) {
+        return null;
+    }
+
+    @Override
+    public void insert(Item x, int position) {
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+}
 
 

lecture_4.md

@@ -239,7 +239,7 @@ public static void main(String[] args) {
 
 试想一下，一旦有很多子类，那么这个工作量将会比没有使用向上转型大很多。这也表明向上转型还有个优点就是提高了代码的简洁性。
 
-**重点：经过向上转型之后，在利用.操作符访问时，如果访问的是对象的属性，则编译的话就是看父类，运行同样是看父类；如果访问的是方法，编译就看父类，运行则看子类；如果访问的是父类中表明的static methods，尽管子类已经进行override，但编译和运行都是看父类**
+**重点：经过向上转型之后，在利用.操作符访问时，如果访问的是对象的属性，则编译的话就是看父类，运行同样是看父类；如果访问的是方法，编译就看父类，运行则看子类；如果访问的是父类中标明的static methods，尽管子类已经进行override，但编译和运行都是看父类**
 
 ### High order function(高阶函数，HOF)
 
@@ -377,8 +377,6 @@ Exception in thread "main" java.lang.ClassCastException: class SList cannot be c
 	at lecture4_2.main(lecture4_2.java:14)
 ```
 
-
-
 ### 内置Comparable接口
 
 事实上，java内置的Comparable接口与我们构建的Ourcomparable接口仅有细微的差别，其内置接口定义如下：

未完成的任务.md

@@ -1,8 +1,6 @@
-# 双向链表（Intnode中的prev指针）（project1 待完成）
+### 双向链表（Intnode中的prev指针）（project1 待完成）
 
-# 你泛型还没有真正弄懂！
+### lecutre 4.4中所有的excerises都没有做！
 
-# 继承与接口实现中java的向上转型与向下转型！
 
-# java静态类型与动态类型（向上转型后**dynamic method selection**，并不适用于overloaded方法）