首页 > 代码库 > 黑马程序员——泛型

黑马程序员——泛型

2024-07-21 11:41:28   220人阅读

package com.yang.exspe01;
 
import java.util.Iterator;
import java.util.TreeSet;
 
import com.yang.ex.TreeSetDemo.Student;
 
/*/**
 * 泛型：1.5版本之后出现的新特性，用于解决安全问题，是一个安全机制。
 * 好处：
 * 1.将运行时期出现的问题，转移到了编译时期。
 *   方便程序员解决问题，让运行事情问题减少，安全
 *   
 * 2.避免了强制转换的麻烦。
 * 
 * 泛型的格式：通过<>来定义要操作的引用的数据类型
 * 在java提供对象时，通常在集合框架中很常见。
 * 只要见到<>就是要定义泛型
 * 其实<>就是用来接收类型
 * 当使用集合时，将集合中要储存的数据类型作为参数传到容器当中
 
 * */
public class Treeset {
 
public static void main(String[] args) {
// TODO Auto-generated method stub
TreeSet<String> treeset=new TreeSet<String>();
treeset.add("aaa");
treeset.add("sdf");
Iterator<String> iterator=treeset.iterator();
while (iterator.hasNext()) {
String string=iterator.next();
System.out.println(string);
 
}
}
}
class MyCompare implements Comparable
{
public int compare(String object1,String object2) {
int num=new Integer(object1.length()).compareTo(new Integer(object2.length()));
if (num==0) {
return object1.compareTo(object2);
return num;
}
 
}
}
package com.yang.exspe01;
 
//泛型类
/*当类中要操作引用数据类型不确定时候
 * 早期定义Object来完成扩展
 * 现在定义泛型来完成扩展。
 * */
public class Demo {
 
public static void main(String[] args) {
// TODO Auto-generated method stub
Utils<Worker> utils = new Utils<Worker>();
utils.setObject();
Worker worker = utils.getObejct();
}
 
}
 
class Worker {
}
 
class Student {
}
 
/*
 * class Tool { private Worker worker; public void setWoker(Worker worker) {
 * this.worker=worker; } public Worker getWorker() { return worker; } }
 */
// 泛型类
class Utils<qq> {
private qq q;
 
public void setObject() {
this.q = q;
}
 
public qq getObejct() {
return q;
}
}
 
 
package com.yang.exspe01;
//泛型类定义的泛型，在整个类中有效，如果被方法是用
//那么泛型类的对象明确遥操作的具体类型后，所有要操作的类型就已经固定了
//为了让不同的方法可以操作不同的类型，而且类型还不确定
//那么可以将泛型定义在方法上
//特殊之处，静态方法不可以访问类上定义的泛型
//如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上
//public static<T> void method(T t),放在修饰符的后面 返回值得前面
public class Demo2 {
 
public static void main(String[] args) {
// TODO Auto-generated method stub
yang<String> demo = new yang<String>();
      demo.show("hah1");
      demo.print("hehe");
      demo.show("new");
      yang<Integer> demo2 = new yang<Integer>();
      demo2.show(new Integer(4));
}
 
}
class yang<T>
{
public void show(T t) {
System.out.println(t);
}
public void print(T t)
{
System.out.println(t);
}
 
public static<T> void method(T t)
{
System.out.println(t);
}
}
package com.yang.exspe01;
//泛型定义在接口上
public class Demo3 {
 
public static void main(String[] args) {
// TODO Auto-generated method stub
InterImpl impl=new InterImpl();
impl.show("haha");
}
 
}
interface Inter<T>
{
void show(T t);
}
class InterImpl implements Inter<String>
{
public void show(String tString) {
System.out.println("show"+tString);
}
 
}
package com.yang.exspe01;
/*
 * ?通配符，也可以理解为占位符
 * 泛型的限定：
 * ？ extends E：可以接收E类型或者E类型的子类型。上限
 * ？ super E：可以接收E类型或者E的父类型，下限
 * 泛型限定 是用来泛型扩展用的
 * 
 * */
import java.awt.print.Printable;
import java.security.AlgorithmConstraints;
import java.util.ArrayList;
import java.util.Iterator;
 
public class Demo4 {
 
public static void main(String[] args) {
// TODO Auto-generated method stub
ArrayList<String> arrayList=new ArrayList<String>();
arrayList.add("adf");
arrayList.add("bdf");
arrayList.add("ertt");
 
 
ArrayList<Integer> arrayList2=new ArrayList<Integer>();
arrayList2.add(4);
arrayList2.add(7);
arrayList2.add(3);
printColl(arrayList);
printColl(arrayList2);
}
public static void printColl(ArrayList<?> arrayList){
Iterator<?>iterator=arrayList.iterator();
while (iterator.hasNext()) {
System.out.println(iterator.next());
 
}
}
}
 
 
 
 

详情请查看：http://edu.csdn.net/heima

黑马程序员——泛型


联系
我们