package com.aaa.test;

/*

 * 演示 泛型方法  对方法的修饰哦

 * 作用 提高代码的重用性 减少了重载方法的使用

 * 实列

 *

 */

import static org.junit.Assert.*;

import org.junit.Test;

import com.aaa.entity.People;

import com.aaa.entity.User;

public class Demo03 {

    //在run01 方法前  定义了一个<W>  参数列表是(W     w)

    // W 的默认类型是object  就是可以放各种类型的值

    public <W>void run01(W w) {

        System.out.println("run01方法在执行 w的值："+w);

    }

    public<R> void run02(R r) {

        System.out.println("体验泛型的强大和快捷----"+r);

    }

    public static void main(String[] args) {

        Demo03 d = new Demo03();

        //写入的值就是  w 的值   写入的是一个对象  w 就等于这个对象。

        d.run01("哈哈");

        d.run01(456);

        d.run01('c');

        User u = new User(2,"马飞飞");

        d.run01(u);

    }

    @Test

    public void testName() throws Exception {

        Demo03 d = new Demo03();

        d.run02("泛型默认是object类型  可以放各种类型的数据");

        d.run02(666);

    }

    @Test

    public void test01() throws Exception {

        //已经知道泛型 默认是object  对象  那么是否可以将我所定义的实体类 放在里面使用呢？

        Demo03 d = new Demo03();

        //在user中定义了 id  和name

        User u = new User(1,"卢本伟牛逼！");

        d.run01(u);     //为什么会显示  demofanxing ?    就是在user 实体类中tostring中 返回的对象就是user  此时w 的值就是user这个对象。

        People p = new People(2,"sadf");

        d.run01(p);   //w 的值 

    }

}

package com.aaa.test;

import static org.junit.Assert.*;

import org.junit.Test;

import com.aaa.entity.User;

/*

 * 演示 在泛型中一次 定义多个

 * 定义多个参数时 中间用逗号隔开。

 *

 * 同理，这里定义的泛型 默认值也是object

 *

 */

public class Demo06 {

    public <S, B> void test01(S s ,B b) {

        System.out.println("定义的s的值是："+s+"----定义的b的值是："+b);

    }

    public static void main(String[] args) {

        Demo06 d= new Demo06();

        d.test01("你好", "我是枫旭");

        d.test01(66, 999);        

    }

    @Test

    public void testName() throws Exception {

        Demo06 d = new Demo06();

        //引入对象

        User u1 = new User(1,"泛型");

        User u2 = new User(1,"定义两个");

        d.test01(u1, u2);

        d.test01(u1, "混着用");

    }

}

package com.aaa.test;

import java.util.ArrayList;

import java.util.List;

import com.aaa.entity.User;

/*

 * 演示  泛型中的通配符。

 * list<?> lists 在list中定义的是？

 *

 * 下面在list中想定义什么引用数据类型  就定义啥、

 * 当list中的数据类型被定义之后，后面的就固定了。

 *

 */

public class Demo07 {

    public void test01(List<?> list) {

        System.out.println("输出list01集合的长度----"+list.size());

    }

    public static void main(String[] args) {

        Demo07 d = new Demo07();

        //新建一个list集合  给通配符   定义引用数据类型

        // 将之前的user放在这里。

        List<User>list01=new ArrayList<>();

        //user放入值

        User u = new User(1,"哈哈");

        User u2 = new User(2,"嘻嘻");

        //添加到list集合中

        list01.add(u);

        list01.add(u2);

        d.test01(list01);

        //便利list01集合中的数据

        for (User user : list01) {

            System.out.println(user);

        }

    }

}

package com.aaa.test;

import java.util.HashMap;

import java.util.Map;

public class Demo08 {

    public void test01(Map<?, ?>map) {

        System.out.println("map的长度---"+map.size());

    }

    public static void main(String[] args) {

        Demo08 d = new Demo08();

        //给通配符定义数据类型  integer， string

        Map<Integer, String>map01=new HashMap<>();

        //这边就只能按照  integer  和string 的类型  来添加数据。

         map01.put(1, "lubenwei");

         map01.put(2, "马飞飞");

         System.out.println(map01);

    }

}

package com.aaa.test;

import static org.junit.Assert.*;

import java.util.ArrayList;

import java.util.List;

import com.aaa.entity.People;

import com.aaa.entity.User;

import com.aaa.entity.ZiUser;

/*

 * 通配符  参数约束

 *  ? extends User  此时  user的子类 ziUser 就可以使用。

 *  ？super  User  同理  user的父类 people  就可以使用。

 *

 *  ？extends  E  当前类的和他的父类  所有的对象都可以使用。

 *

 *子类  父类

 *

 */

public class Demo09 <E>{

    public void test01(List<? extends User>list) {

        System.out.println("extends 包含该类和他的子类的所有对象类型"+list);

    }

    // people的子类 是user  用super之后 user对象也能使用。

    public void test02(List<? super User>list) {

        System.out.println("super 包含该类和他的父类的所有对象类型"+list);

    }

    public void test03(List<? extends E>list) {

        System.out.println(" ? extends  E 包含该类和他的父类的所有对象类型"+list);

    }

    public static void main(String[] args) {

        Demo09<Object> d = new Demo09<>();

        //user的子类是ziUser  因为 extends  所以这里可以使用！

        List<ZiUser>list0101=new ArrayList<>();

        List<User>list01=new ArrayList<>();

        //添加数据

        User u1 = new User(5,"嘻嘻");

        list0101.add(new ZiUser(2,"你好"));

        // index    user

        list01.add(0,u1);

        d.test01(list0101);

        d.test01(list01);

        System.out.println("---------------------");

        //把user的父类people放进去

        List<People>list02=new ArrayList<>();

        List<User>list0201=new ArrayList<>();

        list0201.add(new User(2,"用super之后，user的父类 people也可以使用"));

        list02.add(new People(5,"类people"));

        d.test02(list02);

        d.test02(list0201);

    }

}