我在写一个java泛型接口实现时为啥报出double为意外的类型啊?源程序如下！

Posted 2023-04-21

public interface Operable<T>
.......

class Arr implements Operable<double>
.........

最后在cmd中编译时报出如下错误
Arr.java：2：错误：意外的类型
class Arr implements Operable<double>
需要：引用
找到：double
一个错误

参考技术A 你首先要搞清楚，泛型是什么。
泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。----double是简单类型。
为什么用泛型。
这个你看看书上的例子，说多了你的迷糊。
总之，泛型放的是类，比如你定义一个类叫User，又创建了一个List，放的都是User对象，那么
你就可以用泛型：List<User> list = new ArrayList<User>();
我觉得你完全没有理解概念，T代表什么书上应该说的很清楚吧？
如果是简单类型，直接写就好了，干嘛用泛型？用泛型无非是为了方便，编译时检查类型一致。
当然，不会用也可以不用，强转也可以。 参考技术B 泛型必须是封装类型，比如你支持double就必须 是封装类型Double。int就必须写Integer本回答被提问者采纳 参考技术C Operable里面只能存放T类型的数据，却在Arr中把泛型改成了double，前后不一致了吧 参考技术D 泛型定义只能使用类型，不能使用基本数据类型。但能使用基本类型作为参数，那是1.5以后的自动转型。 第5个回答  2011-10-18 double不是Object的子类。。。。。。
double不是class类型

JAVA泛型的使用（超详细）

目录

1、概念

2、优点

3、泛型使用实例

4、泛型使用细节

5、自定义泛型类

6、自定义泛型接口

7、自定义泛型方法

---

1、概念

        Java泛型是JDK1.5中引⼊的⼀个新特性，其本质是参数化类型，把类型作为参数传递。 常⻅形式有泛型类、泛型接⼝、泛型⽅法。

2、优点

        1）编译时，检查添加元素的类型，提高了安全性

        2）减少了类型转换次数，提高了效率

public class Test 
    public static void main(String[] args) 
        ArrayList<Dog> arrayList = new ArrayList<>();
        arrayList.add(new Dog("贝贝",5));
        arrayList.add(new Dog("乐乐",3));
        arrayList.add(new Dog("小黑",4));
        //arrayList.add(new Cat("贝贝",5));   错误
        for (Dog dog : arrayList) 
            System.out.println(dog.getName()+"-"+dog.getAge());
        
    

3、泛型使用实例

public class Test 
    public static void main(String[] args) 
        HashSet<Student> hashSet = new HashSet<>();
        hashSet.add(new Student("张三",22));
        hashSet.add(new Student("李四",23));
        hashSet.add(new Student("王五",24));
​
        //遍历
        for (Student student : hashSet) 
            System.out.println(student);
        
        //使用泛型方式给HashMap放入三个学生对象
        HashMap<String, Student> hashMap = new HashMap<>();
        hashMap.put("Tom",new Student("Tom",22));
        hashMap.put("Jack",new Student("Jack",23));
        hashMap.put("Smith",new Student("Smith",24));
​
        //迭代器 entrySet
        Set<Map.Entry<String, Student>> entrySet = hashMap.entrySet();
        Iterator<Map.Entry<String, Student>> iterator = entrySet.iterator();
        System.out.println("===========================");
        while (iterator.hasNext()) 
            Map.Entry<String, Student> next = iterator.next();
            System.out.println(next.getKey()+"-"+next.getValue());
        
    

4、泛型使用细节

        1）interface List<T>，public class HashSet<E>...等等

                T、E只能是引用类型

ArrayList<Integer> list1 = new ArrayList<>(); //正确
ArrayList<int> list2 = new ArrayList<int>();  //错误

        2）在给泛型指定具体类型后，可以传入该类型或者其子类类型

public class Demo03 
    public static void main(String[] args) 
        //因为E制定了A类型，构造器传入了new A
        //在给泛型指定具体类型后，可以传入该类型或者其子类类型
        Pig<A> pig = new Pig<A>(new A());
        Pig<A> pig1 = new Pig<A>(new B());
    

class A
class B extends A
​
class Pig<E>
    E e;
    public Pig(E e) 
        this.e = e;
    

        3）在实际开发中，我们往往简写

ArrayList<Integer> list = new ArrayList<Integer>();
//简写
ArrayList<Integer> list1 = new ArrayList<>();

5、自定义泛型类

        注意细节：

                1）普通成员可以使用泛型

public class AA<T,R> 
    T t;
    R r;

                2）使用泛型的数组，不能初始化

public class AA<T,R> 
    T t;
    R r;
    T[] ts;
    //T[] ts =new T[4];  不能初始化

                3）静态方法中不能使用类的泛型

//因为静态时和类相关，在类加载时，对象还没创建，所以静态属性和静态方法使用了泛型，JVM就无法完成初始化
//    static R r2;
//    public static void m(T t)

                4）泛型类的类型是在创建对象时确定的

                5）如果创建对象时没有指定类型，默认为Object

6、自定义泛型接口

        注意细节：

                1）接口中，静态成员也不能使用泛型

                2）泛型接口的类型，在继承接口或实现接口时确定

                3）没有指定类型，默认为Object

public interface IUsb<U,R> 
    int n=10;
    //U name;   不能这样使用，静态成员不能使用泛型
    //普通方法，可以使用接口泛型
    U get(U u);
    void hi(R r);
    void run(R r1,R r2,U u1,U u2);
    //在JDK8中，可以在接口中，使用默认方法,也是可以使用泛型
    default R method(U u)
        return null;
    

public interface IA extends IUsb<String, Double> 

public class AA implements IA 
    //当我们去实现IA接口时，因为IA在继承IUsb接口时，制定了U为String,R为Double
   //在实现IUsb接口的方法时，使用String替换U，Double替换R
    @Override
    public String get(String s) 
        return null;
    
​
    @Override
    public void hi(Double aDouble) 
​
    
​
    @Override
    public void run(Double r1, Double r2, String u1, String u2) 
​
    

7、自定义泛型方法

        注意细节：

                1）泛型方法，可以定义在普通类中，也可以定义在泛型类中

class Car//普通类
    public void run()//普通方法
​
    
    public<T,R> void fly(T t,R r)//泛型方法
​
    

class fish<T,R>//泛型类
    public void run()
​
    
    public <U,M>void eat(U u, M m)
​
    

        2）当泛型方法被调用时，类型会确定

public class Test 
    public static void main(String[] args) 
        Car car = new Car();
        //当调用方法时，传入参数，编译器就会确定类型
        car.fly("宝马",100);
    

        3） public void swim(T t)不是泛型方法，而是使用了类声明的泛型。