Java-泛型（JavaGenericDemoClass）

//手机 请 上下左右 滑动屏幕 观看更全 ！

//package Main;
//泛型

/**
 * @SaySomething(我觉得我应该说点什么的)：
 *      :泛型从jdk1.5之后追加到Java里面的，其主要的目的是为了解决ClassCastException的问题。
 *       在进行对象的向下转型永远都可能存在安全隐患，儿Java希望通过泛型可以慢慢解决掉此类问题。
 *      -类中的属性或方法的参数与返回值的类型可以有对象实例化的时候动态决定。
 *      -泛型的使用范围可以是 接口、类、方法等（定义方式有所不同）
 *      -泛型接口：除了可以在类上定义在外还可以在接口中同样可以使用
 *      -泛型方法：在之前的程序类里面实际上已经可以发现在泛型类中如果将泛型标记在了方法上，
 *       那么这样的方法即 泛型方法 。
 * @Attention(注意)：
 *      1、泛型中只允许设置引用类型，如果要操作基本数据类型必须使用包装类。
 *      2、通配符的上限：指只能本类或其子类<？ extends 对象>
 *      3、通配符的下限：指只能本类或其父类<？ super 对象>
 *      4、泛型接口：有两种实现方式
 *      5、
 *      6、
 * @time(时间)：-2019/04/27
 * @role(谁)：-杨木发
 *
 * @modify(修改)-:
 * -@time：
 * -@role：
 */
public class GenericDemoClass {
    public static void main(String[] args) {
        //泛型
        Point<Integer>point = new Point<Integer>() ;
        //可简写为 Point<Integer>point = new Point<>() ;
        point.setX(10) ;//自动装箱
        point.setY(30) ;//自动装箱
        int x1 = point.getX() ; //自动拆箱
        Integer y1 = point.getY() ;
        System.out.println("X坐标："+x1+" - Y坐标："+y1);

        //泛型通配符
        Message <String>mge = new Message<String>() ;
        mge.setContent("yangmufa") ;
        //fun(mge) ; //此时的fun(Message<String> temp)方法如果真的去使用泛型不可能只是一种类型，
        //也就是说fun(Message<String> temp)方法应该可以接收任意种泛型的Message对象才满足需求，
        //而且这个时候发现在不是在泛型通配符的情况下，那么方法之中就有可能对你的数据进行修改
        // 例如在public static void fun(Message<?> temp)方法里执行temp.setContent("yyy");，
        //就可以修改content的值，所以此时是存在安全隐患的，要解决此问题就得使用泛型通配符
        //例如：public static void fun(Message<?> temp)  ，把原来的String替换为 ？
        // 就是通配符的定定义了
        Message <String>mge1 = new Message<>() ;
        mge1.setContent("杨木发好帅！ ");
        //fun(mge1) ;

        //通配符的上限：指只能本类或其子类<？ extends 对象> ,例如：
        // Message <Integer>mge2 = new Message1<Integer>() ;
        Message <Integer>mge2 = new Message<Integer>() ;
        mge2.setContent(330) ;
        //fun(mge2) ;

        //通配符的下限：指只能本类或其父类<？ super 对象> ,例如：
        //Message <Integer>mge3 = new Message<Integer>() ;
        Message <Double>mge3 = new Message<Double>() ;
        Double D =36.666 ;
        mge3.setContent(D) ;
        fun(mge3);

        //泛型接口
        //实现方式一：在子类中继续设置泛型定义 例如：
        //class MessageImpl1<S> implements IMessage1<S>{}
        MessageImpl1<String> mge4 = new MessageImpl1<String>() ;
        String l = mge4.echo("木发好帅啊！") ;
        System.out.println(l);
        //实现方式二：在子类实现父类的时候直接定义出具体泛型类型 例如：
        //class MessageImpl1<S> implements IMessage1<String>{}

        //泛型方法：被标有泛型标记的方法为泛型方法 例如：
        //public static <I> I[] ff(I...i){}
        Double num[] = ff(2.4,32.5) ;
        for(double i:num)
        System.out.println(i) ;

    }
    public static void fun(Message<? extends Double> temp){
       // temp.setContent("yyy");
        System.out.println(temp.getContent());
    }
    public static <I> I[] ff(I...i){
        return i ;
    }

}


//定义一个泛型类,Point类中的x与y的数据类型并不确定，而是由外部来决定的
class Point<T>{ //T为类型（Type）
    private T x ;
    private T y ;

    public void setX(T x){
        this.x=x ;
    }

    public void setY(T y){
        this.y=y ;
    }

    public T getX(){
        return this.x ;
    }

    public T getY(){
        return this.y ;
    }
}


//泛型通配符
//泛型虽然帮助开发者解决了一系列的强制转换带来的安全隐患，但是从另外一个角度来讲，
//泛型也带来了一些新的问题：（引用传递处理）
class Message<Y>{
    private Y content ;

    public void setContent(Y content){
        this.content=content ;
    }

    public Y getContent(){
        return this.content ;
    }
}


interface IMessage1<U>{
    public abstract String echo(U u) ;
}

class MessageImpl1<S> implements IMessage1<S>{
    public String echo(S t){
        return "echo"+t ;
    }

}

/*-------------------反爬声明o(▽)咻咻咻--------------------
 

作者：**杨木发** 版权声明： 本文为博主倾情原创文章，整篇转载请附上源文链接！

如果觉得本文对你有所收获，你的请评论点赞 与

合理优质的转发也将是鼓励支持我继续创作的动力，

更多精彩可百度搜索 杨木发 或：

个人网站：杨木发的自留地 - 此地无银三百两 ，

GitHub：https://github.com/yangmufa ，

坚持创作 善于总结 开源共享 高质进步。

-------------------反爬声明o(▽)咻咻咻--------------------*/