java学习基础泛型和其他对象

于 2015-08-31 09:37:05 发布
阅读量329 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/rongbinjava/article/details/48129561
版权 
 

-------  android培训、java培训、期待与您交流！ ----------
 

                                                                                                                                      泛型
 

 1).基本使用：
   ArrayList<String> list = new ArrayList<String>();
   或者：
   ArrayList<String> list = new ArrayList<>();(常用格式)
   或者：
   ArrayList<String> list = new ArrayList();(会有黄色警告线)
  2).泛型类：
   class MyArrayList<T>{
    public void add(T t){
    }
   }
  3).泛型方法：
   class MyArrayList{
    //能保证接收什么类型的参数，就返回一个什么类型的值；
    public <T> T show(T  t){
     return t;
    }
   }
  4).泛型接口：
   interface IA<T>{ 
    public void show(T t);
   }
     子类实现：
   1).可以丢弃泛型：
    class A implements IA{
     public void show(Object obj){
     }
    }
   2).可以指定为某个具体类型：
    class A implements IA<String>{
     public void show(String s){
     }
    }
   3).可以继续使用泛型：
    class A<T> implements IA<T>{
     public void show(T t){
     }
 

}
 

通配符
 

1、当传入的类型不确定时，可以使用通配符？。也可以理解为占位符。使用通配符的好处是可以不用明确传入的类型，这样在使用泛型类或者泛型方法时，提高了扩张性。
 

Collection<?>  a可以与任意参数化的类型匹配，但到底匹配的是什么类型，只有以后才知道，所以：a=newArrayList<Integer>和a=new ArrayList<String>都可以，但a.add(new Date())或a.add(“abc”)都不行。
 

问题：
 

        定义一个方法，该方法用于打印出任意参数化类型的集合中的所有数据，该方法如何定义呢？
 

错误方式：
 

[java] view plaincopyprint?<SPAN style="FONT-SIZE: 14px">public static void printCollection(Collection<Object> cols) { 
         for(Object obj:cols) {  
             System.out.println(obj);  
         }  
         /* cols.add("string");//没错 
          cols = new HashSet<Date>();//会报告错误！*/  
 }  
 


 public static void printCollection(Collection<Object> cols) {
   for(Object obj:cols) {
    System.out.println(obj);
   }
    cols.add("string");//没错
    cols = new HashSet<Date>();//会报告错误！}
 正确方式：
 

[java] view plaincopyprint?<SPAN style="FONT-SIZE: 14px">public static void printCollection(Collection<?> cols) { 
         for(Object obj:cols) {  
             System.out.println(obj);  
         }  
         //cols.add("string");//错误，因为它不知自己未来匹配就一定是String   
         cols.size();//没错，此方法与类型参数没有关系   
         cols = new HashSet<Date>();  
     }  
 
 

public static void printCollection(Collection<?> cols) {
   for(Object obj:cols) {
    System.out.println(obj);
   }
   //cols.add("string");//错误，因为它不知自己未来匹配就一定是String
   cols.size();//没错，此方法与类型参数没有关系
   cols = new HashSet<Date>();
  }
 总结：
 

        使用?通配符可以引用其他各种参数化的类型，?通配符定义的变量主要用作引用，可以调用与参数化无关的方法，不能调用与参数化有关的方法。
 

2、泛型限定
 

        对于一个范围内的一类事物，可以通过泛型限定的方式定义，有两种方式：
 

        1）? extends E：可接收E类型或E类型的子类型；称之为上限。
 

        如：ArrayList<? extends Number>x = new ArrayList<Integer>();
 

        2）? super E：可接收E类型或E类型的父类型；称之为下限。
 

        如：ArrayList<? super Integer>x = new ArrayList<Number>();
 

示例：
 

[java] view plaincopyprint?<SPAN style="FONT-SIZE: 14px">import java.util.*; 
   
 //人  父类   
 class Person  
 {  
     private String name;  
     Person(String name)  
     {  
         this.name = name;  
     }  
     public String getName()  
     {  
         return name;  
     }  
 }  
 //学生  继承父类   
 class Student extends Person  
 {  
     Student(String name)  
     {  
         super(name);  
     }  
 }  
   
 class  Demo  
 {  
     public static void main(String[] args)   
     {  
         ArrayList<Person> al = new ArrayList<Person>();  
         al.add(new Person("abc1"));  
         al.add(new Person("abc2"));  
         al.add(new Person("abc3"));  
         printColl(al);//父类对象的元素集合可以调用   
   
         ArrayList<Student> al1 = new ArrayList<Student>();  
         al1.add(new Student("abc--1"));  
         al1.add(new Student("abc--2"));  
         al1.add(new Student("abc--3"));  
         printColl(al1);  //子类对象的元素集合也可以调用   
     }  
   
 //定义一个上限的泛型方法   
 public static void printColl(Collection<? extends Person> al)  
     {  
         Iterator<? extends Person> it = al.iterator();  
         while(it.hasNext())  
         {  
             System.out.println(it.next().getName());  
         }  
     }  
 }  
  
 

  System类
 

 一、概述
 

 1、System是描述系统一些信息的类，类中的属性和方法都是静态的。不能被实例化，没有提供构造函数。
 

 2、字段摘要
 

        out：标准输出流。默认是控制台。
 

         in：标准输入流。默认是键盘。
 

  
 

 二、方法
 

 1、获取系统的属性信息：
 

         PropertiesgetProperties();
 

 说明：
 

         1）此方法返回的双列集合，即键值对；因为Properties是Hahstable的子类，也就是Map集合的一个子类对象，那么通过Map方法取出该集合中的元素。
 

          2）该集合存储的都是字符串，没有泛型定义
 

 2、获取指定属性信息：
 

         String getProperty(Stringkey);
 

 3、在系统内定义特有信息：
 

         String setProperty(Stringkey,String value);
 

 4、如何在jvm启动时，加载一些属性信息：
 

        通过命令：java -D<name>=<value>可以设置特有的系统属性信息
 

 示例：   
 

 import java.util.*;
 class SystemDemo 
 {
 public static void main(String[] args) 
 {
 Properties p=System.getProperties();//获取当前的系统属性
 sop(p);
 
 
 String value=System.getProperty("os.name");//获取指定键指示的系统属性
 sop("os.name="+value);
 
 
 System.setProperty("wode","My_PC");//设置指定键指示的系统属性信息
 sop(p);
 
 String s= System.getProperty("woshi");//当系统中没有该键值，返回null
 sop(s);
 
 
 }
 
 
 public static void sop(Object obj)
 {
 System.out.println(obj);
 }
 }  
 
 

 
 

     Runtime类
 

 一、概述
 

         1、每个java应用程序都有一个Runtime类实例，使用应用程序能与其中运行的环境相连接，应用程序不能创建自己的Runtime类的实例，是由系统底层自己创建的。
 

         2、该类中并没有提供构造函数。说明不可以new对象。那么会直接想到该类中的方法都是静态的。查阅API文档发现，该类中还有非静态方法。说明该类肯定会提供了方法获取本来对象。而且该方法是静态的，并返回值类型是本来类型。
 

         3、由以上特点可以看出该类使用了单例设计模式完成。
 

  
 

 二、方法
 

 1、获取本类对象
 

         static RuntimegetRuntime();
 

 2、在单独的进程中执行指定字符串命令
 

         Processexec(String command);
 

 3、在Process中有一个杀掉子进程的方法，可将exec方法开启的进程结束
 

         void destroy();
 

 示例：
 class RuntimeDemo  

 { 

 
public static void main(String[] args)throws Exception 

 
{ 

 
Runtime r=Runtime.getRuntime();//获取本类对象 

 

 

 
Process p=r.exec("notepad.exe");//执行记事本程序 

 
r.exec("notepad.exe  RuntimeDemo.java");//用记事本打开指定文件 

 

 

 
Thread.sleep(3000);//让线程等待3秒 

 
p.destroy();//杀掉指定进程 

 
} 

 } 

 

 
 

     时间类
 

 一、Date类
 

 1、概述
 

         Date类表示特定的瞬间，精确到毫秒。
 

         java中的默认显示格式为：Mon Jun 10 22:35:21 CST2013
 

 2、自定义格式
 

         默认的格式不一定满足每个人的需求，那么就需要自定义格式化模式。因为Date类中的大部分方法已过时，所以只能找其子类来实现。子类DateFormat中有format方法可以实现，但是DateFormat是抽象类，不能实例化。但是其下有个SimpleDateFormat子类，可以定义时间模式。
 

 具体步骤：
 

         1）创建Date对象
 

         2）将时间模式封装到SimpleDateFormat对象中
 

         3）调用format方法让格式化模式指定Date对象
 

 代码如下：
 

 import java.util.*;
 import java.text.*;
 class DateDemo 
 {
 public static void main(String[] args) 
 {
 Date d=new Date();//创建Date对象
 //sop(d);
 
 
 将模式封装到SimpleDateformat对象中。
 SimpleDateFormat sdf=new SimpleDateFormat("yyyy年MM月dd日E HH:mm:ss");
 //调用format方法让模式格式化指定Date对象。
 String time=sdf.format(d);
 sop(time);
 }
 
 
 public static void sop(Object ojb)
 {
 System.out.println(ojb);
 }
 }
 
 

 
 

 二、Carendar类
 

 1、概述：
 

         1）Calendar是一个抽象类，它为特定瞬间与一组诸如YEAR、MONTH、DAY_OF_MONTH等日历字段之间的转换提供了一些方法。
 

         2）Calendar可以对年月日等时间进行获取。并提供了相应的子段值。可参阅API文档。
 

 2、方法：
 

 2.1、基本获取时间
 

         1）获取年份：Calendar.YEAR
 

         2）获取月份：Calendar.MONTH
 

         3）获取日期：Calendar.DAY_OF_MONTH
 

         4）获取星期：Calendar.DAY_OF_WEEK
 

         5）获取小时：Calendar.HOUR_OF_DAY
 

         6）获取分钟：Calendar.MINUTE
 

         7）获取秒数：Calendar.SECOND
 

 2.2、设置时间：
 

         1）根据日历的规则，为给定的日历字段添加或减去指定的时间量：
 

                 void add(int field,int amount);
 

         2）获取指定的日历字段对应的时间值：
 

                 int get(int field);
 

         3）将给定日历字段对应的时间值设置为给定值：
 

                 void set(int field,int value);
 

        设置日历字段 YEAR、MONTH和DAY_OF_MONTH的值：
 

                 void set(int year,int month,int date);
 

 示例：
 

 import java.util.*;
 class  CalendarDemo
 {
 public static void main(String[] args) 
 {
 Calendar c=Calendar.getInstance();
 
 sop(pattern(c));//显示今天日期和当前时间
 
 c.add(Calendar.YEAR,3);//年份变为3年后
 
 
 sop(pattern(c));//显示指定日期和时间
 
 
 }
 
 
 //获取指定日期和时间
 public static String pattern(Calendar c)
 {
 String s=year(c)+month(c)+day(c)+week(c)+" "+time(c);
 return s;
 }
 
 //获取年份
 public static int year(Calendar c)
 {
 return c.get(Calendar.YEAR);
 }
 //获取月份
 public static String month(Calendar c)
 {
 String[] yue={"一月","二月","三月","四月",
 "五月","六月","七月","八月",
 "九月","十月","十一月","十二月"};
 return yue[c.get(Calendar.MONTH)];
 }
 //获取日期
 public static int day(Calendar c)
 {
 return c.get(Calendar.DAY_OF_MONTH);
 }
 //获取星期
 public static String week(Calendar c)
 {
 String[] day={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};
 return day[c.get(Calendar.DAY_OF_WEEK)];
 }
 //获取时间，格式为时：分：秒
 public static String time(Calendar c)
 {
 String s=c.get(Calendar.HOUR_OF_DAY)+":"+c.get(Calendar.MINUTE)+":"+c.get(Calendar.SECOND);
 return s;
 }
 
 
 //打印输出
 public static void sop(Object obj)
 {
 System.out.println(obj);
 }
 }
 
 

 
 

 第四讲     Math类
 

 一、概述
 

         Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。该类全为静态方法。
 

  
 

 二、方法
 

         1、doubleceil(double d);//返回大于指定数据的最小整数
 

         2、doublefloor(double d);//返回小于指定数据的最大整数
 

         3、double pow(doublea,double b);//返回a的b次方
 

         4、long round(doubleb);//返回b四舍五入的值 
 

         5、doublerandom();//返回正号的double值，是一个大于等于0.0且小于1.0的随机数
 

  
 

 三、Random类
 

         这是java.util中的一个单独的类，该类对象用于获取随机数。与Math中的random方法是一样的，不过这个类有自身的方法，可以将相应的随机数强转为指定基本数据类型。
 

 示例：
 

 /*
 练习：给定一个小数，保留该小数的后n位。
 1、先把给定小数乘以10的n次方，四舍五入保留整数部分
 2、再把该整数除以10的n次方
 */
 class MathTest 
 {
 public static void main(String[] args) 
 {
 
 double d=retention(13.6572,2);
 
 
 System.out.println("d="+d);
 }
 
 //保留小数位方法
 public static double retention(double d,int n)
 {
 double d1=d*Math.pow(10,n);//先将要保留的小数位变为整数
 long l=Math.round(d1);//将小数四舍五入
 return l/Math.pow(10,n);//返回保留了指定小数位的小数
 }
 }
 
 

 

 

 

 

 
 


 

                

        

    

  



    

      

        

            

              
                
                  rongbinjava
                
              
            

            

                关注
              
            

        

        

          
      

      










            

  



          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值