定义和使用含有泛型的方法(1)与定义和使用含有泛型的接口

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

GenericMethod

package Generic01_Demo01;
/*
定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间格式:
修饰符<泛型>返回值类型方法名(参数列表(使用泛型)){
方法体;
}
含有泛型的方法,在调用方法的时候确定泛型的数据类型传递什么类型的参数,泛型就是什么类型
 */
public class GenericMethod {
        //定义含泛型的方法
        public <M> void methd01(M m){
            System.out.println(m);
        }
        //定义一含有泛型的静态方法
       public static <S> void method02(S s){
           System.out.println(s);
       }

}

 

Demo03_GenericMethod

package Generic01_Demo01;
/*
测试含有泛型的方法
 */
public class Demo03_GenericMethod {
    public static void main(String[] args) {
        //创造GenericMethod对象
        GenericMethod gm = new GenericMethod();

            /*
            调用含有泛型的方法method01传递什么类型,泛型就是什么类型
             */
        gm.methd01(10);
        gm.methd01("abc");
        gm.methd01(8.8);
        gm.methd01( true);


        gm.method02("静态方法，不建议创建对象使用");
        //静态方法，通过类名.方法名（参数）可以直接使用
        GenericMethod.method02("静态方法");
        GenericMethod.method02(1);



    }
}

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

首先定义一个接口

package Generic01_Demo01;

public interface GenericInterface<I> {
    public abstract void method(I i);
}

GenericInterfaceImpI类

package Generic01_Demo01;
/*
含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
public interface Iterator<E> {
    E next( );
}
Scanner类实现了Iterator接口,并指定接口的泛型为string,所以重写的next方法泛型默认就是string
public final class Scanner implements Iterator<string>i
    public string next()
}
 */
public class GenericInterfaceImpI implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

Demo04GenericInterface

package Generic01_Demo01;
/*
        测试含有泛型的接口
 */
public class Demo04GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterfaceImpI对象
        GenericInterfaceImpI impI = new GenericInterfaceImpI();

        impI.method("字符串");

        //创建Demo04GenericInterface_pro对象
        Demo04GenericInterface_pro<Object> pro = new Demo04GenericInterface_pro<>();
        pro.method(10);

        Demo04GenericInterface_pro<Object> pro1 = new Demo04GenericInterface_pro<>();
        pro1.method(8.8);

    }
}

Demo04GenericInterface_pro

package Generic01_Demo01;
/*
含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
public interface list<E>i
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)0
 */
public class  Demo04GenericInterface_pro<I> implements GenericInterface<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}