{"id":481,"date":"2019-06-30T15:18:03","date_gmt":"2019-06-30T22:18:03","guid":{"rendered":"http:\/\/35.243.195.209\/?p=481"},"modified":"2020-04-11T22:46:49","modified_gmt":"2020-04-12T05:46:49","slug":"generics-in-java-compared-to-c-templates","status":"publish","type":"post","link":"https:\/\/nanzhou.cc\/index.php\/2019\/06\/30\/generics-in-java-compared-to-c-templates\/","title":{"rendered":"Generics in Java Compared to C++ Templates"},"content":{"rendered":"\n

Summary<\/h2>\n\n\n\n

In this post, I will introduce Generic<\/a> in Java. The post may be useful when you are working with Java with prior knowledge of C++.<\/p>\n\n\n\n

Context<\/h2>\n\n\n\n

The context is that I want to define an AbstractBaseClass<\/code> which is a top-level abstract class but different subclasses require different types of arguments for some member functions.<\/p>\n\n\n\n

With the knowledge of C++, we know that things can be done through class template and specialization (refer to my another post<\/a>)<\/p>\n\n\n\n

Conclusion<\/h2>\n\n\n\n

As usual, we provide the conclusion first.<\/p>\n\n\n\n

  1. Java is not truly Generic as C++ is. Java pretends to be generic leveraging Java compiler.<\/li>
  2. In Java, there is no concept of specialization, but we can use inherence to implement specialization.<\/li><\/ol>\n\n\n\n
    \/\/ Base.java\npublic class Base<T> {\n    public abstract void foo(T a);\n}<\/code><\/pre>\n\n\n\n
    \/\/ Derived.java\npublic class StringDerived extends Base<String> {\n    public abstract void foo(String a) {\n        System.out.println(a);\n    }\n}<\/code><\/pre>\n\n\n\n
    Details<\/h2>\n\n\n\n
    Let’s dive deeper to see what happens in Java’s Generics.<\/p>\n\n\n\n
    1. Type Erasure<\/h3>\n\n\n\n
    The Type Erasure is the main technique under Java’s Generics. The main characteristic of the technique is the elimination of the parameterization types during source-code translation to JVM bytecodes. See the codes below.<\/p>\n\n\n\n
    Vector<Integer> iv = new Vector<Integer>();\nVector<String>  sv = new Vector<String>();\n\n\/\/ correct\niv.add(new Integer(1));\nsv.add(new String(\"abc\"));\nInteger ival = iv.get(0);\nString  sval = sv.get(0);\n\n\/\/ illegal, could not compile\nsv.add(new Integer(1));\niv.add(new String(\"abc\"));<\/code><\/pre>\n\n\n\n
    It will be translated into the following codes by Java Generics compiler.<\/p>\n\n\n\n
    Vector iv = new Vector();\nVector sv = new Vector();\n\niv.add(new Integer(1));\nsv.add(new String(\"abc\"));\n\nInteger ival = (Integer) iv.get(0);\nString  sval = (String) sv.get(0);<\/code><\/pre>\n\n\n\n
    We found that all instantiations of the parameterized class Vector<><\/code> are replaced with its nongeneric alternative Vector<\/code>.<\/p>\n\n\n\n
    The good thing is the compiler helps programmers to do the type checks and casts. And the compiler finishes them better and safer. And all parameterized types share the same class or interface at runtime.<\/p>\n\n\n\n
    2. Is Instance<\/h3>\n\n\n\n
    Consider the following codes.<\/p>\n\n\n\n
    \/\/ C++\nbool test() {\n    vector<int>    intv;\n    vector<string> strv;\n    \/\/ return false\n    return typeid(intv) == typeid(strv);\n}<\/code><\/pre>\n\n\n\n
    boolean test() {\n\/\/ Java\n    Vector<Integer> intv;\n    Vector<String>  strv;\n    \/\/ return true\n    return intv.getClass()  == strv.getClass();\n}<\/code><\/pre>\n\n\n\n
    The C++ test correctly returns false and the Java test yields true. It shows that parameterization in Java is literally “skin-deep” (or rather, compiler-deep). In C++, we know that class templates are templates that generate different classes.<\/p>\n\n\n\n
    3. <T extends Base><\/h3>\n\n\n\n
    Java Generics has a convenient <T extends C> construct to restrict T parameterization only for Base-derived types. In C++, people have to implement it manually.<\/p>\n\n\n\n
    template<class T>\nvoid foo(T const & inst) {\n    C const* test = &inst;\n}<\/code><\/pre>\n\n\n\n
    4. Limitations<\/h3>\n\n\n\n
    There are some notable limitations in Java’s Generic.<\/p>\n\n\n\n
    1. Java Generics does not allow primitives (int, float, double, and so on) as parameterization types, though instead, people can use class Integer, Float, etc.<\/li>
    2. Java Generics does not allow specialization of a generic class.<\/li>
    3. Java Generics does not have run-time type information for parameterized types. Since those types do not exist beyond the source code, which makes things complicated. See the codes below.<\/li><\/ol>\n\n\n\n
      \/\/ not valid in Java\nclass Allocator<T> {\n    public T allocate() { \n        return new T(); \n    }\n}\n\/\/ \/\/ not valid in Java\nclass Foo<T> {\n    public void foo(T inst) {\n        inst.do_something();\n    }\n}<\/code><\/pre>\n\n\n\n
      To achieve this, you have to use a Factory model for the Allocator example and impose unnecessary polymorphism in the Foo example (like implement a specialized subclass).<\/p>\n\n\n\n
      Reference<\/h2>\n\n\n\n
      This Post at Dr.Dobb’s<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
      Summary In this post, I will introduce Generic in Java. The post may be useful when you are working with Java with prior knowledge of C++. Context The context is that I want to define an AbstractBaseClass which is a top-level abstract class but different subclasses require different types of arguments for some member functions….<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6,33,59,5,25],"tags":[],"class_list":["post-481","post","type-post","status-publish","format-standard","hentry","category-c","category-java","category-ood","category-proglang","category-software-engineering"],"_links":{"self":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/481","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/comments?post=481"}],"version-history":[{"count":5,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/481\/revisions"}],"predecessor-version":[{"id":957,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/posts\/481\/revisions\/957"}],"wp:attachment":[{"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/media?parent=481"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/categories?post=481"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/nanzhou.cc\/index.php\/wp-json\/wp\/v2\/tags?post=481"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}