**泛型类。**

/**
泛型类。

什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。

泛型类定义的泛型，在整个类中有效。如果被方法使用，
那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定。
那么可以将泛型定义在方法上。

/*
特殊之处：
静态方法不可以访问类上定义的泛型。//不是说不可以相同类型的泛型，
//主要是静态方法时所有类所共享的，静态方法先加载，后面才有对象
如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上。

*/

package day;

import java.security.Principal;

import org.omg.PortableServer.POAPackage.AdapterAlreadyExists;

class Demo<E>//泛型类
{
public void show(E e) { 
System.out.println(e);
}
public void  daing (E e) {//两个方法
System.out.println(e);
}

public void  p(String string) { 
    System.out.println(string);
}

public <aa>  void dd(aa a)//泛型方法
{
System.out.println(a);  
}

public static <Eq>void staticDemo(Eq s)//静态泛型方法
{
    System.out.println(s);
}

}

public class 泛型1 {
public static void main(String[] args) {
    Demo<String > aDemo=new Demo<>();
    aDemo.daing("这是String");//String

    Demo<Integer> aDemo2=new Demo<Integer>();
    aDemo2.show(1);
    aDemo2.p("Integer");


    aDemo.staticDemo("zzzzzzzzzzzzzzz");
//  System.exit(0);
}

}

代码2

package day;
interface Inter<E>
{
    public void  name(E z);

}

class Inter2 implements Inter<String>
{
    public void  name(String s)
    {
        System.out.println(s);
    };  
}
/////////////////////////////////////////////////
class Inter3 <E> implements Inter<E>
{
    public void  name(E z)
    {

    }
}

public class 泛型2 {
    public static void main(String[] args) {
     new Inter2().name("sd");
     new Inter3<Integer>().name(123);
    }
}

代码3

package day;

import java.security.PublicKey;
import java.util.ArrayList;
import java.util.Iterator;

import org.omg.CORBA.PUBLIC_MEMBER;
class per
{
     String name;
    per(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}
class student extends per
{
    student(String name) {
        super(name);
    }
}


public class 泛型限定 {
    public static void main(String[] args) {
        // ArrayList<String > a=new ArrayList();
        // a.add("a1");
        // a.add("a2");
        // a.add("a3");
        //
        //  ArrayList<Integer> b=new ArrayList<>();
        //  b.add(11);
        //  b.add(22);
        //  b.add(33);
        //  printarr(b);

        ArrayList< per> aList=new ArrayList<per>();
        aList.add(new per("第1人"));
        aList.add(new per("第2人"));
        aList.add(new per("第3人"));
        aList.add(new per("第4人"));

        printper(aList);
    }
    //泛型限定
    /**
     ?通配符。也可以理解为占位符
     ？extends E：可以接收E类型或E的子类
     ？ super   E：可以接收E类型或E的子类
     *
     */
    public static void  printper(ArrayList<? extends per> arrayList) {
        Iterator<? extends per> iterator=arrayList.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next().getName());
        }

    }




//  public static void printarr(ArrayList<?> a)
//  {//一旦使用占位符?，就不能使用类型的特有方法
//      //多态具有扩展性，当是不可以使用子类的特有方法
//      Iterator< ?>  A=a.iterator();
//      while (A.hasNext()) {
//
//          System.out.println(A.next());
//      } 
//  }
//
//
//  public static <T>void  name(ArrayList<T> a) {
//      //注意泛型方法  要声明下
//      Iterator< T>  A=a.iterator();
//      while (A.hasNext()) {
//          T t=A.next();//占位符为不明确类型，不可如此
//          System.out.println(t.toString());
//      }
//  }





}