使用java的API编写代码

使用java的API编写代码

JavaBean

在Java中，有很多class的定义都符合这样的规范：

• 若干private实例字段；
• 通过public方法来读写实例字段。

public class Person {
    private String name;
    private int age;

    public String getName() { return this.name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return this.age; }
    public void setAge(int age) { this.age = age; }
}

如果读写方法符合以下这种命名规范：

// 读方法:
public Type getXyz()
// 写方法:
public void setXyz(Type value)

那么这种class被称为JavaBean：

上面的字段是xyz，那么读写方法名分别以get和set开头，并且后接大写字母开头的字段名Xyz，因此两个读写方法名分别是getXyz()和setXyz()。

boolean字段比较特殊，它的读方法一般命名为isXyz()：

// 读方法:
public boolean isChild()
// 写方法:
public void setChild(boolean value)

我们通常把一组对应的读方法（getter）和写方法（setter）称为属性（property）。例如，name属性：

• 对应的读方法是String getName()
• 对应的写方法是setName(String)

只有getter的属性称为只读属性（read-only），例如，定义一个age只读属性：

• 对应的读方法是int getAge()
• 无对应的写方法setAge(int)

类似的，只有setter的属性称为只写属性（write-only）。

很明显，只读属性很常见，只写属性不常见。

属性只需要定义getter和setter方法，不一定需要对应的字段。例如，child只读属性定义如下：

public class Person {
    private String name;
    private int age;

    public String getName() { return this.name; }
    public void setName(String name) { this.name = name; }

    public int getAge() { return this.age; }
    public void setAge(int age) { this.age = age; }

    public boolean isChild() {
        return age <= 6;
    }
}

可以看出，getter和setter也是一种数据封装的方法。

JavaBean的作用

JavaBean主要用来传递数据，即把一组数据组合成一个JavaBean便于传输。此外，JavaBean可以方便地被IDE工具分析，生成读写属性的代码，主要用在图形界面的可视化设计中。

枚举JavaBean属性

要枚举一个JavaBean的所有属性，可以直接使用Java核心库提供的Introspector：

import java.beans.*;
public class Main {
    public static void main(String[] args) throws Exception {
        BeanInfo info = Introspector.getBeanInfo(Person.class);
        for (PropertyDescriptor pd : info.getPropertyDescriptors()) {
            System.out.println(pd.getName());
            System.out.println("  " + pd.getReadMethod());
            System.out.println("  " + pd.getWriteMethod());
        }
    }
}

class Person {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

运行上述代码，可以列出所有的属性，以及对应的读写方法。注意class属性是从Object继承的getClass()方法带来的。

JavaBean是一种符合命名规范的class，它通过getter和setter来定义属性；

属性是一种通用的叫法，并非Java语法规定；

可以利用IDE快速生成getter和setter；

使用Introspector.getBeanInfo()可以获取属性列表。

 

枚举类

在Java中，我们可以通过static final来定义常量。例如，我们希望定义周一到周日这7个常量，可以用7个不同的int表示：

public class Weekday {
    public static final int SUN = 0;
    public static final int MON = 1;
    public static final int TUE = 2;
    public static final int WED = 3;
    public static final int THU = 4;
    public static final int FRI = 5;
    public static final int SAT = 6;
}

使用常量的时候，可以这么引用：

if (day == Weekday.SAT || day == Weekday.SUN) {
    // TODO: work at home
}

也可以把常量定义为字符串类型，例如，定义3种颜色的常量：

public class Color {
    public static final String RED = "r";
    public static final String GREEN = "g";
    public static final String BLUE = "b";
}

使用常量的时候，可以这么引用：

String color = ...
if (Color.RED.equals(color)) {
    // TODO:
}

无论是int常量还是String常量，使用这些常量来表示一组枚举值的时候，有一个严重的问题就是，编译器无法检查每个值的合理性。例如：

if (weekday == 6 || weekday == 7) {
    if (tasks == Weekday.MON) {
        // TODO:
    }
}

上述代码编译和运行均不会报错，但存在两个问题：

• 注意到Weekday定义的常量范围是0~6，并不包含7，编译器无法检查不在枚举中的int值；
• 定义的常量仍可与其他变量比较，但其用途并非是枚举星期值。

enum

　　Java中的枚举其实是一种语法糖，在 JDK 1.5之后出现，用来表示固定且有限个的对象。比如一个季节类有春、夏、秋、冬四个对象；一个星期有星期一到星期日七个对象。这些明显都是固定的，且有限个。

枚举类和普通类的区别

　　①、使用 enum 定义的枚举类默认继承 java.lang.Enum 类，即枚举类是不能再继承别的类了。而普通类的一般父类默认是 Object

　　②、枚举类的构造器只能使用 private 定义，而普通类的还可以用 public 修饰

　　③、枚举类的所有实例必须在枚举类中显示列出（，分隔   ；结尾），列出的实例系统会默认自动添加 public static final 修饰

　　④、所有的枚举类都提供了一个 values() 方法，可以用来遍历枚举值

为了让编译器能自动检查某个值在枚举的集合内，并且，不同用途的枚举需要不同的类型来标记，不能混用，我们可以使用enum来定义枚举类：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day == Weekday.SAT || day == Weekday.SUN) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}

enum Weekday {
    SUN, MON, TUE, WED, THU, FRI, SAT;
}

注意到定义枚举类是通过关键字enum实现的，我们只需依次列出枚举的常量名。

和int定义的常量相比，使用enum定义枚举有如下好处：

首先，enum常量本身带有类型信息，即Weekday.SUN类型是Weekday，编译器会自动检查出类型错误。例如，下面的语句不可能编译通过：

int day = 1;
if (day == Weekday.SUN) { // Compile error: bad operand types for binary operator '=='
}

其次，不可能引用到非枚举的值，因为无法通过编译。

最后，不同类型的枚举不能互相比较或者赋值，因为类型不符。例如，不能给一个Weekday枚举类型的变量赋值为Color枚举类型的值：

Weekday x = Weekday.SUN; // ok!
Weekday y = Color.RED; // Compile error: incompatible types

这就使得编译器可以在编译期自动检查出所有可能的潜在错误。

enum的比较

使用enum定义的枚举类是一种引用类型。前面我们讲到，引用类型比较，要使用equals()方法，如果使用==比较，它比较的是两个引用类型的变量是否是同一个对象。因此，引用类型比较，要始终使用equals()方法，但enum类型可以例外。

这是因为enum类型的每个常量在JVM中只有一个唯一实例，所以可以直接用==比较：

if (day == Weekday.FRI) { // ok!
}
if (day.equals(Weekday.SUN)) { // ok, but more code!
}

enum类型

通过enum定义的枚举类，和其他的class有什么区别？

答案是没有任何区别。enum定义的类型就是class，只不过它有以下几个特点：

• 定义的enum类型总是继承自java.lang.Enum，且无法被继承；
• 只能定义出enum的实例，而无法通过new操作符创建enum的实例；
• 定义的每个实例都是引用类型的唯一实例；
• 可以将enum类型用于switch语句。

例如，我们定义的Color枚举类：

public enum Color {
    RED, GREEN, BLUE;
}

编译器编译出的class大概就像这样：

public final class Color extends Enum { // 继承自Enum，标记为final class
    // 每个实例均为全局唯一:
    public static final Color RED = new Color();
    public static final Color GREEN = new Color();
    public static final Color BLUE = new Color();
    // private构造方法，确保外部无法调用new操作符:
    private Color() {}
}

所以，编译后的enum类和普通class并没有任何区别。但是我们自己无法按定义普通class那样来定义enum，必须使用enum关键字，这是Java语法规定的。

因为enum是一个class，每个枚举的值都是class实例，因此，这些实例有一些方法：

name()

返回常量名，例如：

String s = Weekday.SUN.name(); // "SUN"

ordinal()

返回定义的常量的顺序，从0开始计数，例如：

int n = Weekday.MON.ordinal(); // 1

改变枚举常量定义的顺序就会导致ordinal()返回值发生变化。例如：

public enum Weekday {
    SUN, MON, TUE, WED, THU, FRI, SAT;
}

和

public enum Weekday {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}

的ordinal就是不同的。如果在代码中编写了类似if(x.ordinal()==1)这样的语句，就要保证enum的枚举顺序不能变。新增的常量必须放在最后。

有些童鞋会想，Weekday的枚举常量如果要和int转换，使用ordinal()不是非常方便？比如这样写：

String task = Weekday.MON.ordinal() + "/ppt";
saveToFile(task);

但是，如果不小心修改了枚举的顺序，编译器是无法检查出这种逻辑错误的。要编写健壮的代码，就不要依靠ordinal()的返回值。因为enum本身是class，所以我们可以定义private的构造方法，并且，给每个枚举常量添加字段：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Work at home!");
        } else {
            System.out.println("Work at office!");
        }
    }
}

enum Weekday {
    MON(1), TUE(2), WED(3), THU(4), FRI(5), SAT(6), SUN(0);

    public final int dayValue;

    private Weekday(int dayValue) {
        this.dayValue = dayValue;
    }
}

这样就无需担心顺序的变化，新增枚举常量时，也需要指定一个int值。

 注意：枚举类的字段也可以是非final类型，即可以在运行期修改，但是不推荐这样做！

默认情况下，对枚举常量调用toString()会返回和name()一样的字符串。但是，toString()可以被覆写，而name()则不行。我们可以给Weekday添加toString()方法：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        if (day.dayValue == 6 || day.dayValue == 0) {
            System.out.println("Today is " + day + ". Work at home!");
        } else {
            System.out.println("Today is " + day + ". Work at office!");
        }
    }
}

enum Weekday {
    MON(1, "星期一"), TUE(2, "星期二"), WED(3, "星期三"), THU(4, "星期四"), FRI(5, "星期五"), SAT(6, "星期六"), SUN(0, "星期日");

    public final int dayValue;
    private final String chinese;

    private Weekday(int dayValue, String chinese) {
        this.dayValue = dayValue;
        this.chinese = chinese;
    }

    @Override
    public String toString() {
        return this.chinese;
    }
}

覆写toString()的目的是在输出时更有可读性。

 注意：判断枚举常量的名字，要始终使用name()方法，绝不能调用toString()！

switch

枚举类可以应用在switch语句中。因为枚举类天生具有类型信息和有限个枚举常量，所以比int、String类型更适合用在switch语句中：

public class Main {
    public static void main(String[] args) {
        Weekday day = Weekday.SUN;
        switch(day) {
        case MON:
        case TUE:
        case WED:
        case THU:
        case FRI:
            System.out.println("Today is " + day + ". Work at office!");
            break;
        case SAT:
        case SUN:
            System.out.println("Today is " + day + ". Work at home!");
            break;
        default:
            throw new RuntimeException("cannot process " + day);
        }
    }
}

enum Weekday {
    MON, TUE, WED, THU, FRI, SAT, SUN;
}

加上default语句，可以在漏写某个枚举常量时自动报错，从而及时发现错误。

Java使用enum定义枚举类型，它被编译器编译为final class Xxx extends Enum { … }；

通过name()获取常量定义的字符串，注意不要使用toString()；

通过ordinal()返回常量定义的顺序（无实质意义）；

可以为enum编写构造方法、字段和方法

enum的构造方法要声明为private，字段强烈建议声明为final；

enum适合用在switch语句中。

使用 Enum 来表示季节类：

public enum SeasonEnum {
 
    //必须在第一行写出有哪些枚举值
    SPRING("春天", "春暖花开"),
    SUMMER("夏天", "炎炎盛夏"),
    FALL("秋天", "秋高气爽"),
    WINTER("冬天", "大雪纷飞");
     
    private final String name;
    private final String desc;
     
    private SeasonEnum(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
     
     
}

public static void main(String[] args) {
         
        System.out.println(SeasonEnum.SPRING); //SPRING
        //用 values() 来获取所有的枚举值
        for(SeasonEnum s : SeasonEnum.values()){
            System.out.println(s);
        }
    }

枚举类还能实现接口：

第一步：定义一个接口，方法是返回季节的月份

public interface SeasonEnumImpl {
    //用来返回季节的月份
    String getMonth();
 
}

第二步：季节类实现接口，并实现接口中的方法

public enum SeasonEnum implements SeasonEnumImpl{
 
    //必须在第一行写出有哪些枚举值
    SPRING("春天", "春暖花开"){
        @Override
        public String getMonth() {
            return "12-2";
        }
    },
    SUMMER("夏天", "炎炎盛夏"){
        @Override
        public String getMonth() {
            return "3-5";
        }
    },
    FALL("秋天", "秋高气爽"){
        @Override
        public String getMonth() {
            return "6-8";
        }
    },
    WINTER("冬天", "大雪纷飞"){
        @Override
        public String getMonth() {
            return "9-11";
        }
    };
     
    private final String name;
    private final String desc;
     
    private SeasonEnum(String name, String desc) {
        this.name = name;
        this.desc = desc;
    }
}　　

public static void main(String[] args) {
         
        System.out.println(SeasonEnum.SPRING); //SPRING
         
        //用 values() 来获取所有的枚举值
        for(SeasonEnum s : SeasonEnum.values()){
            System.out.println(s.getMonth());
        }
    }　

结果为：

SPRING
12-2
3-5
6-8
9-11

如果枚举类的对象只有一个，那么可以作为单例模式的实现

 

Math工具类

public class MathDemo {
	    public static void main(String args[]){  
	        /** 
	         *Math.sqrt()//计算平方根
	         *Math.cbrt()//计算立方根
	         *Math.pow(a, b)//计算a的b次方
	         *Math.max( , );//计算最大值
	         *Math.min( , );//计算最小值
	         */  

	        System.out.println(Math.sqrt(16));   //4.0 
	        System.out.println(Math.cbrt(8));    //2.0
	        System.out.println(Math.pow(3,2));     //9.0
	        System.out.println(Math.max(2.3,4.5));//4.5
	        System.out.println(Math.min(2.3,4.5));//2.3
                Math.exp(2); // 计算ex次方：7.389...
                Math.log(4); // 计算以e为底的对数：1.386...
                Math.log10(100); // 计算以10为底的对数：2

                //三角函数
                Math.sin(3.14); // 0.00159...
                Math.cos(3.14); // -0.9999...
                Math.tan(3.14); // -0.0015...
                Math.asin(1.0); // 1.57079...
                Math.acos(1.0); // 0.0

	        /** 
	         * 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  
	        System.out.println(Math.ceil(-1.7));    //-1.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  

	        
	        System.out.println("----------------------------");
	        /** 
	         * random 取得一个大于或者等于0.0小于不等于1.0的随机数 
	         */  
	        System.out.println(Math.random());  //小于1大于0的double类型的数
	        System.out.println(Math.random()*2);//大于0小于1的double类型的数
	        System.out.println(Math.random()*2+1);//大于1小于2的double类型的数

	        /** 
	         * 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  

                //Math还提供了几个数学常量
                double pi = Math.PI; // 3.14159...
                double e = Math.E; // 2.7182818...
                Math.sin(Math.PI / 6); // sin(π/6) = 0.5

	    }  
	}

生成一个随机数x，x的范围是0 <= x < 1：

Math.random(); // 0.53907... 每次都不一样

如果我们要生成一个区间在[MIN, MAX)的随机数，可以借助Math.random()实现，计算如下：

// 区间在[MIN, MAX)的随机数
public class Main {
    public static void main(String[] args) {
        double x = Math.random(); // x的范围是[0,1)
        double min = 10;
        double max = 50;
        double y = x * (max - min) + min; // y的范围是[10,50)
        long n = (long) y; // n的范围是[10,50)的整数
        System.out.println(y);
        System.out.println(n);
    }
}

有些童鞋可能注意到Java标准库还提供了一个StrictMath，它提供了和Math几乎一模一样的方法。这两个类的区别在于，由于浮点数计算存在误差，不同的平台（例如x86和ARM）计算的结果可能不一致（指误差不同），因此，StrictMath保证所有平台计算结果都是完全相同的，而Math会尽量针对平台优化计算速度，所以，绝大多数情况下，使用Math就足够了。

Random

Random用来创建伪随机数。所谓伪随机数，是指只要给定一个初始的种子，产生的随机数序列是完全一样的。

要生成一个随机数，可以使用nextInt()、nextLong()、nextFloat()、nextDouble()：

Random r = new Random();
r.nextInt(); // 2071575453,每次都不一样
r.nextInt(10); // 5,生成一个[0,10)之间的int
r.nextLong(); // 8811649292570369305,每次都不一样
r.nextFloat(); // 0.54335...生成一个[0,1)之间的float
r.nextDouble(); // 0.3716...生成一个[0,1)之间的double

有童鞋问，每次运行程序，生成的随机数都是不同的，没看出伪随机数的特性来。

这是因为我们创建Random实例时，如果不给定种子，就使用系统当前时间戳作为种子，因此每次运行时，种子不同，得到的伪随机数序列就不同。

如果我们在创建Random实例时指定一个种子，就会得到完全确定的随机数序列：

import java.util.Random;
public class Main {
    public static void main(String[] args) {
        Random r = new Random(12345);
        for (int i = 0; i < 10; i++) {
            System.out.println(r.nextInt(100));
        }
        // 51, 80, 41, 28, 55...
    }
}

前面我们使用的Math.random()实际上内部调用了Random类，所以它也是伪随机数，只是我们无法指定种子。

SecureRandom

有伪随机数，就有真随机数。实际上真正的真随机数只能通过量子力学原理来获取，而我们想要的是一个不可预测的安全的随机数，SecureRandom就是用来创建安全的随机数的：

SecureRandom sr = new SecureRandom();
System.out.println(sr.nextInt(100));

SecureRandom无法指定种子，它使用RNG（random number generator）算法。JDK的SecureRandom实际上有多种不同的底层实现，有的使用安全随机种子加上伪随机数算法来产生安全的随机数，有的使用真正的随机数生成器。实际使用的时候，可以优先获取高强度的安全随机数生成器，如果没有提供，再使用普通等级的安全随机数生成器：

import java.util.Arrays;
import java.security.SecureRandom;
import java.security.NoSuchAlgorithmException;
public class Main {
    public static void main(String[] args) {
        SecureRandom sr = null;
        try {
            sr = SecureRandom.getInstanceStrong(); // 获取高强度安全随机数生成器
        } catch (NoSuchAlgorithmException e) {
            sr = new SecureRandom(); // 获取普通的安全随机数生成器
        }
        byte[] buffer = new byte[16];
        sr.nextBytes(buffer); // 用安全随机数填充buffer
        System.out.println(Arrays.toString(buffer));
    }
}

SecureRandom的安全性是通过操作系统提供的安全的随机种子来生成随机数。这个种子是通过CPU的热噪声、读写磁盘的字节、网络流量等各种随机事件产生的“熵”。

在密码学中，安全的随机数非常重要。如果使用不安全的伪随机数，所有加密体系都将被攻破。因此，时刻牢记必须使用SecureRandom来产生安全的随机数。

 需要使用安全随机数的时候，必须使用SecureRandom，绝不能使用Random！

Java提供的常用工具类有：

• Math：数学计算

• Random：生成伪随机数

• SecureRandom：生成安全的随机数

 

集合常用工具类

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class CollectionsTest {
	public static void main(String[] args) {
		List list = new ArrayList();
		list.add(12);
		list.add(-15);
		list.add(7);
		list.add(4);
		list.add(35);
		list.add(9);
		
		System.out.println("源列表：" + list);

		// 最大值
		System.out.println("最大值：" + Collections.max(list));
		
		// 最小值
		System.out.println("最小值：" + Collections.min(list));
		
		// 替换
		Collections.replaceAll(list, -15, 12);
		System.out.println("-15替换12：" + list);
 
		// 出现次数
		System.out.println("12出现次数：" + Collections.frequency(list, 12));

		// 排序（自然顺序）
		Collections.sort(list);
		System.out.println("自然序：" + list);
		
		// 逆序
		Collections.reverse(list);
		System.out.println("逆序：" + list);
		
		
		// 随机排序
		Collections.shuffle(list);
		System.out.println("随机序：" + list);
		
		// 定制排序的用法，将int类型转成string进行比较
		Collections.sort(list, new Comparator