test

Author: huiruo

src/com/practise2/p10_fanxing2.java

@@ -0,0 +1,116 @@
+package com.practise2;
+
+//--------------->如何设置支持泛型的类
+//-------------->01.不支持泛型的Stack
+/*
+以Stack栈为例子，如果不使用泛型
+当需要一个只能放Hero的栈的时候，就需要设计一个HeroStack
+当需要一个只能放Item的栈的时候，就需要一个ItemStack
+* */
+//HeroStack
+public class p10_fanxing2 {
+
+}
+/*实例代码1
+package generic;
+import java.util.LinkedList;
+import charactor.Hero;
+public class HeroStack {
+    LinkedList<Hero> heros = new LinkedList<Hero>();
+    public void push(Hero h) {
+        heros.addLast(h);
+    }
+    public Hero pull() {
+        return heros.removeLast();
+    }
+    public Hero peek() {
+        return heros.getLast();
+    }
+    public static void main(String[] args) {
+        HeroStack heroStack = new HeroStack();
+        for (int i = 0; i < 5; i++) {
+            Hero h = new Hero("hero name " + i);
+            System.out.println("压入 hero:" + h);
+            heroStack.push(h);
+        }
+        for (int i = 0; i < 5; i++) {
+            Hero h =heroStack.pull();
+            System.out.println("弹出 hero" + h);
+        }
+    }
+}
+* */
+
+/*实例代码2
+package generic;
+import java.util.LinkedList;
+import property.Item;
+public class ItemStack {
+    LinkedList<Item> Items = new LinkedList<Item>();
+    public void push(Item h) {
+        Items.addLast(h);
+    }
+    public Item pull() {
+        return Items.removeLast();
+    }
+    public Item peek() {
+        return Items.getLast();
+    }
+    public static void main(String[] args) {
+        ItemStack ItemStack = new ItemStack();
+        for (int i = 0; i < 5; i++) {
+            Item item = new Item("Item name " + i);
+            System.out.println("压入 Item:" + item);
+            ItemStack.push(item);
+        }
+        for (int i = 0; i < 5; i++) {
+            Item item =ItemStack.pull();
+            System.out.println("弹出 Item" + item);
+        }
+    }
+}
+* */
+
+
+
+//----------------->02.支持泛型的Stack
+/*
+设计一个支持泛型的栈MyStack
+设计这个类的时候，在类的声明上，加上一个<T>，表示该类支持泛型。
+T是type的缩写，也可以使用任何其他的合法的变量，比如A,B,X都可以，但是一般约定成俗使用T，代表类型。
+* */
+/*
+package generic;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import charactor.Hero;
+import property.Item;
+
+public class MyStack<T> {
+    LinkedList<T> values = new LinkedList<T>();
+    public void push(T t) {
+        values.addLast(t);
+    }
+    public T pull() {
+        return values.removeLast();
+    }
+    public T peek() {
+        return values.getLast();
+    }
+    public static void main(String[] args) {
+        //在声明这个Stack的时候，使用泛型<Hero>就表示该Stack只能放Hero
+        MyStack<Hero> heroStack = new MyStack<>();
+        heroStack.push(new Hero());
+        //不能放Item
+        heroStack.push(new Item());
+
+        //在声明这个Stack的时候，使用泛型<Item>就表示该Stack只能放Item
+        MyStack<Item> itemStack = new MyStack<>();
+        itemStack.push(new Item());
+        //不能放Hero
+        itemStack.push(new Hero());
+    }
+}
+* */
+

src/com/practise2/readme.md

@@ -15,3 +15,5 @@ final 关键字
 
 内部类  
 
+泛型
+

笔记和学习方法/06_02_lambda表达式.md

@@ -25,11 +25,10 @@
 > //平时的写法
 > @Test
 >     public void test1() {
->         Runnable runnable = new Runnable() {
->             
+>         Runnable runnable = new Runnable() {       
 >             @Override
 >             public void run() {
->         System.out.println("线程启动了");        
+>         			System.out.println("线程启动了");        
 >             }
 >         };
 >         runnable.run();
@@ -44,25 +43,25 @@
 >     Runnable runnable = ()->System.out.println("线程启动了");    
 >     runnable.run();
 >     }
-> ```
->
-> ```java
+>  ```
+> 
+>```java
 > public static void main(String[] args) {
->     new Thread(new Runnable() {
+>    new Thread(new Runnable() {
 >         @Override
 >         public void run() {
 >             System.out.println("匿名内部类的执行");
 >         }
 >     }).start();
-> }
+>  }
 > //设计匿名内部类的目的，就是为了方便程序猿将代码作为数据来传递。但是你会发现，这个对象看起来是很多余的，所以我们不想传入对象，只想传入行为。
 > 
 > new Thread(()->{
->     System.out.println("lambda代替内部类");
-> }).start();
+>    System.out.println("lambda代替内部类");
+>  }).start();
 > //和实现某接口的对象不同，我们传入了一段代码块--一个没有名字的函数。->将参数和表达式主体分开，左边是参数，右边是方法体。
 > ```
->
+> 
 
 
 
@@ -76,7 +75,7 @@
 >     (String first, String second)
 >     -> first.length() - second.length()
 >     
-> //这 就 是 你 看 到 的 第 一 个 表 达 式。 lambda 表达式就是一个代码块， 以及必须传人
+> //这 就 是 你 看 到 的 第 一 个 表 达 式。 lambda 表达式就是一个代码块， 以及必须传入
 > //代码的变量规范。
 > ```
 >