欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java泛型demo

程序员文章站 2022-06-05 17:36:31
1.泛型类 普通的类 这样的代码是完全可以执行了,那为什么还需要泛型类? 1.安全性 上面的代码编译是完全可以通过的,但是执行的时候就会出现ClassCastException异常 2.可读性好,省去了反复的强制类型转换。 对于泛型类,java编译器会将泛型代码转换成普通的非泛型代码, 所以对于虚拟 ......

1.泛型类

public class dog<t> {
    private t age;

    public dog(t age) {
        this.age = age;
    }

    public t getage() {
        return age;
    }

    public static void main(string[] args) {
        //java7之后,尖括号中是不需要填写参数的
        dog<string> dog=new dog<>("28");
        system.out.println(dog.getage());
    }
}

普通的类

public class dog {
    private object age;

    public dog(object age) {
        this.age = age;
    }

    public object getage() {
        return age;
    }

    public static void main(string[] args) {
        dog dog=new dog("28");
        system.out.println(dog.getage());
    }
}

这样的代码是完全可以执行了,那为什么还需要泛型类?

1.安全性

public class dog {
    private object age;

    public dog(object age) {
        this.age = age;
    }

    public object getage() {
        return age;
    }

    public static void main(string[] args) {
        dog dog=new dog("28");
        integer age=(integer) dog.getage();
        system.out.println(age);
    }
}

上面的代码编译是完全可以通过的,但是执行的时候就会出现classcastexception异常
2.可读性好,省去了反复的强制类型转换。

 

对于泛型类,java编译器会将泛型代码转换成普通的非泛型代码,

所以对于虚拟机来说,是没有泛型类的概念的。
为什么这么设计呢?应为泛型是jdk6以后才有的,为了向下兼容。

泛型方法:

public class testmethod {
    public static <t> boolean ishas(t[] arr, t elemt){
        for(t t:arr){
            if(t.equals(elemt)){
                return true;
            }
        }
        return false;
    }
    public <s> boolean isstring(s s){
       if(s instanceof string){
           return true;
       }
       return false;
    }

    public static void main(string[] args) {
        integer[] arr={1,5,6,8};
        system.out.println(ishas(arr,8));
        testmethod testmethod=new testmethod();
        system.out.println(testmethod.isstring(5));
    }
}

一个方法是不是泛型和他的类是不是泛型没有任何关系。
泛型方法需要在方法的返回值前先声明,在从后面的代码中使用。

泛型接口:
参照comparable接口。

public class testcomparable implements mycomparable<testcomparable>{

    private integer n;

    public testcomparable(int n) {
        this.n = n;
    }

    @override
    public boolean isequals(testcomparable testcomparable) {
        return this.n.intvalue()==testcomparable.getn().intvalue()?true:false;
    }

    public integer getn() {
        return n;
    }

    public static void main(string[] args) {
        testcomparable testcomparable1=new testcomparable(2);
        testcomparable testcomparable2=new testcomparable(2);
        system.out.println(testcomparable1.isequals(testcomparable2));
    }
}
interface mycomparable<t> {
    boolean isequals(t t);
}

类型参数继承某个类

/**
 * 测试继承class
 */
public class testinheritclass<t extends  father>{
    private t t;

    public testinheritclass(t t) {
        this.t = t;
    }

    void output(){
        system.out.println(t.getname());
    }

    public static void main(string[] args) {
        child child=new child("李逵");
        testinheritclass<child> t=new testinheritclass<>(child);
        t.output();
    }
}
class father{
    private string name;

    public string getname() {
        return name;
    }

    public father(string name) {
        this.name = name;
    }
}
class child extends father{
    public child(string name) {
        super(name);
    }

}

测试继承接口

/**
 * 测试继承接口
 */
public class testinheritinterface<t extends ifruits> {
    private t t;

    public testinheritinterface(t t) {
        this.t = t;
    }
    void output(){
        t.shape();
    }

    public static void main(string[] args) {
        apple apple=new apple();
        testinheritinterface<apple> t=new testinheritinterface<>(apple);
        t.output();
    }
}
interface ifruits{
    //形状
    void shape();
}
class apple implements ifruits{
    @override
    public void shape() {
        system.out.println("苹果是圆形的。");
    }
}