11月第一次Java周记

就是简单看看了

public class meiju<T> {///泛型
	private T over;
	
	public static <E> void s(E i)
	{
	if(i instanceof int[])
	{
		System.out.println();
	}
	}
	
	public T getover()
	{
		return over;
	}
	public void setover(T over)
	{
		 this.over=over;
	}
	public static void main(String[] args)
	{
		
		fx a=new fx();
		fx.fx2("aaaa");
		s(new int[]{5,5});
	Test t=new Test();
	t.s();
	fanxing fx=new fanxing();
	over<Boolean> over1=new over<Boolean>();//<T>可以接收任何的数据变量
	
	
	over<Float> over2=new over<Float>();
	
	
	over<Float> l1=new over<Float>();
    l1.setover(11.1f);
	over<?> aa1=l1;
    System.out.println("l1 的值"+l1.getover());
	System.out.println("aa1的值为"+aa1.getover());
	
	
	over2.setover(12.3f);
	
	
	Boolean b=over1.getover();
	Float f=over2.getover();
	over1.setover(true);
	
	System.out.println(b);
	System.out.println(f);
	
	
	int[] aac= {1,6,5};
	fxsz<Integer> fxs=new fxsz<Integer>();
	Integer ac[]= {12,62,5};
	  fxs.set(ac);
	  
	  
	    for(Integer acc:ac)
	    {
	    	System.out.println("数组是+"+acc);// 遍历数组
	    }
	    
	    
	}
	
	
	interface Cont1
	{
		public static final int Cona=1;
		public static final int conb=2;
	}
	}
	




 class over<T>
{
	private T overa;
	public T getover()
	{
		return overa;
	}
	
	public void setover(T ov)
	{
	overa=ov;
}

}
 
///////////////向上转型实现
        class Test{
		private Object b;
		public Object getB() {
			return b;
		}
		public void setB(Object b)
		{
			this.b=b;
		}
		
		@SuppressWarnings("deprecation")
		public void s() {
			setB(new Boolean(true));
		setB(new Integer(6));
		System.out.println("向上转型"+getB());
		System.out.println(getB());
		setB(new Float(12.3));
		System.out.println();
		Float f=(Float) getB();
		System.out.println("向下转型"+f);
			
		}
	}
	//限制泛型可用类型
        
        
        
        
	
	
	
     class fanxing
        {
                           
           public static < E > void printArray( E[] inputArray )
           {
            
                 for ( E element : inputArray ){        
                    System.out.printf( "%s ", element );
                 }
                 System.out.println();
            }
         
            fanxing()
            {
                int[] a= {1,6};
                Integer[] b = { 1, 2, 3, 4, 5 };
                printArray(b);
               
    
                System.out.println( "整型数组元素为:" );
               
                Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
                Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
         
                System.out.println( "\n双精度型数组元素为:" );
                printArray( doubleArray ); 
         
                System.out.println( "\n字符型数组元素为:" );
                printArray( charArray ); 
            } 
        }
	
	
     class fx
     {
    	 fx(){
    		 
    	 }
    	 public static <A> void fx2(A a)
    	 {
    		 System.out.println("泛型为"+a);
    	 }
     }
	
     
 //泛型数组
     
     class fxsz<T>
     {
    	 private T[] array;
    	 
    	 
    	 public  void set(T[] array)
    	 {
    		this.array=array;
    	 }
    	 
    	 public T[] get()
    	 {
			return array;
    		 
    	 }
    fxsz()
    {

    	
     }
     }
     

泛型好像最简单的理解就是可以接收不同数据类型的一种东西了