java中的泛型，简单介绍。 修饰方法的用法

一、<R>  ( R  r ) 默认object  可以存所有类型。   R 这个是随便定义的大写字母，前后要保持一致性！

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);

    }

}

四、通配符参数约束：?  extends 类  包含该自身及其子类的所有对象类型

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);

    }

}