那些java中的常用类（二）

本节将介绍剩下的几个java常用类。

3.Object类

• Object类存储在java.lang包中，是所有java类(Object类除外)的终极父类。当然，数组也继承了Object类，但是，接口和枚举类是不继承Object类的。
• java的任何类都继承了Object类的成员方法，并且可以重写不被final修饰的方法。
• Object类包含的一些成员方法：

　　　　

1. Object()方法：一般情况下，java通过new关键字来创建对象，而这是通过类中的构造方法来实现的。因此，java中规定：在类的定义过程中，对于未定义构造方法的类，默认会有一个无参的构造方法，作为所有java类的父类，Object自然也要体现这一特性。所以，在Object的源码中没有给出构造方法的具体定义，但实际上这个构造方法是存在的。
2. clone()方法：这个方法可以产生一个相同的类，并且返回给调用者。这是一个native方法，由C语言实现，使用时需要注意：当代码执行的时候，将会检查调用对象的类(或者父类)是否实现了java.lang.Cloneable接口(Object类不实现Cloneable)。如果没有实现这个接口，clone()将会抛出一个检查异常()——java.lang.CloneNotSupportedException,如果实现了这个接口，clone()会创建一个新的对象，并将原来对象的内容复制到新对象，最后返回这个新对象的引用。
3. finalize()方法：finalize()也是一个native方法，并且这个方法可以被子类对象所覆盖，然后作为一个终结者，当GC被调用的时候完成最后的清理工作（例如释放系统资源之类）。默认的finalize()方法什么也不做，当被调用时直接返回。
4. Object还提供了wait、notify、notifyAll几个方法，用于控制线程的暂停和运行，这将在以后的文章中进行详细介绍。
5. clone()方法的使用示例：
   

   /*
    * 定义一个Person类，并实现Cloneable接口
    */
   public class Person implements Cloneable {
   
       @Override
       protected Object clone() throws CloneNotSupportedException {
           // TODO Auto-generated method stub
           return super.clone();
       }
   
       public String name;
   }

   public class CloneTest {
       public static void main(String[] args) throws CloneNotSupportedException {
           //创建一个Person对象，并初始化
           Person p1 = new Person("hello");
           System.out.println(p1.name);//hello
           
           /*
            * 调用clone方法，对p1对象进行克隆
            *     注意：当代码执行的时候，将会检查调用对象的类(或者父类)是否实现了java.lang.Cloneable接口(Object类不实现Cloneable)。
            *         如果没有实现这个接口，clone()将会抛出一个检查异常()——java.lang.CloneNotSupportedException,
            *         如果实现了这个接口，clone()会创建一个新的对象，并将原来对象的内容复制到新对象，最后返回这个新对象的引用。
            */
           //所以，此处会先检查Person类是否实现了Cloneable，即重写clone()方法。
           Person p2 = (Person) p1.clone();
           System.out.println(p2.name);//hello
           
       }
   
   }

4.Math类

 Math类提供了基本数学函数的计算方法，并且Math类中所有的成员变量（主要指PI和E）和成员方法都是静态的，可以通过类名直接调用。这里只是简单列举一些：

public class MathDemo {

    public static void main(String[] args) {
        /** 
         * abs求绝对值 
         */  
        System.out.println(Math.abs(-10.4));    //10.4  
        System.out.println(Math.abs(10.1));     //10.1  
          
        /** 
         * ceil天花板的意思，就是返回大的值，注意一些特殊值 
         */  
        System.out.println(Math.ceil(-10.1));   //-10.0  
        System.out.println(Math.ceil(10.7));    //11.0  
        System.out.println(Math.ceil(-0.7));    //-0.0  
        System.out.println(Math.ceil(0.0));     //0.0  
        System.out.println(Math.ceil(-0.0));    //-0.0  
          
        /** 
         * floor地板的意思，就是返回小的值 
         */  
        System.out.println(Math.floor(-10.1));  //-11.0  
        System.out.println(Math.floor(10.7));   //10.0  
        System.out.println(Math.floor(-0.7));   //-1.0  
        System.out.println(Math.floor(0.0));    //0.0  
        System.out.println(Math.floor(-0.0));   //-0.0  
          
        /** 
         * max 两个中返回大的值,min和它相反，就不举例了 
         */  
        System.out.println(Math.max(-10.1, -10));   //-10.0  
        System.out.println(Math.max(10.7, 10));     //10.7  
        System.out.println(Math.max(0.0, -0.0));    //0.0  
          
        /** 
         * random 取得一个大于或者等于0.0小于不等于1.0的随机数 
         */  
        System.out.println(Math.random());  //0.08417657924317234  
        System.out.println(Math.random());  //0.43527904004403717  
          
        /** 
         * rint 四舍五入，返回double值 
         * 注意.5的时候会取偶数 
         */  
        System.out.println(Math.rint(10.1));    //10.0  
        System.out.println(Math.rint(10.7));    //11.0  
        System.out.println(Math.rint(11.5));    //12.0  
        System.out.println(Math.rint(10.5));    //10.0  
        System.out.println(Math.rint(10.51));   //11.0  
        System.out.println(Math.rint(-10.5));   //-10.0  
        System.out.println(Math.rint(-11.5));   //-12.0  
        System.out.println(Math.rint(-10.51));  //-11.0  
        System.out.println(Math.rint(-10.6));   //-11.0  
        System.out.println(Math.rint(-10.2));   //-10.0  
          
        /** 
         * round 四舍五入，float时返回int值，double时返回long值 
         */  
        System.out.println(Math.round(10.1));   //10  
        System.out.println(Math.round(10.7));   //11  
        System.out.println(Math.round(10.5));   //11  
        System.out.println(Math.round(10.51));  //11  
        System.out.println(Math.round(-10.5));  //-10  
        System.out.println(Math.round(-10.51)); //-11  
        System.out.println(Math.round(-10.6));  //-11  
        System.out.println(Math.round(-10.2));  //-10  
        
        /*
         * 指数函数的计算方法，返回double值
         *     注意Math.log()是计算以e为底数的自然对数
         */
        System.out.println(Math.pow(Math.E, 2));//e^2
        System.out.println(Math.sqrt(25));//5.0
        System.out.println(Math.exp(2));//e^2
        System.out.println(Math.log(Math.pow(Math.E, 2)));//2.0
        System.out.println(Math.log10(100));//2.0
        
    }

需要注意的是Math类中的取整方法：rint和round。

• rint遇到x.5的时候会取偶数
• round(x) = floor(x+0.5)

5.Random类

 Random类用于生成伪随机数，它有两个构造器：一个构造器使用默认的种子（系统当前时间的毫秒值）；另一个构造器需要程序员显示的传入一个long型的参数作为种子。

    public static void main(String[] args) {
        
        //使用默认种子的构造器，以系统当前时间的毫秒数作为种子
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            System.out.print(random.nextInt(10)+" ");
        }//5 0 2 6 5 0 4 1 4 9 
        
        /*使用带参数的构造器，传入一个long型整数作为种子
         *需要注意的是：
         * 相同种子数的Random对象，相同次数生成的随机数字是完全相同的。
         * 即是，两个种子数相同的Random对象，第一次生成的随机数完全相同，第二次生成的随机数也完全相同
         * 这点在生成多个随机数字时需要特别注意。
         */
        Random r1 = new Random(10);
        Random r2 = new Random(10);
        System.out.println(r1.nextInt() == r2.nextInt());//true
        System.out.println(r1.nextInt() == r2.nextInt());//true
        
    }

因此，为了避免两个Random对象产生相同的随机数序列，我们通常使用系统当前时间作为种子来生成随机数。而且，Random类还提供了一些其他类型的随机数生成方法，如nextDouble、nextFloat、nextLong、nextBoolean等。

        Random random = new Random();

        //nextDouble方法，产生[0.0,1.0)之间的double型随机数
        //注意：Math类中的random方法就是调用Random类中的nextDouble方法实现的。
        for (int i = 0; i < 10; i++) {
            System.out.print(random.nextDouble()+" ");
        }
        System.out.println();
        
        //nextFloat方法，产生[0.0,1.0)之间的float型随机数
        for (int i = 0; i < 10; i++) {
            System.out.print(random.nextFloat()+" ");
        }
        System.out.println();
        
        //nextLong方法，产生long型的随机整数
        for (int i = 0; i < 10; i++) {
            System.out.print(random.nextLong()+" ");
        }
        System.out.println();
        
        //nextBoolean方法，产生随机的布尔数
        for (int i = 0; i < 10; i++) {
            System.out.print(random.nextBoolean());
        }
            

6.File类

 File类是java.io包下用于操作与平台无关的文件和目录，也就是说，不管是文件还是目录都是使用File类来操作的。File类能够新建、删除和重命名文件和目录，但是File类不能访问文件的内容，需要通过输入/输出流来访问。

• 构造方法：File(String pathname)、File(String parent, String child)、File(File parent, String child)、File(URI uri)
• 创建文件和目录：createNewFile() 文件不存在则创建并返回true，否则返回false、mkdir()创建目录、mkdirs()创建多级目录
• 删除文件和目录：delete()、deleteOnExit()
• 文件和目录信息获取：getName()、getPath()、getAbsolutePath()、getAbsoluteFile()、getParent()、getParentFile()等等。
• 获取指定目录下文件列表：listFiles()、list()
• 文件过滤：list(FilenameFilter filter)、listFiles(FilenameFilter filter)、listFiles(FileFilter filter)，代码示例如下：

 1　　 /*    
    * 从根目录开始搜索符合条件的文件
    */
    public static void main(String[] args){
            File[] files =File.listRoots();
            for(File file:files){
                System.out.println(file);
                if(file.length()>0){
                    String[] filenames =file.list(new FilenameFilter(){
                        //file 过滤目录 name 文件名
                        public boolean accept(File file,String filename){
                            return filename.endsWith(".mp3");
                        }
                    });
                    for(String filename:filenames){
                        System.out.println(filename);
                    }
                }
            }
        }


    public static void main(String[] args) {
//        System.out.println(System.getProperty("user.dir"));
        
        //先获取文件列表，再进行逐个筛选
        File fileRoot = new File("D:\\...\\codeAnal");
        File[] files = fileRoot.listFiles();
        for(File file: files){
            if(file.getName().startsWith("C")){
                System.out.println(file.getName());
            }    
        }
    }

7.枚举类（Enum）

 在一些特定的情况下，某个类的对象是有限而且固定的，例如季节类，它只有四个对象，再例如星期类，只有七个对象等等。这种实例对象有限而且固定的类在java中称为枚举类。

一、手动实现一个枚举类

一般来说有下面几个步骤：

• 将枚举类的构造器定义为private，使得其它类不可自行创建该类的实例对象；
• 将这个类的所有可能的实例对象用public static final来修饰，即定义为该类的静态常量；
• 在必要的情况下，提供一些静态方法，允许其他类通过指定参数来获取指定的实例对象。

代码示例如下：

/*
 * 这是一个枚举类，只有四个实例对象
 */
public class Season {

    //将season类定义成私有的，将其属性也定义成final
    private final String  name;
    private final String  desc;
    public static final Season SPRIGN = new Season("春天", "春天来了");
    public static final Season SUMMER = new Season("夏天", "夏天来了");
    public static final Season FALL = new Season("秋天", "秋天来了");
    public static final Season WINTER = new Season("冬天", "冬天来了");
    
    private Season (String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
    
    //定义一个获取season对象的方法，这是一个静态工厂方法
    public static Season getSeason(int seasonNum){
        switch(seasonNum){
        case 1: return SPRIGN;
        case 2: return SUMMER;
        case 3: return FALL;
        case 4: return WINTER;
        default: return null;
        }
    }
    
    public String getDesc() {
        return desc;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "Season [name=" + name + ", desc=" + desc + "]";
    }
}

public class EnumDemo {
    public static void main(String[] args) {
        //获取枚举类的实例对象
        System.out.println(Season.getSeason(1).toString());//Season [name=春天, desc=春天来了]
        System.out.println(Season.SPRIGN.toString());//Season [name=春天, desc=春天来了]
        System.out.println(Season.FALL.toString());//Season [name=秋天, desc=秋天来了]
    }

}

 通过观察代码可知，使用枚举类可以增加程序的健壮性，能够避免随意地创建对象。

 二、枚举类的简单使用

JDK1.5新增了enum关键字，其作用类似于class和interface关键字，将生成一个枚举类，即一种特殊的java类。这种枚举类与其他一些普通类有如下简单区别：

• 使用enum定义的枚举类默认继承了java.lang.Enum类，而不是继承Object类。
• 枚举类的构造器只能使用private关键字来修饰，如果省略此关键字，则默认使用private修饰。
• 枚举类中的所有实例必须显示列出，而且对于列出的实例，系统都会自动加上public static final修饰，无序程序员手动添加。
• 所有枚举类都提供了一个values方法，用于遍历所有的枚举值。

代码示例：

/*
 * 定义一个枚举类
 */
public enum SeasonNum {
    SPRING,SUMMER,FALL,WINTER;
}

public class EnumDemo {
    
    public static void main(String[] args) {
        
        //通过values方法遍历枚举值，即枚举类的所有实例
        for(SeasonNum season: SeasonNum.values()){
            System.out.print(season+" ");
        }//SPRING SUMMER FALL WINTER 
        
        System.out.println();
        judge(SeasonNum.SPRING);//春天来了
        
    }

    private static void judge(SeasonNum season) {

        switch (season) {
        case SPRING:
            System.out.println("春天来了");
            break;
        case SUMMER:
            System.out.println("夏天来了");
            break;
        case FALL:
            System.out.println("秋天来了");
            break;
        case WINTER:
            System.out.println("冬天来了");
            break;
        default:
            break;
        }
    }
}

 三、实现接口的枚举类

枚举类可以实现一个或者多个接口，与普通类一样，枚举类实现接口时也需要实现该接口所包含的方法。但是不同的是：如果需要每个枚举值在调用接口中的方法时呈现不同的行为方式，则可以让每个枚举值分别按照自己的方式来实现该方法。每个枚举值提供不同的实现方式，从而让不同枚举值调用该方法时具有不同的行为方式。

代码示例：

/*
 * 定义一个性别的接口类
 */
public interface GenderInfo {

    void info();
}

/*
 * 定义一个性别的枚举类，实现GenderInfo接口
 */
public enum Gender implements GenderInfo {
    
    //此处的枚举值必须调用对应的构造器来实现，并且不同的枚举值提供不同的实现方式
    MALE("男"){
        @Override
        public void info() {
            System.out.println("这是一个男性的枚举值");
        }
    },
    
    FEMALE("女"){
        @Override
        public void info() {
            System.out.println("这是一个女性的枚举值");
        }
    };

    private final String name;
    //自定义枚举类的构造器，访问修饰符必须为private
    private Gender(String name){
        this.name = name;
    }

}

/*
 * 接口枚举类的测试
 */
public class GenderEnumDemo {

    public static void main(String[] args) {
        //通过类名直接获取枚举类的实例对象，然后调用info方法
        Gender.MALE.info();//输出：这是一个男性的枚举值
        Gender.FEMALE.info();//输出：这是一个男女性的枚举值
    }
}

 

本节只是简单介绍了一下枚举类，详细了解可参考：http://www.cnblogs.com/hemingwang0902/archive/2011/12/29/2306263.html