精华内容
下载资源
问答
  • java 泛型类

    2014-08-26 00:14:48
    java 泛型类

    今天讲讲泛型类的使用,首先讲讲不使用泛型类的方法


    Person.java

    public class Person {
    private int age;
    private String name;
    public int getAge() {
    return age;
    }
    public void setAge(int age) {
    this.age = age;
    }
    public String getName() {
    return name;
    }
    public void setName(String name) {
    this.name = name;
    }
    }


    写一个工具类 对Person进行操作

    public class Tool {
    private Person person;


    public Person getPerson() {
    return person;
    }


    public void setPerson(Person person) {
    this.person = person;
    }

    Tool.java只能操作Person这个类,而不能操作其他类,这样肯定不利于扩展,如果Tool想操作其他的类,就没办法了,所以这样肯定不是解决问题最好的办法,因此得想办法让Tool也能操作其他类,

    现在Tool.java使用了泛型类来操作不可预知的对象,

    public class Tool<T> {
    private T t;

    public T getT() {
    return t;
    }


    public void setT(T t) {
    this.t = t;
    }
    }

    T就代表要操作的类,这是我们自定义的,其实jdk中

    ArrayList<String> al = new ArrayList<>();这样的

    只不过这不是我们自己自定义的类,而是jdk提供给我们使用的,原理是一样的



    ToolMain.java 

    public class ToolMain {
    public static void main(String[] args) {
    Tool<String> tool = new Tool<String>();
    tool.setT("helloworld");
    System.out.println(tool.getT());
    }
    }

    在jdk1.5中后,使用泛型莱尼接受类中要操作的引用数据类型

    泛型类:当类中操作的引用数据类型不确定的时候就使用泛型来表示






    ToolMain.java 
    展开全文
  • Java 泛型类

    2019-03-10 18:12:26
    一、泛型类的由来 当类中要操作的引用数据类型不确定的时候, 早期定义Object来完成扩展 现在定义泛型来完成扩展 二、并不存在泛型类 1、如何验证不存在泛型类 2、使用注意事项 三、泛型继承 1、以泛型类为...
    文章目录
         一、泛型类的由来
          当类中要操作的引用数据类型不确定的时候,
          早期定义Object来完成扩展
          现在定义泛型来完成扩展
         二、并不存在泛型类
         1、如何验证不存在泛型类
         2、使用注意事项
         三、泛型继承
         1、以泛型类为父类
         2、以非泛型类为父类
         3、泛型类与非泛型类在继承时主要区别
    

    一、泛型类的由来
    当类中要操作的引用数据类型不确定的时候,
    早期定义Object来完成扩展,
    现在定义泛型来完成扩展。

    (1)先看早期的做法,看个例子

    public class GeremicClass
     {
    	public static void main(String[] args) {
    		Tools u = new Tools();
    		//u.setObject(new Teacher());  类型转化异常
    		u.setObject(new Worker());
    	    Worker w = (Worker)u.getObject();
    	}
    }
    
    class Teacher
    {	
    }
    
    class Worker
    {	
    }
    
    class Tools
    {
    	private Object obj;
        public void setObject(Object obj){
        	this.obj = obj;
        }
        public Object getObject(){
        	return obj;
        }
    }
    

    (2) 定义泛型后的做法

    public class GeremicClass {
    
    	public static void main(String[] args) {
    		Tools<Worker> u = new Tools<Worker>();
    		//u.setObject(new Teacher());  类型转化异常
    		u.setObject(new Worker());
    	    Worker w = u.getObject();
    	}
    
    }
    class Tools<T>
    {
    	private T obj;
        public void setObject(T obj){
        	this.obj = obj;
        }
        public T getObject(){
        	return obj;
        }
    }
    

    分析 : 不需要进行类型强转。在调用setObject方法时,如果我传入的参数类型非Worker类型,编译直接报错。而早期通过定义Object来完成扩展,需要强转,而且如果传参类型出错,只能到运行时体现。不利于定位问题。我们称Tools为自定义的泛型类。

    二、并不存在泛型类
    这个标题不是与上面的相违背。不急。先看一个简单的例子。

    	public static void main(String[] args) 
    	{
    		ArrayList<Teacher> l1 = new ArrayList<Teacher>();
    		ArrayList<Worker> l2 = new ArrayList<Worker>();
    		System.out.println(l1.getClass()==l2.getClass());
    	}
    

    你觉得上述代码是输出ture还是false呢?答案是true。

    1、如何验证不存在泛型类

    不管泛型类型的实际参数是什么,他们在运行的时候总会有相同的class,即系统并没有生成新的class文件。 实际上,泛型对其所有可能的类型参数,都具有同样的行为,从而可以把相同的类当成许多不同的类来处理。

    2、使用注意事项

    <1> 因为不存在泛型类,所以经过instanceof运算符处理后不能使用泛型类。
    //下面的代码编译时会引发错误

    	if(l1 instanceof ArrayList<Teacher>)
    	{		
    	}
    

    <2> Java类中的静态方法、静态初始化、静态变量声明、初始化中不允许使用泛型参数。

    三、泛型继承
    和普通类一样,泛型类一样支持继承。任何一个泛型类都可以作为父类或者子类。

    1、以泛型类为父类
    当一个类的父类是泛型时,这个子类必须要把类型参数传递给父类,所以这个子类必定是泛型类。

    // main方法
    	public static void main(String[] args) 
    	{
    		SubTools<String> t1 = new SubTools<String>("hello java");
    	    System.out.println(t1.getObject());
    		
    	}
    
    //定义一个泛型类
    class Tools<T>
    {
    	private T obj;
    	public Tools()
    	{	
    	}
    	//当程序员提供有参构造方法,系统将不会提供无参构造方法
        public Tools(T obj){
        	this.obj = obj;
        }
        public void setObject(T obj){
        	this.obj = obj;
        }
        public T getObject(){
        	return obj;
        }
    }
    
    //泛型类的子类(注意SubTools是如何声明称为Tools的子类的。格式。)
    class SubTools<T> extends Tools<T>
    {
    	public SubTools(T obj){
    		 super(obj);  //调用的是父类有参构造方法。
    		//super();  调用父类无参构造方法
    	}
    }
    

    当然,除此之外,子类还可以扩展自己的类型参数。看下面一个例子

    //泛型类的子类(注意SubTools是如何声明称为Tools的子类的。格式。)
    class SubTools<T,U> extends Tools<T>
    {   
    	public U extentsion;
    	public SubTools(T obj,U ex){
    		 super(obj);  //调用的是父类有参构造方法。
    		//super();  调用父类无参构造方法
    		 extentsion = ex;
    		 
    	}
    	public U getExtension(){
    		return extentsion;
    	}
    }
    //main方法如下
    public static void main(String[] args) {
    
    	SubTools<String,Integer> t1 = new SubTools<String,Integer>("value is:",100);
    	System.out.println(t1.getObject()+t1.getExtension());
       //输出: value is:100
    }
    
    

    2、以非泛型类为父类
    泛型类也可以使用非泛型类作为父类,此时不需要传递类型参数给父类,所有的类型参数都是为自己准别的。

    //定义一个泛型类,其父类不是泛型类
    class GemericClass<T> extends Teacher{
    	
    	private T obj;
    	public GemericClass(String name,T obj){
    		super(name);
    		this.obj = obj;
    	}
    	
    	public T getObj(){
    		return obj;
    		
    	}
    }
    // 非泛型父类
    class Teacher
    {	
       private String name;
       
       public Teacher(){
    	   
       }
       public Teacher(String name){
    	   this.name = name;
       }
       
       public String getName(){
    	   return name;
       }
    }
    
    //main方法
    public static void main(String[] args) {
      GemericClass<Integer> t1 = new GemericClass<Integer>("value is:",500);
      System.out.println(t1.getName()+t1.getObj());
      //输出: value is:500
    }
    

    3、泛型类与非泛型类在继承时主要区别
    泛型类的子类必须将泛型父类所需要的类型参数,沿着继承链向上传递。(类似于构造方法)

    展开全文
  • Java泛型类

    千次阅读 2019-04-09 19:49:42
    声明一个泛型类 class People<E> People是泛型类的名称 E为泛型,他可以是任意的对象或接口,但不能是基本类型 使用泛型类声明一个对象 Cone<Circle> coneOne = new<Circle>(new Circle);/*...

    声明一个泛型类

    class People<E>

    People是泛型类的名称

    E为泛型,他可以是任意的对象或接口,但不能是基本类型

    使用泛型类声明一个对象

    Cone<Circle> coneOne = new<Circle>(new Circle);/*泛型类声明对象时必须要用具体的类代替泛型*/

    实例:求椎体的体积

    对于椎体的体积,我们并不关心他的地面具体是怎样的形状,关心的是用底面积和高计算出他的体积。

    因此,定义一个泛型锥体类,bottom类型为泛型。

    Cone.java
    /*使用泛型类声明椎体对象*/
    public class Cone<E> {
        double height;
        E bottom;
        public Cone(E b){/*泛型类E声明对象bottom*/
            bottom=b;
        }
        public void setHeight(double h){
            height = h;
        }
        public double computerVolume(){
            /*泛型变量只能调用从Object类继承的或重写的方法*/
            String s = bottom.toString();/*执行到这步时会调用具体类中重写的toString方法,泛型不能是基本类型,
            所以先强制转化为String类型在转化为double类型进行计算*/
            double area = Double.parseDouble(s);
            return 1.0/3.0*area*height;
        }
    }

     

    底面的形状

    Rect.java

    public class Rect {
        double sideA,sideB,area;
        Rect(double a,double b){
            this.sideA=a;
            this.sideB=b;
        }
        public String toString(){
            area = sideA*sideB;
            return area+"";
        }
    }
    Circle.java
    public class Circle {
        double area,radius;
        Circle(double radius){
            this.radius = radius;
        }
        /*bottom泛型类变量只能调用Object变量,所以Circle和Rectangle都重写了toString方法*/
        public String toString() {
            area = radius*radius*Math.PI;
            return area+"";
        }
    } 

    测试类

    Conepublic class ConeDemo {
        public static void main(String[] args) {
             Circle circle = new Circle(10);
             /*泛型类声明对象,一定要用具体的类替代<>中的泛型*/
             /*Cone泛型的名称  <>泛型*/
             Cone<Circle>coneOne = new Cone<Circle>(circle);
             coneOne.setHeight(16);
             System.out.println(coneOne.computerVolume());
             Rect rect = new Rect(10,10);
             Cone<Rect>coneTwo = new Cone<Rect>(rect);
             coneTwo.setHeight(10);
             System.out.println(coneTwo.computerVolume());
        }
    }
    

     

    展开全文
  • java泛型类

    2018-11-01 18:10:27
    一、泛型概念简述 泛型吗,就是泛泛的类型,指代某一种类型的符号。...1)在定义泛型类或声明泛型类的变量时,使用尖括号来指定形式类型参数。例如java.util.Map接口的定义: public interface Map&amp;lt;K, ...

    一、泛型概念简述
    泛型吗,就是泛泛的类型,指代某一种类型的符号。
    这样有啥好处呢?1.消除强制类型转换;2.附加类型检查,避免错误类型;3.确保Java类型安全(这才是主要目的)等。相信用过集合框架的都有类似体会。

    二、泛型基础特征
    1)在定义泛型类或声明泛型类的变量时,使用尖括号来指定形式类型参数。例如java.util.Map接口的定义:
    public interface Map<K, V> {

                   public void put(K key, V value);
    
                   public V get(K key);
    
         }
    

    命名方式约定以大写的单个字母名称作为类型参数。
    2)泛型不是协变的,即无法向上转型。不同于Object obj = new String(“str”),以下方式是错误的:

              错误代码   即无法向上转型
              List<int> intsList = new ArrayList<int>();
              List<Object> objList = intsList; 
    

    如果第二行写成List objList = strList,可以通过编译但会出现警告(类型不安全)。那如何表示泛型为一个通用泛型,就是定义个尖括号内可以放任意类型的泛型呢?这是就要使用类型通配符了。
    3)类型通配符,’?’表示。可以声明一个List<?>,作为任何泛型List的父类型。即List<?> objList = strList,这样就没啥问题了。
    4)受限泛型,即给泛型定义上下限。简单说,就是类型参数必须是某类及其子类(上限),或者是某类及其父类(下限)。
    怎么弄捏,例如List为传入参数,限定类型参数必须为Number,如下:

     public void fun(List<? extends Number> list) {…}
    

    上述List只接收Number及Number的子类。另一种方式,只接收Integer及其父类,则如下:

       public void fun(List<? super Integer> list) {…}
    

    1.增强for循环
    LinkedList类:

            LinkedList<String> linkedList = new LinkedList();
            linkedList.add("汉语");
            linkedList.add("英语");
            for(Iterator<String> iterator = linkedList.iterator();iterator.hasNext();){
                System.out.println(iterator.next());
            }
    

    ArrayList类:

            ArrayList<String> strings = new ArrayList<>();
            strings.add("汉语");
            strings.add("英语");
            for(Iterator<String> iterator = strings.iterator();iterator.hasNext();){
                String s = iterator.next();
                System.out.println(s);
            }
    

    Vector类:
    特有的迭代器方法:.elements();

            Vector<String> strings = new Vector<>();
            strings.add("汉语");
            strings.add("英语");
            for(Enumeration<String> elements = strings.elements();elements.hasMoreElements();) {
                String s = elements.nextElement();
                System.out.println(s);
            }
    
    展开全文
  • 主要介绍了Java泛型类与泛型方法的定义,结合实例形式详细分析了java泛型类与泛型方法定义、用法及相关操作注意事项,需要的朋友可以参考下
  • JAVA泛型类

    2016-08-29 19:29:03
    public interface BaseDao { //... } .jdk1.5的新特性---泛型。这是定义在接口上的泛型,继承了Serializable(序列化),也就省去了强制...这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口
  • java泛型类指定多个泛型 从作为Java程序员的早期开始,我们都知道如何实例化和使用Collection对象。 实例化为具体类的List接口将如下所示。 List myArrayList = new ArrayList(); 如果myArrayList应该仅保存...
  • java泛型类和函数

    2017-03-17 15:46:12
    java泛型类和函数
  • JAVA 泛型类

    2013-03-16 12:26:46
    泛型类 当类中需要操作的引用数据类型不明确时 早期(JDK 1.4版本以前) 定义Object 来完成扩展 现在定义泛型来完成扩展 */ //早期版本 class ToolPre { private Object obj; public void setObject...
  • Java泛型类泛型方法

    2015-07-10 22:40:25
    Java泛型类和泛型方法
  • 主要为大家详细介绍了java泛型类定义与使用的相关资料,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java 泛型类的类型识别示例 java 泛型类的类型识别示例 java 泛型类的类型识别示例
  • Java泛型类详细解读

    2018-05-23 09:24:57
    转载自:Java泛型类详细解读
  • JVM如何理解Java泛型类.doc JVM如何理解Java泛型类.doc
  • C++模板类与Java泛型类

    千次阅读 2018-02-07 21:19:19
    C++模板类与Java泛型类一、C++模板类使用示例1、模板类定义头文件base.htemplate&lt;class T&gt; class Base { public: Base() {}; ~Base() {}; T add(T x, T y); }; #include "base.cpp&...
  • java 泛型类、接口、方法、数组详解 转自:java 泛型详解-绝对是对泛型方法讲解最详细的,没有之一 对java的泛型特性的了解仅限于表面的浅浅一层,直到在学习设计模式时发现有不了解的用法,才想起详细的记录一下。 ...
  • Java泛型类特性

    2019-10-01 05:22:42
    在2004年末Java推出了Java5,其中提供了对泛型方法和的支持,也围绕着泛型推出了一下特性,本章将对Java泛型进行综合的概括 1.泛型特性构件pre-Java 5  1.使用Object表示泛型   public class test{ public ...
  • 我在学习集合的时候对泛型还不太了解,只是觉得用了泛型之后能向自己的集合里加入自己指定类型的对象,可以减少数据类型的转换。那么,脱离集合后,泛型到底该...下面泛型类的例子就非常简单明了了,泛型类一般只需...
  • * 泛型的由来:通过Object转型问题引入 * 早期的...泛型类的概述及使用* A:泛型类概述<T> * 把泛型定义在类上* B:定义格式 * public class 类名<泛型类型1,…>* C:注意事项 * 泛型类型必须是引用类...
  • Java泛型类求数组的最小,最大,平均值 定义一个泛型类,成员变量是Number类或其子类对象的数组,成员方法有:求数组元素最小值、最大值和平均值。另外在demo类中创建该泛型类对象,分别求Integer和Double型数组的...
  • JVM如何理解Java泛型类

    2010-07-26 21:12:00
    JVM如何理解Java泛型类
  • Java泛型类和泛型方法

    2015-05-26 17:08:00
    泛型类是应用在整个类上,但同时可以在类中包含参数化方法,而这个方法所在的类可以是泛型,也可以不是泛型,也就是说是否有泛型方法,与其所在的类是否是泛型类没有关系。 泛型方法是的该方法可以能够独立于类而...
  • Java泛型类继承实现

    万次阅读 2018-08-07 22:22:24
    项目中经常会碰到泛型继承实现,这里讲解一下Java是如何实现泛型继承的。 泛型父类声明 泛型父类声明如下: public class Father&lt;T, M&gt; { public void test(T t, M m) { // do something with ...
  • Java泛型类的定义

    千次阅读 2019-06-22 19:15:18
    泛型类定义的语法如下: [访问修饰符]class类名称 <T> 泛型类的主要作用在于类被实例化后,传入具体的类型参数,对类的成员属性的类型和成员方法的参数类型和返回值类型进行替换。 二代码 public class ...
  • 【Java】Java泛型类继承Comparable接口

    千次阅读 2020-06-04 11:01:15
    遇到一个泛型类中的新应用,记录一下,如果泛型类中的泛型需要进行比较可以通过让泛型继承Comparable接口的方式来实现,如下: public class SortedSymbolList<Key extends Comparable<Key>, Value> { ...
  • 自定义java 泛型类与泛型方法的实现总结 ============泛型方法  public static retType reduceO4(atiType obj, Func function) {  String lastVal="";  if (obj instanceof List) {  List o

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 18,774
精华内容 7,509
关键字:

java泛型类

java 订阅