精华内容
下载资源
问答
  • 泛型类的使用方法
    千次阅读
    2022-04-24 14:12:17

    Java系列之:泛型类、泛型方法、泛型接口

    一、泛型

    • 泛型:本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。将类型由原来的具体的类型参数化,然后在使用/调用时传入具体的类型。这种参数可以用在类、方法和接口中,分别被称为泛型类、泛型方法、泛型接口。

    泛型定义格式:

    • <类型>:指定一种类型的格式。这里的类型可以看成是形参。
    • <类型1,类型2…>:指定多种类型的格式,多种类型用逗号隔开,这里的类型可以看成是形参。
    • 将来具体调用时候给定的类型可以看成是实参,并且实参的类型只能是引用数据类型。

    泛型的好处:

    • 把运行时期的问题提前到了编译期间
    • 避免了强制类型转换

    二、泛型类

    泛型类的定义格式:

    • 格式:修饰符 class 类名<类型>{}
    • 泛例:public class Generic<T> {}
    • T可以是任意标识
    public class Generic<T>{
        private T t;
    
        public T get(){
            return t;
        }
    
        public void set(T t){
            this.t = t;
        }
    }
    
    
    public class CollectionDemo {
    
        public static void main(String[] args) {
            Generic<String> stu = new Generic<String>();
            stu.set("鸣人");
            System.out.println(stu.get());
    
            Generic<Integer> stu1 = new Generic<Integer>();
            stu1.set(10);
            System.out.println(stu1.get());
        }
    }
    
    

    三、泛型方法

    泛型方法的定义格式:

    • 格式:修饰符 <类型> 返回值类型方法名(类型变量名){}
    • 范例:public <T> void show(T t){}
        public <T> T show(T t){
            return t;
        }
    
        public <T> void show1(T t){
            System.out.println(t);
        }
    

    四、泛型接口

    泛型接口的定义格式:

    • 格式:修饰符 interface 接口名<类型>{}
    • 范例:public interface Generic <T>{}
    
    public interface GenInterface<T> {
        void show(T t);
    }
    
    public class GenImpl<T> implements GenInterface<T>{
        @Override
        public void show(T t) {
            System.out.println(t);
        }
    }
    
    public class CollectionDemo{
    
        public static void main(String[] args) {
            GenImpl<String> str = new GenImpl<String>();
            str.show("加油");
    
            GenImpl<Integer> i = new GenImpl<>();
            i.show(30);
        }
    }
    

    五、类型通配符

    为了表示各种泛型List的父类,可以使用类型通配符:

    • 类型通配符:<?>
    • List<?>:表示元素类型未知的List,它的元素可以匹配任何的类型
    • 这种带通配符的List仅表示它是各种泛型List的父类,并不能把元素添加到其中

    如果不希望List<?>是任何泛型的父类,只希望代表某一类泛型List的父类,可以使用类型通配符的上限。

    • 类型通配符上限:<?extends类型>
    • List<? extends Number>:表示的类型是Number或者其子类型

    除了可以指定类型通配符的上限,也可以指定类型通配符的下限:

    • 类型通配符下限:<?super类型>
    • List<?super Number>:表示的类型是Number或者其父类型
    import java.util.ArrayList;
    import java.util.List;
    
    public class CollectionDemo{
    
        public static void main(String[] args) {
            List<?> numbersList = new ArrayList<Number>();
    
            //类型通配符上限
            List<? extends Number> list1 = new ArrayList<Number>();
            List<? extends Number> list2 = new ArrayList<Integer>();
    
            //类型通配符下限
            List<? super Number> list3 = new ArrayList<Number>();
    
        }
    }
    
    更多相关内容
  • 泛型类、泛型方法、泛型接口、泛型委托 泛型类、泛型方法、泛型接口、泛型委托
  • 下面小编就为大家带来一篇浅谈java中定义泛型类和定义泛型方法的写法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 泛型 泛型简介 泛型可以理解为参数化类型,主要作用在类,方法和接口上。 Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是...泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ; 泛

    泛型

    泛型简介

    1. 泛型可以理解为参数化类型,主要作用在类,方法和接口上。
    2. Java泛型 与 C++ 模板 : Java 中的泛型 , 是仿照 C++ 中的模板开发的 , 目的是让开发者可以写出通用,灵活的代码 。
    3. 伪泛型 : Java中的泛型 , 是伪泛型 , Java 泛型开发好之后 , 在编译阶段就将泛型相关的信息消除了 , 不会泛型留到运行时。

    泛型类型 :

    • 泛型方法 : 方法有参数 , 方法的参数 可以指定成一些 泛型 ;
    • 泛型类 : 类 也可以有参数 , 将 类型 作为 参数 传入类中 ;
    • 泛型接口 : 接口 的 参数 , 也可以是泛型 ;

    将类型传入泛型方法 , 泛型类, 泛型接口中 , 可以动态地指定一些类型 ;
    泛型的作用 :

    • 安全检查 : 在编译阶段 , 就可以进行 代码检查, 将更少的错误带到运行时 ;
    • 避免强转 : 避免类型的强转导致不必要的安全问题 ;
    • 提高性能 : 使用泛型可以提高 Java 的性能 ;

    泛型类

    泛型类 : 在类名后面使用声明泛型 , 则在该类中, 可以使用该泛型类型 T 类型 ;特别注意 , 该类中的 如下2个方法不是泛型方法 ; 其中的参数 , 返回值类型是T , 但这个T是作为一个正常的类型使用的 , 并不是声明在方法 中的泛型 ;
    如果类,接口,方法是泛型类, 泛型接口,泛型方法, 则该类 , 接口 , 方法必须由 修饰 , 有个带尖括号的 T ;

        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    

    完整的泛型类

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 该方法不是泛型方法
         *  该方法是普通方法 , 返回值类型是 T 类型
         * @return
         */
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    }
    

    泛型方法

    泛型方法 : 在方法的返回值前, 使用 声明泛型的方法 , 是泛型方法 ; 将某个类型作为参数传入 ;
    泛型个数 : 该方法是泛型方法, 且指定了2个泛型 , 泛型的个数可以有很多个, 多个泛型之间 , 使用逗号隔开 ;
    泛型方法 与 泛型类 中的泛型 :
    泛型不同 : 泛型方法指定的泛型T与 类中的泛型T没有任何关系 , 这两个T 可以是不同的类型 ;
    泛型相同 : 泛型方法中定义的泛型T , 与参数类型的T , 返回值类型的T , 方法内部的T , 都是同一个类型 ;

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 泛型方法 , 是将某个类型作为参数传入
         *      方法指定泛型 , 写法如下
         *
         * 该方法是泛型方法
         *      方法指定了 2 个泛型
         *      泛型个数 , 泛型的个数可以有很多个
         *      多个泛型之间 , 使用逗号隔开
         *
         * 为方法指定的泛型 T 与类中的泛型 T 没有任何关系
         *      这两个 T 可以是不同的类型
         *
         * 泛型方法中定义的泛型 T
         *      与参数类型的 T
         *      返回值类型的 T
         *      方法内部的 T
         *      都是同一个类型
         *
         * 与泛型类中的 T 完全没有关系
         *
         * @param <T>
         * @param <A>
         * @return
         */
        public <T, A> T getData2(T arg){
            T data = arg;
            return data;
        }
    }
    

    静态方法的泛型

    静态方法泛型 : 如果静态方法中使用了类中的泛型T, 作为参数或返回值 , 这种使用时错误的 ;
    如果必须在静态方法中使用泛型T, 则该泛型T必须是静态方法的泛型 , 不能是类的泛型 ;
    错误用法:
    错误用法正确用法 :
    正确用法

    泛型类与泛型方法完整示例

    /**
     * 泛型类
     *  该 T 类型作为参数使用
     *  T 是参数化类型 , 可以由外部传入
     *
     * @param <T>
     */
    public class Student<T> {
    
        private String name;
        private int age;
        /**
         * 该数据的类型未知
         *  使用泛型表示 , 运行时确定该类型
         */
        private T data;
    
        public Student(String name, int age, T data) {
            this.name = name;
            this.age = age;
            this.data = data;
        }
    
        /**
         * 该方法不是泛型方法
         *  该方法是普通方法 , 返回值类型是 T 类型
         * @return
         */
        public T getData() {
            return data;
        }
    
        public void setData(T data) {
            this.data = data;
        }
    
        /**
         * 泛型方法 , 是将某个类型作为参数传入
         *      方法指定泛型 , 写法如下 ;
         *
         * 该方法是泛型方法
         *      方法指定了 2 个泛型
         *      泛型个数 , 泛型的个数可以有很多个
         *      多个泛型之间 , 使用逗号隔开
         *
         * 泛型方法指定的泛型 T 与类中的泛型 T 没有任何关系
         *      这两个 T 可以是不同的类型
         *
         * 泛型方法中定义的泛型 T
         *      与参数类型的 T
         *      返回值类型的 T
         *      方法内部的 T
         *      都是同一个类型
         *
         * 与泛型类中的 T 完全没有关系
         *
         * @param <T>
         * @param <A>
         * @return
         */
        public <T, A> T getData2(T arg){
            T data = arg;
            return data;
        }
    
        /**
         * 如果静态方法中使用类 类中的泛型
         *      这种使用时错误的
         *
         * 如果必须在 静态方法 中使用泛型 T
         *      则该泛型 T 必须是静态方法的泛型
         *      不能是类的泛型
         *
         * @param arg
         * @return
         */
        public static <T> T getData3(T arg){
            T data = arg;
            return data;
        }
    }
    
    展开全文
  • 主要介绍了Java泛型类与泛型方法的定义,结合实例形式详细分析了java泛型类与泛型方法定义、用法及相关操作注意事项,需要的朋友可以参考下
  • 泛型:泛型类与泛型方法

    千次阅读 2022-03-16 10:40:33
    1. public 和 返回类型中间的标识符,**可以理解为**,声明该...2. 只有声明了的方法是泛型方法,泛型类中的成员方法**不是**泛型方法 3. 表明,该方法使用泛型类型T,可以使用在**返回类型,传入参数列表,方法体**里

    泛型

    JDK1.5新特性

    优点:

    1. 类型安全:编译时检测类型
    2. 减少类型转换

    泛型类

    概念:在类声明体中用到了类型参数。

    语法:

    /*
    class 类型名<泛型标识,泛型标识, ...>{
        private 泛型标示 变量名;
    }
    */
    public class GenericDemo<T> {
        private T key;
    
        public GenericDemo(T key) {
            this.key = key;
        }
    
        public T getKey() {
            return key;
        }
    
        public void setKey(T key) {
            this.key = key;
        }
    
        public static void main(String[] args) {
            
            /*
            类名<具体的数据类型> 对象名 = new 类目<具体的数据类型>();
    
            JDK1.7后,可以省略成这样:
            类名<具体的数据类型> 对象名 = new 类目<>();
            */
            GenericDemo<Integer> integerGenericDemo = new GenericDemo<>(10);
            GenericDemo<String> stringGenericDemo = new GenericDemo<>("abc");
            //如果没有指定具体的数据类型,此时,操作类型是Object
            GenericDemo genericDemo = new GenericDemo("genericDemo");
    
            System.out.println(integerGenericDemo.key);
            System.out.println(stringGenericDemo.key);
            System.out.println(genericDemo.key);
            //泛型类型在逻辑上可以看成是多个不同的类型,但实际上是相同类型
          System.out.println(integerGenericDemo.getClass()==stringGenericDemo.getClass());	//输出结果为true
        }
    }
    
    
    

    注意:

    1. 泛型类只支持类类型不支持基本数据类型(如int),但可以用包装类(如Integer )

    泛型标识<>:类型形参

    由外部使用类的时候来指定

    泛型标识含义
    TType
    EElement
    KKey
    VValue

    泛型类的继承

    1. 子类也是泛型类,子类和父类的泛型标识要一致。子类也可以扩展泛型标识,但子类中至少有一个泛型标识与父类相同

    2. 子类不是泛型类,父类要明确泛型的数据类型

    //1.子类也是泛型类,子类和父类的泛型标识要一致
    
    class Child<T> extends Parent<T>{}
    
    //也可以扩展,但子类中至少有一个泛型标识与父类相同
    class Child<T,E> extends Parent<T>{}
    
    //2.子类不是泛型类,父类要明确泛型的数据类型
    
    class Child extends Parent<String>{}
    

    泛型接口

    1. 实现类不是泛型类时,接口要明确数据类型
    2. 实现类也是泛型类时,实现类和接口的泛型类型要一致

    泛型方法

    泛型方法比泛型类更加灵活

    泛型类和泛型方法的区别
    泛型类实例化类的时候指明泛型的具体类型
    泛型方法调用方法的时候指明泛型的具体类型

    语法

    修饰符 <T,E,...> 返回值类型 方法名(形参列表){
        方法体... 
    }
    
    1. public 和 返回类型中间的标识符,可以理解为,声明该方法为泛型方法
    2. 只有声明了的方法是泛型方法,泛型类中的成员方法不是泛型方法
    3. 表明,该方法使用泛型类型T,可以使用在返回类型,传入参数列表,方法体

    泛型方法与可变参数

    public class GenericDemo<T> {
    
        public static <E> void print(E... e){
            for(int i = 0; i < e.length; i++){
                System.out.println(e[i]);
            }
        }
    
        public static void main(String[] args) {
            GenericDemo.print(1,2,3,4,5);
            GenericDemo.print("a","b","c");
        }
    }
    

    类型通配符: ?

    概念:用“?”代替具体类型,是类型实参,不是类型形参

    /*
    	类型通配符上限
    	语法:
    	类/接口 <? extends 实参类型>
    	作用:要求该泛型的类型只能是《该实参类型或其子类型》  
    */
    
    public static void showAnimal(ArrayList<? extends Cat> list){
        for(int i;i<list.size();i++){
            Cat cat = list.get(i);
            System.out.println(cat);
        }
    }
    public static void main(String[] args){
        ArrayList<Animal> animals = new ArrayList<>();
        ArrayList<Cat> cats = new ArrayList<>();
        ArrayList<MiniCat> miniCats = new ArrayList<>();
        
        //showAnimal(animals); 编译报错
        showAnimal(cats);
        showAnimal(miniCats);
    }
    
    /*
    	类型通配符下限
    	语法:
    	类/接口 <? super 实参类型>
    	作用:要求该泛型的类型只能是《该实参类型或其父类型》  
    */
    

    类型擦除

    概念:

    JDK1.5以前没有泛型,但泛型代码能很好地和之前版本的代码兼容,是因为,泛型信息只存在于代码编译阶段,

    在进入JVM之前,与泛型相关的信息会被擦除

    展开全文
  • 泛型类: using System; namespace ThreadDemo { class Program { static void Main(string[] args) { MyStack<int> myStack = new MyStack<int>(3); myStack.Push(1); myStack.Push(2);

    泛型类:

    using System;
    
    namespace ThreadDemo
    {
        class Program
        {
    
            static void Main(string[] args)
            {
                MyStack<int> myStack = new MyStack<int>(3);
                myStack.Push(1);
                myStack.Push(2);
                myStack.Push(3);
                myStack.Push(4);
    
                MyStack<string> myStack1 = new MyStack<string>(5);
                myStack1.Push("张三");
            }
        }
    
        public class MyStack<T>
        {
            private T[] _stack;//栈数组
            private int _stackPoint;//当前位置
            private int _size;//栈的容量
    
            /// <summary>
            /// 初始化
            /// </summary>
            public MyStack(int size)
            {
                _size = size;
                _stack = new T[size];
                _stackPoint = 0;
            }
    
            /// <summary>
            /// 入栈方法
            /// </summary>
            /// <param name="item"></param>
            public void Push(T item)
            {
                if (_stackPoint >= _size)
                {
                    Console.WriteLine("栈已满,无法继续入栈");
                }
                else
                {
                    _stack[_stackPoint] = item;
                    _stackPoint++;
                }
    
                foreach (var s in _stack)
                {
                    Console.WriteLine(s);
                }
                Console.WriteLine("---------------------------");
            }
    
        }
    
    }
    

    执行结果:

    上面实例模拟数据入栈的操作。使用泛型可以让不同类型的数据公用一个类处理。实现代码的复用。

     

     泛型方法:

    using System;
    
    namespace ThreadDemo
    {
        class Program
        {
            /// <summary>
            /// 两个参数交换值
            /// </summary>
            /// <typeparam name="T"></typeparam>
            /// <param name="left"></param>
            /// <param name="right"></param>
            static void Swip<T>(ref T left, ref T right)
            {
                T temp;
                temp = left;
                left = right;
                right = temp;
            }
    
            static void Main(string[] args)
            {
                int a = 1;
                int b = 2;
                Swip<int>(ref a, ref b);
    
                string s1 = "张三";
                string s2 = "李四";
                Swip<string>(ref s1, ref s2);
    
                Console.WriteLine("a={0},b={1}", a, b);
                Console.WriteLine("s1={0},s2={1}", s1, s2);
    
            }
        }
    
    
    
    }
    

    执行结果:

    可以看到a,b  s1,s2 的值都进行了交换。

    这里的泛型方法就起到了可以为不同类型的数据进行数值交换,而不需要对各种类型单独定义方法。

    这里用到了ref关键字,可以参考https://blog.csdn.net/m0_37679113/article/details/83045813

     

     

    展开全文
  • 如果被方法是用,那么泛型类的对象明确要操作的具体类型后,所有要操作的类型就已经固定了。为了让不同的方法可以操作不同类型,而且类型还不确定。那么可以将泛型定义在方法上。泛型类class Demo{public void show...
  • 方法中出现了泛型的结构,泛型参数与类的泛型参数没有任何关系,换句话说,泛型方法所属的类是不是泛型类都没关系 泛型方法在调用时指明泛型参数的类型,并非在实例化类时确定, arr给E指挥的类型是integer,并且...
  • 1. 概述 泛型,即参数化类型。一提到参数,最熟悉的就是定义方法是...也就是说在泛型使用过程中,操作的数据类型被指定为一个参数,这种参数类型可以用在类、接口和方法中,分别被称为泛型类、泛型接口、泛型方法。 2.
  • 1泛型的类型参数只能是类类型包括自定义类不能是简单类型 2同一种泛型可以对应多个版本因为参数类型是不确定的不同版本的泛型类实例是不兼容的 3泛型的类型参数可以有多个 4泛型的参数类型可以使用extends语句例如...
  • c#泛型类、泛型方法、泛型接口、泛型委托
  • 使用泛型类2. 子类继承泛型类4. 泛型方法 1. 泛型的提出 List中默认的类型是Object,当我们向List中传入数字和字符串的时候可以执行,但是当要输出的时候就让人头疼。这时候泛型就出来了,可以指定List中传入对象的...
  • 一、泛型类用法、 二、泛型方法用法、 三、泛型通配符 、 四、泛型安全检查、
  • 1、泛型类 package com.wyq.StringBuffer; public class MyGe<T> { //在这里的T只是占位符,并没有表示是什么类型 public void show(T t){//方法中的泛型T,在差一個年MyGe類的对象的时候就会决定T的类型...
  • 在 Java 1.5 之前没有泛型,通常需要使用强制类型转换的方式将一种数据类型转换为另一种数据类型,这种转换要求开发者对实际参数的类型具有可预知性。对于强制类型转换错误的情况,编译器可能不会提示错误,但是在...
  • 转自:...一、泛型类定义及使用 public class Point<T> { private T x; private T y; public T getX() { return x; } public void setX(T x) { this.x = x; } public T getY() {
  • 1、泛型是什么 首先告诉大家ArrayList就是泛型。那ArrayList能完成哪些想不到的功能呢?先看看下面这段代码: ArrayList<String> strList = new ArrayList<String>(); ArrayList<Integer> int...
  • 一、泛型简介、 二、泛型类、 三、泛型方法、 四、静态方法的泛型、 五、泛型类与泛型方法完整示例、
  • 【Flutter】Dart 泛型 ( 泛型类 | 泛型方法 | 特定类型约束的泛型 ) https://hanshuliang.blog.csdn.net/article/details/114059611 博客源码快照
  • 目录标题泛型引入1. 泛型类特点2. 最简单泛型类3. 泛型方法4. 泛型接口5. 泛型类可是同时设置多个类型参数6. 泛型的类型参数可以是泛型类7...这样就解决了多个相似的类(方法、接口 )创建的问题,一个泛型类即可代替所
  • JAVA容器之泛型类与泛型方法
  • 泛型的使用泛型类使用方法泛型类继承泛型接口使用方法泛型接口实现类泛型方法使用方法静态泛型方法所属类为泛型类/泛型接口 前言     我们在平时的开发当中基本上无时无刻都在使用泛型,尤其是涉及到集合、...
  • 在定义的时候并不会设置的属性和方法的参数的具体类型,而是在实际用的时候再定义。它存在的意义是帮我们在编译期间检查我们的类型是否正确。 //定义一个Point class Point{ private Object x; private ...
  • Java泛型、泛型类、泛型方法详解

    千次阅读 2020-05-22 16:52:10
    这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。 Java泛型被引入的好处是安全简单。在Java SE 1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,...
  • 原文链接:https://blog.csdn.net/qq_27093465/article/details/73229016
  • 泛型允许我们使用类型参数Type parameter,它用一个自定义的标识符(T、V、E)来...在使用泛型类时(区别于定义泛型类时 泛型允许我们使用类型参数Type parameter,它用一个自定义的标识符(T、V、E)来代表一个类型,...
  • 顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。 泛型的本质是为了参数化
  • C#泛型类和泛型方法

    2019-10-21 20:16:46
    泛型可以理解为广泛的类型,或者不确定的...泛型类 泛型类是指这个类的某些字段的类型是不确定的,只有在构造的时候才能确定下的类。 泛型类示例 class Program { static void Main(string[] args) { MyClass&l...
  • 顾名思义,就是将类型由原来的具体的类型参数化,类似于方法中的变量参数,此时类型也定义成参数形式(可以称之为类型形参),然后在使用/调用时传入具体的类型(类型实参)。为什么要是用泛型呢??泛型一半是用在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 278,814
精华内容 111,525
关键字:

泛型类的使用方法