精华内容
下载资源
问答
  • 范型

    2021-03-01 23:11:40
    为什么需要范型? 1.适用于多种数据类型,执行相同的代码。 2.使用范型后,在编码的时候可以直接指定数据类型,插入错误的数据类型,在编译期间直接不通过。

    为什么需要范型?

    1.适用于多种数据类型,执行相同的代码。

    2.使用范型后,在编码的时候可以直接指定数据类型,插入错误的数据类型,在编译期间直接不通过。

    展开全文
  • 消息传递范型与C/S范型范型的主数据管理机制,陈晓云,邢乔金,本文针对主数据管理(MDM)存在的问题提出了一种基于消息传递机制范型与C/S范型范型的主数据管理机制,当各个分系统的数据有所变化�
  • Java范型类 public class FanXingClassTest { public static void main(String args[]){ Test<Integer> intObj = new Test<Integer>(123); Test<String> strObj = ne...

    Java范型类

    public class FanXingClassTest {
        public static void main(String args[]){
            Test<Integer> intObj = new Test<Integer>(123);
            Test<String> strObj = new Test<String>("一二三");
            intObj.showType();
            strObj.showType();
        }
    }
    
    /**
     * 定义范型类
     * @param <T>
     */
    class Test<T>{
        private T ob; //定义范型的成员变量
    
        public Test(T ob){
            this.ob = ob;
        }
    
        public void setT(T ob){
            this.ob = ob;
        }
        public T getT(){
            return this.ob;
        }
    
        public void showType(){
            System.out.println("T的实际类型是:"+ob.getClass());
        }
    }

      对比一下没有使用范型类(如下代码),也可以输出一样的结果,为什么要使用范型类?类型检查??

    public class FanXingClassTest {
        public static void main(String args[]){
            Test intObj = new Test(123);
            Test strObj = new Test("一二三");
            intObj.showType();
            strObj.showType();
        }
    }
    /**
     * 定义普通类
     */
    class Test{
        private Object ob; // 不能定义T类型的变量??
    
        public Test(Object ob){
            this.ob = ob;
        }
    
        public void setT(Object ob){
            this.ob = ob;
        }
        public Object getT(){
            return this.ob;
        }
    
        public void showType(){
            System.out.println("T的实际类型是:"+ob.getClass());
        }
    }

    我们做实验如下:

    // 两个基本类:StringDemo和DoubleDemo
    public class StringDemo {
        private String str;
    
        public StringDemo(String str){
            this.str = str;
        }
    
        public void setStr(String str){
            this.str = str;
        }
        public String getStr(){
            return this.str;
        }
    }
    public class DoubleDemo {
        private Double doubleVal;
    
        public DoubleDemo(Double doubleVal){
            this.doubleVal = doubleVal;
        }
        public void setDoubleVal(Double doubleVal){
            this.doubleVal = doubleVal;
        }
        public Double getDoubleVal(){
            return this.doubleVal;
        }
    }
    
    // 因为上面的类中,成员和方法的逻辑都一样,就是类型不一样,因此考虑重构。Object是所有类的父类,因此可以考虑用Object做为成员类型,这样就可以实现通用了,实际上就是“Object泛型”,暂时这么称呼。
    public class ObjectDemo {
        private Object obj;
    
        public ObjectDemo(Object obj){
            this.obj = obj;
        }
        public void setObj(Object obj){
            this.obj = obj;
        }
        public Object getObj(){
            return this.obj;
        }
    }
    public class MyDemo {
        public static void main(String args[]){
            ObjectDemo str = new ObjectDemo("string");
            ObjectDemo dble = new ObjectDemo(123d);
            ObjectDemo obj = new ObjectDemo(new Object());
            System.out.println(str.getObj());
            System.out.println(dble.getObj());
            System.out.println(obj.getObj());
        }
    }
    
    // 在Java 5之前,为了让类有通用性,往往将参数类型、返回类型设置为Object类型,当获取这些返回类型来使用时候,必须将其“强制”转换为原有的类型或者接口,
    // 然后才可以调用对象上的方法。强制类型转换很麻烦,我还要事先知道各个Object具体类型是什么,才能做出正确转换。否则,要是转换的类型不对,比如将
    // “Hello Generics!”字符串强制转换为Double,那么编译的时候不会报错,可是运行的时候就挂了。那有没有不强制转换的办法----有,改用 Java5泛型来实现,
    // 示例见最上面FanXingClassTest<T>范型类的定义。

    范型类语法解释

    1. 使用<T>来声明一个类型持有者名称,然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。
    2. class GenericsTest<T> 声明了一个泛型类,这个T没有任何限制,实际上相当于Object类型,实际上相当于 class GenericsTest<T extends Object>。
    3. 与Object泛型类相比,使用泛型所定义的类在声明和构造实例的时候,可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如
    GenericsTest<Double> douTest=new GenericsTest<Double>(new Double("33"));
    4. 实际上,当构造对象时不指定类型信息的时候,默认会使用Object类型,这也是要强制转换的原因.

    限制范型

      在上面的例子中,由于没有限制class GenericsTest<T>类型持有者T的范围,实际上这里的限定类型相当于Object,这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做:class GenericsTest<T extends Collection>,这样类中的泛型T只能是Collection接口的实现类,传入非Collection接口编译会出错。注意:<T extends Collection>这里的限定使用关键字extends,后面可以是类也可以是接口。但这里的extends已经不是继承的含义了,应该理解为T类型是实现Collection接口的类型,或者T是继承了XX类的类型。
    // 限制范型
    public class CollectionGenTest<T extends Collection> {
        private T x;
        public CollectionGenTest(T x){
            this.x = x;
        }
        public T getX(){
            return this.x;
        }
        public void setX(T x){
            this.x = x;
        }
    }
    public class CollectionGenTestDemo {
        public static void main(String args[]){
            CollectionGenTest<ArrayList> test = new CollectionGenTest<ArrayList>(new ArrayList());
            System.out.println("实例化完成");
        }
    }

    // 多接口限制
    <T extends SomeClass & interface1 & interface2 & interface3>

    // 通配符范型
    <T extends Collection> //向下限制
    <?> //任意类型,相当于Object
    <T super Double> // 向上限制,Double类型或者其父类

    Java范型方法

     

    /**
     * 范型方法:只需在返回值前添加<T>
     */
    public class ExampleA {
        public <T> void f(T x){
            System.err.println(x.getClass().getName());
        }
    
        public static void main(String args[]){
            ExampleA exampleA = new ExampleA();
            exampleA.f("");
            exampleA.f(123);
            exampleA.f('a');
            exampleA.f(exampleA);
        }
    }

    // 使用泛型方法时,不必指明参数类型,编译器会自己找出具体的类型。泛型方法除了定义不同,调用就像普通方法一样
    // 一个static方法,无法访问泛型类的类型参数,所以,若要static方法需要使用泛型能力,必须使其成为泛型方法。

     

    方法

     1. 定义泛型方法时,必须在返回值前边加一个<T>,来声明这是一个泛型方法,

    2. Class<T>的作用就是指明泛型的具体类型,而Class<T>类型的变量c,可以用来创建泛型类的对象。为什么要用变量c来创建对象呢?既然是泛型方法,就代表着我们不知道具体的类型是什么,也不知道构造方法如何,因此没有办法去new一个对象,但可以利用变量c的newInstance方法去创建对象,也就是利用反射创建对象。

     3.   http://www.cnblogs.com/iyangyuan/archive/2013/04/09/3011274.html

    转载于:https://www.cnblogs.com/RunForLove/p/7093532.html

    展开全文
  • Java范型

    2021-03-30 16:40:16
    范型 Generics 让数据类型变得参数化 定义范型时,对应的数据类型是不确定的 范型方法被调用时,会指定具体类型 核心目标,解决容器类型在编译时安全检查的问题 public class GenericDemo { public static void ...

    范型 Generics

    让数据类型变得参数化

    • 定义范型时,对应的数据类型是不确定的
    • 范型方法被调用时,会指定具体类型
    • 核心目标,解决容器类型在编译时安全检查的问题
    public class GenericDemo {
        public static void main(String[] args) {
            List<String> linkedList = new LinkedList();
            linkedList.add("works");
    //        linkedList.add(1);
            for (int i = 0; i < linkedList.size(); i++) {
                String item = (String) linkedList.get(i);
                System.out.println(item);
            }
        }
    }
    

    范型一般用作类型校验

    • 泛型类
    • 范型接口
    • 范型方法
    class 类名称 <范型标识:可以随便写任意标识号,标识指定的范型的类型>{
    	修饰符 范型标识/* ( 成员变量类型) */
    	修饰符 构造函数(范型标识 参数)
    	.......
    } 
    
    public class GenericDemo {
        public static void main(String[] args) {
            GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
            GenericClassExample<Integer> integerExample = new GenericClassExample<Integer>(123);
            System.out.println(stringExample.getMember().getClass());
            System.out.println(integerExample.getMember().getClass());
            System.out.println(integerExample.sayHello("haha"));
        }
    }
    
    
    @Data
    public class GenericClassExample<T> {
    
        //member这个成员变量的类型为T,T的类型由外部指定
        private T member;
        public GenericClassExample(T member) {
            this.member = member;
        }
    
        public T handleSomething(T target){
            return target;
        }
    
        public String sayHello(String name){
            return "Hello" + name;
        }
    
    }
    
    

    泛型类

    • 范型的参数不支持基本类型
    public class GenericDemo {
        public static void handleMember(GenericClassExample<Integer> integerGenericClassExample){
            Integer result = 111 + integerGenericClassExample.getMember();
            System.out.println("result is" + result);
        }
        public static void main(String[] args) {
            GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
            GenericClassExample<Integer> integerExample = new GenericClassExample<Integer>(123);
            System.out.println(stringExample.getClass());
            System.out.println(integerExample.getClass());
            handleMember(integerExample);
        }
    }
    
    
    @Data
    public class GenericClassExample<T> {
    
        //member这个成员变量的类型为T,T的类型由外部指定
        private T member;
        public GenericClassExample(T member) {
            this.member = member;
        }
    
        public T handleSomething(T target){
            return target;
        }
    
        public String sayHello(String name){
            return "Hello" + name;
        }
    
    }
    

    能否在范型里面使用具备继承关系的类

    • 使用通配符?,但是会使得范型的类型检查失去意义
    public class GenericDemo {
        public static void handleMember(GenericClassExample<?> integerGenericClassExample){
            Integer result = 111 + (Integer) integerGenericClassExample.getMember();
            System.out.println("result is" + result);
        }
        public static void main(String[] args) {
            GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
            GenericClassExample<Number> integerExample = new GenericClassExample<Number>(123);
            System.out.println(stringExample.getClass());
            System.out.println(integerExample.getClass());
            handleMember(integerExample);
        }
    }
    
    • 给范型加入上边界 ?extends E
    public class GenericDemo {
        public static void handleMember(GenericClassExample<? extends Number> integerGenericClassExample){
            Integer result = 111 + (Integer) integerGenericClassExample.getMember();
            System.out.println("result is" + result);
        }
        public static void main(String[] args) {
            GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
            GenericClassExample<Number> integerExample = new GenericClassExample<Number>(123);
            System.out.println(stringExample.getClass());
            System.out.println(integerExample.getClass());
            handleMember(integerExample);
        }
    }
    
    
    • 给范型加入下边界 ?super E
    public class GenericDemo {
        public static void handleMember(GenericClassExample<? super Integer> integerGenericClassExample){
            Integer result = 111 + (Integer) integerGenericClassExample.getMember();
            System.out.println("result is" + result);
        }
        public static void main(String[] args) {
            GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
            GenericClassExample<Number> integerExample = new GenericClassExample<Number>(123);
            System.out.println(stringExample.getClass());
            System.out.println(integerExample.getClass());
            handleMember(integerExample);
        }
    }
    

    范型接口

    package com.imooc.demo.generic;
    
    public interface GenericIFactory<T,N> {
        T nextObject();
        N nextNumber();
    }
    
    
    public class GenericFactoryImpl<T,N> implements GenericIFactory<T,N>{
        @Override
        public T nextObject() {
            return null;
        }
    
        @Override
        public N nextNumber() {
            return null;
        }
    }
    
    

    范型方法

    public class GenericDemo {
        public static void handleMember(GenericClassExample<? super Integer> integerGenericClassExample){
            Integer result = 111 + (Integer) integerGenericClassExample.getMember();
            System.out.println("result is" + result);
        }
        public static void main(String[] args) {
            GenericClassExample<String> stringExample = new GenericClassExample<String>("abc");
            GenericClassExample<Number> integerExample = new GenericClassExample<Number>(123);
            System.out.println(stringExample.getClass());
            System.out.println(integerExample.getClass());
            handleMember(integerExample);
            Integer[] integers = {1,2,3,4,5,6};
            Double[] doubles = {1.1,1.2,1.3,1.4,1.5};
            Character[] characters = {'A','B','C'};
            stringExample.printArray(integers);
            stringExample.printArray(doubles);
            stringExample.printArray(characters);
        }
    }
    
    
    @Data
    public class GenericClassExample<T> {
    
        //member这个成员变量的类型为T,T的类型由外部指定
        private T member;
        public GenericClassExample(T member) {
            this.member = member;
        }
    
        public T handleSomething(T target){
            return target;
        }
    
        public String sayHello(String name){
            return "Hello" + name;
        }
    
        public static <T> void printArray(T[] inputArray){
            for (T element : inputArray) {
                System.out.printf("%s", element);
                System.out.printf(" ");
            }
            System.out.println();
        }
    
    }
    
    

    范型字母的含义

    • E - Element:在集合中使用,因为集合中存放的是元素
    • T - Type:Java 类
    • K - Key:键
    • V - Value:值
    • N - Number:数值类型
    展开全文
  • Scala 范型

    2020-12-24 16:34:43
    范型的作用主要是对函数和类构造的输入参数进行类型限制 package com.abc // 范型 object TDemo { def main(args: Array[String]): Unit = { // 1、下限<: // fun(new A) // 报错 fun(new C) // 正常 // 2...
    • 范型的作用主要是对函数和类构造的输入参数进行类型限制
    package com.abc
    
    // 范型
    object TDemo {
      def main(args: Array[String]): Unit = {
        // 1、下限<:
    //    fun(new A) // 报错
        fun(new C) // 正常
        // 2、上限>:(所有类都可以)
        fun1(new A) // 正常
        fun1(new C) // 正常
        // 3、协变+
        val t:Test[C] = new Test[C](new C)
        var t0:Test[B] = t
        // 4、逆变-
        val t1:Test1[A] = new Test1[A](new A)
        val t11:Test1[B] = t1
      }
      // 限定函数参数类型下限(B以及子类)<:
      def fun[T <: B](arg : T): Unit ={
    
      }
      // 限定函数参数类型上限(任意类)>:
      def fun1[T >: B](arg : T): Unit ={
    
      }
      // 限定类构造函数输入类型包含其子类
      class Test[+T](arg: T){
    
      }
      // 限定类构造函数输入类型包含其父类
      class Test1[-T](arg: T){
    
      }
      class A{
    
      }
      class B extends A{
    
      }
      class C extends B{
    
      }
    }
    
    展开全文
  • JAVA范型

    2020-08-19 16:37:44
    不使用范型带来的危害:当我们将一个对象放入集合中,集合不会记住此对象的类型,当再次从集合中取出此对象时,改对象的编译类型变成了Object类型,但其运行时类型任然为其本身类型。取出集合元素时需要人为的强制...
  • CLR中的范型详解

    2021-03-05 00:54:49
    本页内容编译器如何处理范型?规则和限制whereT:IComparable范型接口和委托类库中的范型小结在本专栏某一期中,我初步讨论了公共语言运行库(CLR)中的范型。我引入了范型的概念,介绍了范型所带来的灵活性和代码重用...
  • 本文详细介绍Java的范型,写一篇关于范型的博客原因有两个,前几天要写个范型方法(返回值根据传入的类型而定),竟然想了半天,最后还是从网上找了个范型方法的写法;再者,前一段时间在看Gson, Gson这个JSON包的精华...
  • Java 范型

    2018-06-03 23:49:35
    简介范型(generic)可以参数化类型,这个能力使我们可以定义带范型类型的类或方法,随后编译器会用具体的类型来替换它。
  • 范型声明

    2018-09-02 15:36:52
    鉴于对范型声明的不明确,现作文以记之。 public class AdapterController&lt;T&gt; : AdapterRemoting.IRemoteController, ICommandHandler where T : IAlarmAdapter, new() 上面的非静态类中的T表示在...
  • java-范型

    2021-03-04 14:16:45
    范型分为:范型集合、范型类、范型方法 限制泛型可用类型 范型通配符 继承范型类和实现范型接口 泛型集合 public class Test14 { public static void main(String[] args) { // 创建3个Book对象 Book book1 = new...
  • 分布式计算范型

    2019-11-22 14:26:54
    2.1 消息传递范型 2.2 客户 / 服务器范型 2.3 P2P范型 2.4 消息系统范型 2.5 远程过程调用范型 2.6 分布式对象范型 2.6.1 远程方法调用 2.6.2 对象请求代理 2.7 网络服务范型 2.8 移动代理范型 2.9 云服务范型 ...
  • java范型

    2017-04-24 08:34:45
    范型的主要优点:能够在编译时而不是运行时检测出错误继而提高软件的可靠性和可读性。(JDK 1.5开始使用范型范型类型必须是引用类型,不能使用基本类型。 引用类型:是一个对象类型,值是什么呢?它的值是指向...
  • java 范型详解

    千次阅读 2017-04-29 14:05:46
    1.范型长啥样?ArrayList<String> list = new ArrayList ();这是我们最常见的了,然而对于很多java开发来说,只知道用java本身自带的一些范型类,而对于自己去创建范型类啥的,不太熟悉。 范型在java当中是一个比较...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,926
精华内容 1,970
关键字:

范型