public class Book { private int Id; // 图书编号 private String Name; // 图书名称 private int Price; // 图书价格 public Book(int id, String name, int price) { // 构造方法 this.Id = id; this.Name = name; this.Price = price; } public String toString() { // 重写 toString()方法 return this.Id + ", " + this.Name + "," + this.Price; } }2)使用 Book 作为类型创建 Map 和 List 两个泛型集合,然后向集合中添加图书元素,最后输出集合中的内容。具体代码如下:
public class Test14 { public static void main(String[] args) { // 创建3个Book对象 Book book1 = new Book(1, "唐诗三百首", 8); Book book2 = new Book(2, "小星星", 12); Book book3 = new Book(3, "成语大全", 22); Map<Integer, Book> books = new HashMap<Integer, Book>(); // 定义泛型 Map 集合 books.put(1001, book1); // 将第一个 Book 对象存储到 Map 中 books.put(1002, book2); // 将第二个 Book 对象存储到 Map 中 books.put(1003, book3); // 将第三个 Book 对象存储到 Map 中 System.out.println("泛型Map存储的图书信息如下:"); for (Integer id : books.keySet()) { // 遍历键 System.out.print(id + "——"); System.out.println(books.get(id)); // 不需要类型转换 } List<Book> bookList = new ArrayList<Book>(); // 定义泛型的 List 集合 bookList.add(book1); bookList.add(book2); bookList.add(book3); System.out.println("泛型List存储的图书信息如下:"); for (int i = 0; i < bookList.size(); i++) { System.out.println(bookList.get(i)); // 这里不需要类型转换 } } }在该示例中,第 7 行代码创建了一个键类型为 Integer、值类型为 Book 的泛型集合,即指明了该 Map 集合中存放的键必须是 Integer 类型、值必须为 Book 类型,否则编译出错。在获取 Map 集合中的元素时,不需要将
books.get(id);
获取的值强制转换为 Book 类型,程序会隐式转换。在创建 List 集合时,同样使用了泛型,因此在获取集合中的元素时也不需要将bookList.get(i)
代码强制转换为 Book 类型,程序会隐式转换。泛型Map存储的图书信息如下: 1001——1, 唐诗三百首,8 1003——3, 成语大全,22 1002——2, 小星星,12 泛型List存储的图书信息如下: 1, 唐诗三百首,8 2, 小星星,12 3, 成语大全,22
public class class_name<data_type1,data_type2,…>{}其中,class_name 表示类的名称,data_ type1 等表示类型参数。Java 泛型支持声明一个以上的类型参数,只需要将类型用逗号隔开即可。
private data_type1 property_name1; private data_type2 property_name2;该语句中的 data_type1 与类声明中的 data_type1 表示的是同一种数据类型。
public class Stu<N, A, S> { private N name; // 姓名 private A age; // 年龄 private S sex; // 性别 // 创建类的构造函数 public Stu(N name, A age, S sex) { this.name = name; this.age = age; this.sex = sex; } // 下面是上面3个属性的setter/getter方法 public N getName() { return name; } public void setName(N name) { this.name = name; } public A getAge() { return age; } public void setAge(A age) { this.age = age; } public S getSex() { return sex; } public void setSex(S sex) { this.sex = sex; } }接着创建测试类。在测试类中调用 Stu 类的构造方法实例化 Stu 对象,并给该类中的 3 个属性赋予初始值,最终需要输出学生信息。测试类的代码实现如下:
public class Test14 { public static void main(String[] args) { Stu<String, Integer, Character> stu = new Stu<String, Integer, Character>("张晓玲", 28, '女'); String name = stu.getName(); Integer age = stu.getAge(); Character sex = stu.getSex(); System.out.println("学生信息如下:"); System.out.println("学生姓名:" + name + ",年龄:" + age + ",性别:" + sex); } }该程序的运行结果如下:
学生信息如下: 学生姓名:张晓玲,年龄:28,性别:女
[访问权限修饰符] [static] [final] <类型参数列表> 返回值类型 方法名([形式参数列表])例如:
public static <T> List find(Class<T> cs,int userId){}
public class Test16 { public static <T> void List(T book) { // 定义泛型方法 if (book != null) { System.out.println(book); } } public static void main(String[] args) { Book stu = new Book(1, "细学 Java 编程", 28); List(stu); // 调用泛型方法 } }该程序中的 Book 类为前面示例中使用到的 Book 类。在该程序中定义了一个名称为 List 的方法,该方法的返回值类型为 void,类型参数使用“T”来代替。在调用该泛型方法时,将一个 Book 对象作为参数传递到该方法中,相当于指明了该泛型方法的参数类型为 Book。
1, 细学 Java 编程,28
class 类名称<T extends anyClass>
// 限制ListClass的泛型类型必须实现List接口 public class ListClass<T extends List> { public static void main(String[] args) { // 实例化使用ArrayList的泛型类ListClass,正确 ListClass<ArrayList> lc1 = new ListClass<ArrayList>(); // 实例化使用LinkedList的泛型类LlstClass,正确 ListClass<LinkedList> lc2 = new ListClass<LinkedList>(); // 实例化使用HashMap的泛型类ListClass,错误,因为HasMap没有实现List接口 // ListClass<HashMap> lc3=new ListClass<HashMap>(); } }在上述代码中,定义 ListClass 类时设置泛型类型必须实现 List 接口。例如,ArrayList 和 LinkedList 都实现了 List 接口,所以可以实例化 ListClass 类。而 HashMap 没有实现 List 接口,所以在实例化 ListClass 类时会报错。
图1 两个等价的泛型类
泛型类名称<? extends List>a = null;其中,“<? extends List>”作为一个整体表示类型未知,当需要使用泛型对象时,可以单独实例化。
A<? extends List>a = null; a = new A<ArrayList> (); // 正确 b = new A<LinkedList> (); // 正确 c = new A<HashMap> (); // 错误在上述代码中,同样由于 HashMap 类没有实现 List 接口,所以在编译时会报错。
public class FatherClass<T1>{} public class SonClass<T1,T2,T3> extents FatherClass<T1>{}
interface interface1<T1>{} interface SubClass<T1,T2,T3> implements Interface1<T2>{}
本文链接:http://task.lmcjl.com/news/10899.html