定义和使用含有泛型的方法，定义和使用含有泛型的接口

定义和使用含有泛型的方法：

定义含有泛型的方法：泛型定义在方法的修饰符和返回值类型之间

格式：

修饰符  <泛型>  返回值类型  方法名(参数列表(使用泛型)){

方法体；

}

含有泛型的方法，在调用方法的时候确定泛型的数据类型

传递什么类型的参数，泛型就是什么类型

public class fangfa {

    //定义一个含有泛型的方法
    public <A> void meth(A a){
        System.out.println(a);
    }
    //定义一个含有泛型的静态方法
    public static  <W> void fanxin(W w){
        System.out.println(w);
    }

}

/**
 * 测试含有泛型的方法
 */
public class diaoyong {
    public static void main(String[] args) {
        //创建fangfa对象
        fangfa fan = new fangfa();
        /**
         * 调用含有泛型的方法meth
         * 传递什么类型，泛型就是什么类型
         */
        fan.meth(19);
        fan.meth("对你有好感");
        fan.meth(6.24);
        fan.meth(52.10);

        //静态方法，通过类名，方法名(参数)可以直接使用
        fangfa.fanxin("静态方法，不建议创建对象使用");
        fangfa.fanxin(1);
    }
}

 

 

 

定义和使用含有泛型的接口：

含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型

public interface iterator<E> {

E next( )；

}

Scanner类实现了Iterator接口，并指定接口的泛型为string，所以重写的next方法泛型默认就是string

public final class Scanner implements Iterator<string>{

public string next(){}

}

/**
 * 定义含有泛型的接口
 */
public interface jiekou <S> {
    public abstract void text(S b);
}

/**
 * 含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
 * public interface Iterator<E> {
 * E next( );
 * }
 * scanner类实现了Iterator接口,并指定接口的泛型为string,所以重写的next方法泛型默认就是string
 * public final class Scanner implements Iterator<string>{
 * public string next() {}
 * }
 */
public class fanjie implements jiekou<String>{

    @Override
    public void text(String b) {
        System.out.println(b);
    }
}

/**
 * 测试含有泛型的接口
 */
public class shixainlei {
    public static void main(String[] args) {
        //创建fanjie对象
        fanjie jie = new fanjie();
        jie.text("永世");
    }
}

 

含有泛型的接口第二种使用方式：接口使用什么泛型，实现类就使用什么泛型，类跟着接口走

就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型

public interface list<E>{

boolean add(E e)；

E get(int index)；

}

public class ArrayList<E> implements List<E>{

public boolean add(E e){}

public E get(int index){}

}

/**
 * 定义含有泛型的接口
 */
public interface jiekou <S> {
    public abstract void text(S b);
}

/**
 * 含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
 * 就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
 * public interface list<E>{
 *  boolean add(E e);
 *  E get(int index);
 *  }
 *  public class ArrayList<E> implements List<E>{
 *      public boolean add(E e){}
 *      public E get(int index){}
 *  }
 */
public class xingkou <S> implements jiekou<S>{

    @Override
    public void text(S b) {
        System.out.println(b);
    }
}

/**
 * 测试含有泛型的接口
 */
public class shixainlei {
    public static void main(String[] args) {
        //创建fanjie对象
        fanjie jie = new fanjie();
        jie.text("永世");

        //创建xingkou对象
        xingkou<Integer> kou = new xingkou<>();
        kou.text(19);

        xingkou<Double> xing = new xingkou<>();
        xing.text(5.21);
    }
}

 

 

 

 

 

 

 

 

搜索

复制

标签：定义,含有,接口,public,void,泛型,class
来源： https://www.cnblogs.com/hungui/p/16451682.html