JAVA从入门到精通（一）基础篇

一、JAVA语言基础

public class First {  //入门
    //类的属性称为类的全局变量（成员变量）
    /*
       成员变量又可以分为静态变量和实例变量
       成员变量前面加一个static关键字就是静态变量（静态变量的有效范围可以跨类，甚至可达到整个应用程序之外）
       静态变量除了可以在定义的类内存取，还能直接以：类名.静态变量方式在其他类内使用。
     */
    static String s1 = "你好";

    /*
     创建字符串的方法：String(char a[]),
             String(char a[],int offset,int length)-offset表示开始截取字符串的位置，length表示截取字符串的长度
             String(char[] value)
     */
    static char a[] = {'g', 'o', 'o', 'd'};
    static String S1 = new String(a);
    static String S2 = new String("good");

    public static void main(String[] args) { //main方法是类中的主方法
        /*  public\static\void分别是main()方法的权限修饰符、静态修饰符、返回类型修饰符
         *    java程序中的main()方法必须声明为public static void
         *    String[] args是一个字符串类型的数组为main()方法的参数*/
        //方法中的属性称为局部变量
        String s2 = "Java";
        System.out.println(s1);
        System.out.println(s2);
        System.out.println(S1);
        System.out.println(S2);
        System.out.println(S1.equals(S2));
    }


}

二、字符串

创建字符串的方法：

String(char a[]),
String(char a[],int offset,int length)-offset表示开始截取字符串的位置，length表示截取字符串的长度
String(char[] value)

static char a[]={'g','o','o','d'};
static String s1 = new String(a);
static String s2 = new String("good");

    获取字符串信息
    1、字符串长度str.length()
    2、查找字符串，indexOf()、lastIndexOf()搜索指定条件的字符串或字符
    3、charAt()获取指定索引位置的字符
    4、获取子字符串： substring(int beginIndex)从索引位置到结尾
                                    substring(int beginIndex,int endIndex)不包括结束位置
    5、去除空格：str.trim()去除首部和尾部空格
    6、字符串替换：str.replace(char oldChar,char newChar)
    7、判断字符串开始结尾：startsWith(),endsWith()返回boolean类型
    8、判断字符串是否相等：equals()--区分大小写，equalsIgnoreCase()--忽略大小写
    9、按字典顺序比较两个字符串：compareTo()--基于字符串中各个字符的Unicode值,相等取0，大于取正，小于取负
    10、字母大小写转换：toLowerCase()-转为小写，toUpperCase()--转为大写
    11、字符串分割：split()--按指定分割字符或字符串进行分割,返回数组
                 split(String sign)--根据给定的分隔符对字符串拆分
                 split(String sign,int limit)--限定拆分的次数
    12、格式化字符串：str.format(String format,Object...args)---format格式字符串，args--引用的参数
          format(Local l,String format,Object...args)---l格式化过程中要应用的语言环境

import java.lang.String;

public class Strings {  //字符串

    public static void main(String[] args) {
        System.out.println("判断字符串是否相等："+ s1.equals(s2));
        System.out.println("获取字符串长度："+s1.lastIndexOf(""));
        System.out.println("获取指定索引位置的字符："+s1.charAt(1));
        System.out.println("获取子字符串："+s1.substring(1,3));
        System.out.println("替换字符串："+s1.replace('o','l'));
        System.out.println("判断开始结尾："+s1.startsWith("g"));
        System.out.println("字典序比较字符串："+s1.compareTo(s2));
        System.out.println("大小写转换："+s1.toUpperCase());
        String sign = "abc,def,ghi,gkl";
        String[] arr = sign.split(",",2);
        System.out.println("字符串分割："+arr[1]);
        StringBuffer bf = new StringBuffer("StringBuilder");
        bf.insert(5,"world");
        System.out.println("字符串生成器："+bf.toString());
        bf.delete(5,10);
        System.out.println("字符串生成器："+bf.toString());
    }


}

三、数组

 一维数组创建：

1、先声明，再用new运算符进行内存分配
     声明：数组元素类型 数字名字[] 、 数组元素类型[] 数组名字；
     分配内存：数组名字 = new 数组元素类型[数组元素的个数];
2、生命的同时为数组分配内存
     数组元素类型 数组名 = new 数组元素类型[数组元素个数]
二维数组创建：

1、先声明，再用new运算符进行内存分配
     声明：数组元素类型 数字名字[][] 、 数组元素类型[][] 数组名字；
     分配内存：数组名字 = new 数组元素类型[数组元素的个数][数组元素的个数]; （直接为每一维度分配）
        数组名字[数组元素的个数]= new 数组元素类型[数组元素的个数]; （分别为每一维度分配）
 2、声明的同时为数组分配内存
      数组元素类型 数组名[数组元素的个数] = new 数组元素类型[数组元素个数]

数组的基本操作：
1、遍历数组：for循环、foreach语句
2、填充替换数组元素：

             Arrays.fill(int[] a,int value)---将指定int值分配给int型数组的每个元素
             fill(int[] a,int fromIndex,int toIndex,int value)
           将指定的int值分配给int型数组指定范围中的每个元素。填充的范围从索引fromIndex(包括)到索引toIndex(不包括）
3、对数组进行排序：Arrays.sort(object)---升序排序
4、复制数组：Array.copyOf(arr,int newLength)--复制数组至指定长度
     Array.copyOfRange(arr,int fromIndex,int toIndex)---将指定数组的指定长度复制到一个新数组中
5、数组查询：binarySearch(Object[],Object key)---如果key包含在数组中，则返回搜索值的索引，否则返回-1或‘-’（插入点）
                 （插入点：是要插入数组的那一点，即第一个大于此键的元素索引）
     binarySearch(Object[]a,int fromIndex,int toIndex,Object key)---在指定的范围内检索某一元素,指定范围应小于数组长度

6、数组排序算法：
        冒泡排序：对比相邻的元素值，如果满足条件就交换元素值，把较小的元素移动到数组前面，把大的元素移动到数组后面（也就是交换两个元素的位置）这样较小的元素像气泡一样从底部上升到顶部。
        直接选择排序：将指定元素位置与其他数组元素分别对比，如果满足条件就交换元素值（将满足条件的元素与指定的排序位置交换），每一趟从待排序的数据中选出最小（最大）的一个元素
        反转排序：对数组两边进行替换，所以只需要循环数组长度的半次数

import java.util.Arrays;

public class Arr {   //数组

    public static void main(String[] args) {
        //创建一维数组
        int arr[];
        arr = new int[5];  //创建1
        int month[] = new int[5];  //创建2
        System.out.println(arr.length);
        //初始化一维数组
        int arr2[] = new int[]{1,2,3,4,5}; //初始化方式1
        int arr3[] = {1,2,3,4,5}; //初始化方式2

        //创建二维数组
        int arr4[][]; //声明
        arr4 = new int[2][5]; //分配内存（直接为每维分配）
        int[][] arr5; //声明
        arr5 = new int[2][]; //分配内存(分别为每维分配内存）
        arr5[0] = new int[2];
        arr5[1] = new int[3];
        // 初始化二维数组
        int myarr[][] = {
   
   {1,2},{3,4}};
        int a[][] = new int[2][2];
        a[1][1] = 20;
        System.out.println(a[1][1]);

     
        int b[][] = new int[][]{
   
   {1},{2,3},{4,5,6}};
        //for循环
        for(int i=0;i<b.length;i++){
            for(int j=0;j<b[i].length;j++){
                System.out.println(b[i][j]); //将数组中的元素输出
            }
        }
        System.out.println();
        //foreach
        for(int x[]:b){
            for(int e:x){
                System.out.println(e);
            }
        }
        //填充替换数组元素
        int aa[] = new int[]{1,2,3,5};
        System.out.println();
        Arrays.fill(aa,9);
        for (int i=0;i<aa.length;i++){
            System.out.println("第"+i+"个元素是："+aa[i]);
        }
        System.out.println();
        Arrays.fill(aa,1,3,8);
        for (int i=0;i<aa.length;i++){
            System.out.println("第"+i+"个元素是："+aa[i]);
        }
        int newArr[]=Arrays.copyOf(aa,6);
        System.out.println("新数组：");
        for (int i=0;i<newArr.length;i++){
            System.out.println("第"+i+"个元素是："+newArr[i]);
        }
        int newArr2[] =Arrays.copyOfRange(aa,1,4);
        System.out.println("新数组：");
        for (int i=0;i<newArr2.length;i++){
            System.out.println("第"+i+"个元素是："+newArr2[i]);
        }

        int array[] = new int[]{4,25,10};
        Arrays.sort(array);
        int index = Arrays.binarySearch(array,0,1,8);
        System.out.println(index); //-2(因为8在数组0~1位置不存在，index的值是‘-’插入点，如果对数组进行排序，8应该在25前面，因此插入点应该是25的索引值2，所以index为-2）


    }
}

public class BubbleSort { //冒泡排序
    public static void main(String[] args) {
        int[] array = {63,4,24,1,3,15};  //创建一个数组，乱序
        BubbleSort sorter = new BubbleSort();//创建冒泡排序类的对象
        sorter.sort(array);//调用排序方法将数组排序

    }
    public void sort(int[] array){
        //每次驯化不能把最大的元素排在后面，下一次循环对数组中其他元素进行类似的操作
        for(int i=1;i<array.length;i++){
            //比较相邻两个元素，较大的数往后冒泡
            for(int j=0;j<array.length-i;j++){
                if(array[j]>array[j+1]){  //较小的移动到前面
                    int tmp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = tmp;
                }
            }
        }
        //输出排序后的数组
        for(int i:array){
            System.out.println(i);
        }
    }
}

public class SelectSort { //直接选择排序
    public static void main(String[] args) {
        int[] array = {63,4,24,1,3,15};  //创建一个数组，乱序
        SelectSort sorter = new SelectSort();//创建直接排序类的对象
        sorter.sort(array);//调用排序方法将数组排序
    }
    public void sort(int[] array){
        int index;
        for(int i=1;i<array.length;i++){
            index = 0;
            for(int j=1;j<=array.length-i;j++){
                if(array[j]>array[index]){
                    index = j;
                }
            }
            //交换在位置array.length-i和index（最大值）上的两个数
            int tmp = array[array.length-i];
            array[array.length-i] = array[index];
            array[index] =tmp;

        }
        //输出排序后的数组
        for(int i:array){
            System.out.println(i);
        }
    }
}

public class ReverseSort { //反转排序
    public static void main(String[] args) {
        int[] array = {63,4,24,1,3,15};  //创建一个数组，乱序
        ReverseSort sorter = new ReverseSort();//创建反转排序类的对象
        sorter.sort(array);//调用排序方法将数组排序
    }
    public void sort(int[] array){
        System.out.println("数组原有内容：");
        //输出排序前数组值
        for(int i:array){
            System.out.println(i);
        }
        int tmp;
        int len = array.length;
        for(int i=0;i<len/2;i++){
            tmp = array[i];
            array[i] = array[len-1-i];
            array[len-1-i] = tmp;
        }
        System.out.println("反转后的数组内容：");
        //输出排序后的数组
        for(int i:array){
            System.out.println(i);
        }
    }
}

四、类和对象

类

概念：类是同一类事物的统称，如果将现实世界中的一个事物抽象成对象，类就是 这类对象的统称。

类是封装对象的属性和行为的载体，也就是说具有相同属性和行为的一类实体被称为类。

Java语言中，类中对象的行为是以方法的形式定义的，对象的属性是以成员变量的形式定义的，而类中包括对象的属性和方法。

类和对象的关系

类实质就是封装对象属性和行为的载体，而对象则是类抽象出来的实例。

面向对象的三大特征是什么？

面向对象的程序设计方法具有三个基本特征：封装、继承、多态。

• 封装：指的是将对象的属性和方法封装起来，其载体就是类，类通常将对象的实现细节隐藏起来，然后通过一些公用方法来暴露该对象的功能；(避免外部操作对内部数据的影响，提高程序的可维护性)

• 继承：是面向对象实现软件复用的重要手段，当子类继承父类后，子类作为一种特殊的父类，将直接获得父类的属性和方法；

• 多态：指的是子类对象可以直接赋给父类变量，但运行时依然表现出子类的行为特征，这意味着同一个类型的对象在执行同一个方法时，可能表现出多种行为特征。

扩展阅读

抽象也是面向对象的重要部分，抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是考虑部分问题。例如，需要考察Person对象时，不可能在程序中把Person的所有细节都定义出来，通常只能定义Person的部分数据、部分行为特征，而这些数据、行为特征是软件系统所关心的部分。

权限修饰符

Java语言为我们提供了三种访问修饰符，即private、protected、public，在使用这些修饰符修饰目标时，一共可以形成四种访问权限，即private、default、protected、public，注意在不加任何修饰符时为default访问权限。

在修饰成员变量/成员方法时，该成员的四种访问权限的含义如下：

• private：该成员只能被该类内部成员访问；

• default：该成员可以被该类内部成员访问，也可以被同一包下其他的类访问；

• protected：该成员可以被该类内部成员访问，也可以被同一包下其他的类访问，还可以被它的子类访问；

• public：该成员可以被任意包下，任意类的成员进行访问。

在修饰类时，该类只有两种访问权限，对应的访问权限的含义如下：

• default：该类可以被同一包下其他的类访问；

• public：该类可以被任意包下，任意的类所访问。

public和protected修饰的类可以由子类访问，如果子类和父类不在同一包中，那么只有修饰符为public的类可以被子类进行访问。

类的构造方法

构造方法：在变量赋值，这样实例化一个本类的对象时，相应的成员变量也将被初始化 如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法类中除了成员方法之外的一种特殊类型的方法，构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的 每当类实例化一个对象时，类都会自动调用构造方法。 特点：构造方法没有返回值、构造方法的名称要出本类的名称相同 在构造方法中可以为成员变量赋值，这样实例化一个本类的对象时，相应的成员变量也将被初始化 如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法

//定义无参构造方法
public Lei(){   //public-构造方法修饰符，Lei--构造方法的名称
    //构造方法体
    this("this调用有参构造方法"); //使用this调用有参构造方法
    //在无参构造方法中可以使用this调用有参构造方法，但只可以在无参构造方法的第一句使用this调用
    System.out.println("无参构造方法");
}
//定义有参构造方法
public Lei(String name){
    System.out.println("有参构造方法");
}

public class Lei {   //类
    //Java语言中类中对象的属性以成员变量的形式存在，对象的方法以成员方法的形式存在

    //如果在执行类时，希望先执行类的初始化动作，可以先定义一个静态区域，当代码执行时，首先执行static块中的程序，并且只会执行一次
    static{
        //some
    }

    private String name; //定义一个String型的成员变量

    public String getName(){ //定义一个getName()方法
         int id =0;
         setName("Java");  //调用类中其他方法00
         return id+this.name;  //设置方法返回值
    }

    private void setName(String name){ //定义一个setName()方法
        //this关键字代表本类对象的引用
        this.name = name; //将参数值赋予类中的成员变量

    }

    public Lei getBook(){
        return this; //返回Book类引用
    }

     /*
        构造方法：在类中除了成员方法之外的一种特殊类型的方法，构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的
                每当类实例化一个对象时，类都会自动调用构造方法。
        特点：构造方法没有返回值、构造方法的名称要出本类的名称相同
        在构造方法中可以为成员变量赋值，这样实例化一个本类的对象时，相应的成员变量也将被初始化
        如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法
         */
     //定义无参构造方法
     public Lei(){   //public-构造方法修饰符，Lei--构造方法的名称
         //构造方法体
         this("this调用有参构造方法"); //使用this调用有参构造方法
         //在无参构造方法中可以使用this调用有参构造方法，但只可以在无参构造方法的第一句使用this调用
         System.out.println("无参构造方法");
     }
    //定义有参构造方法
    public Lei(String name){
        System.out.println("有参构造方法");
    }


    // 被声明为static的变量、常量和方法被称为静态成员。
    // 静态成员属于类所有，区别于个别对象，可以在本类或其他类使用类名和'.'运算符调用静态成员
    //java语言的两点规定：在静态方法中不可以使用this关键字、在静态方法中不可以直接调用非静态方法、在方法体类的局部变量不能被声明为static

    static  double PI = 3.1415;  //在类中定义静态常量
    static int id; //在类中定义静态变量
    public static void method(){  //在类中定义静态方法
        System.out.println("调用了静态方法");
    }

    //类的主方法
    /*特性：主方法是静态的，如果要直接在主方法中调用其他方法，则该方法必须也是静态的；主方法没有返回值；主方法的形参为数组。
           其中args[0]~args[n]分别表示程序的第一个参数到第n个参数，可以使用args.length获取参数的个数

     */
    public static void main(String[] args) {
        //方法体
        for(int i=0;i<args.length;i++){
            System.out.println(args[i]);  //循环打印参数内容
        }
        System.out.println(Lei.PI);  //调用静态常量
        System.out.println(Lei.id=1);  //调用静态变量
        Lei.method();  //调用静态方法
    }


}

public class Object {  //对象
    //对象可以认为是一类事物中抽象出来的某一个特例，可以通过这个特例来处理这类事物出现的问题
    //JAVA语言中使用new操作符调用构造方法创建对象

    public Object(){  //构造方法
        System.out.println("创建对象");
    }
    //访问对象的属性和方法：使用new操作符创建一个对象后，可以使用“对象.类成员”来获取对象的属性和行为。
    int i =47;  //定义成员变量(如果希望成员变量不被任何一个对象改变，可以使用static关键字）
    public void  call(){  //定义成员方法
        System.out.println("调用call方法");
        for(i=0;i<3;i++){
            System.out.println(i);
            if(i==2){
                System.out.println("--");
            }
        }
    }
    //对象的引用：类名 对象引用名称---例：Book book;引用只是存放一个对象的内存地址，并非存放一个对象

    public static void main(String[] args) {
        new Object(); //创建对象，调用构造函数方法
        Object o1 = new Object();//创建一个对象
        Object o2 = new Object();//创建另一个对象
        o2.i = 60;   //将类成员变量赋值为60
        //使用对象调用类成员变量
        System.out.println("对象1调用变量i的结果："+o1.i++);
        o1.call();  //调用类成员方法
        System.out.println("对象2调用成员变量i的结果："+o2.i);
        o2.call();

        //对象的比较
        String c1 = new String("abs");  //创建两个String型对象
        String c2 = new String("abs");
        String c3 = c1;  //将c1对象引用赋予c3

        System.out.println("c2==c3运算结果："+(c2==c3));  //使用==比较的是两个对象的引用地址是否相同--false
        System.out.println("c2.equals(c3)运算结果："+(c2.equals(c2)));  //使用equals比较的是两个对象引用所指向的内容是否相等--true
        System.out.println("c1==c3运算结果："+(c3==c1));  //true,c3和c1共享相同的引用地址
    }
}

五、包装类

1、Integer类

构造方法----------Integer(int number)方法以一个int型变量作为参数获取Integer对象
                       ---Integer(String str)方法以一个String型变量作为参数来获取Integer对象
常用方法---------byteValue() 以byte类型返回该Integer的值
                      ---compareTo(Integer anotherInteger) 在数值上比较两个Integer对象
                      ---equals(Object IntegerObj) 比较此对象与指定对象是否相等
                      ---intValue() 以int型返回此Integer对象
                      ---shortValue() 以short型返回此Integer对象
                      ---toString() 返回一个表示该Integer值的String对象
                      ---valueOf(String str) 返回保存指定的String值的Integer对象
                      ---parseInt(String str) 返回包含在由str指定的字符串中的数字等价的整数值
常量-----------MAX_VALUE 表示int型可取的最大值2^31-1
                      MIN_VALUE 表示int型可取的最小值-2^31
                      SIZE 表示以二进制补码形式表示int值的位数
                      TYPE 表示基本类型int的Class实例

2、Boolean类

Boolean类将基本类型boolean的值包装在一个对象中，一个Boolean类型的对象只包含一个类型为boolean的字段
 构造方法：Boolean(boolean value)---创建一个表示value参数的Boolean对象(true/false)
                Boolean(String str) ---以String变量作为参数创建Boolean对象。若String忽略大小写为                   true则创建一个值为true的Boolean对象，否则获得一个false值的Boolean对象
常用方法：booleanValue() 将Boolean对象的值以对应的boolean值返回
                equals(Object obj) 判断调用该方法的对象与obj是否相等
                parseBoolean() 将字符串参数解析为boolean值
                toString() 返回表示该boolean值的String对象
                valueOf(String s)  返回一个用指定的字符串表示值的boolean值
常量：TRUE FALSE TYPE(基本类型boolean的class对象）

3、Byte类

 Byte类将基本类型为byte的值包装在一个对象中，一个Byte类型的对象只包含一个类型为byte的字段
构造方法：Byte(byte value)  创建一个Byte对象，可表示指定的byte值
                Byte(String str)  创建一个Byte对象，可表示String参数（数值型）所指示的byte值
常用方法：byteValue() 将Byte对象的值以对应的byte值返回
                compareTo(Byte anotherByte) 在数值上比较两个Byte对象
                doubleValue()  以一个double值返回此Byte对象的值
                intValue()  以一个int值返回此Byte的值
                equals(Object obj) 判断调用该方法的对象与obj是否相等
                parseByte(String s) 将字符串参数解析为等价的字节（byte)形式
                toString() 返回表示该boolean值的Byte对象
                valueOf(String s)  返回一个用指定的字符串表示值的Byte对象
 常量：MIN_VALUE byte类型可取的最小值
              MAX_VALUE byte类型可取的最大值
              SIZE 表示以二进制补码形式表示byte值的位数
              TYPE 表示基本类型byte的Class实例

4、 Character类

构造方法：Character(char value)
常用方法：compareTo(Character anotherCharacter) 根据数字比较两个Character对象，相等则返回0
                equals(Object obj) 判断调用该方法的对象与obj是否相等
                toUpperCase(char ch) 将字符参数转换为大写
                toLowerCase(char ch) 将字符参数转换为小写
                toString() 返回一个表示指定char值的String对象
                charValue() 返回此Character对象的值
                isUpperCase(char ch) 判断指定字符是否是大写字母
                isLowerCase(char ch) 判断指定字符是否是小写字母

5、Double和Float包装类

 Double和Float包装类是对double,float基本类型的封装，它们都是Number类的子类
        Double 构造方法：Double(double value) 、 Double(String str)
        常用方法：byteValue() 以byte形式返回Double对象值
                compareTo(Double d) 根据数字比较两个Double对象，相等则返回0
                equals(Object obj) 判断调用该方法的对象与obj是否相等
                intValue() 以int形式返回double值
                isNaN() 判断此double是否是非数字（NaN）类型
                toString() 返回此Double对象的字符串表示形式
                doubleValue() 以double形式返回此Double对象
                longValue() 以long形式返回此double值（强制转换）
        常量：MAX_EXPONENT  返回int值表示有限double变量可能具有有的最大指数
             MIN_EXPONENT  返回int值表示标准化double变量可能具有的最小指数
             NEGATIVE_INFINITY 返回double值，表示保存double类型的负无穷大值的常量
             POSITIVE_INFINITY 返回double值表示保存double类型的正无穷大值的常量

public class PackageClass {  //包装类

    public static void main(String[] args) {
        Integer number = new Integer(7);
        Integer number2 = new Integer("45"); //要用数值型String变量，否则抛出异常
        System.out.println(number2);
        String str[] = {"89", "12", "10", "18", "35"}; //定义String型数组
        for (String i : str) {
            int myint = Integer.parseInt(i); //将数组中的每个元素都转换为int型
            System.out.println(myint);   //输出

        }
        System.out.println("shortValue方法：" + number.shortValue());
        System.out.println("valueOf方法：" + Integer.valueOf("666"));
        //Integer类的toString方法可将对象转换为十进制字符串，toBinaryString()和toHexString()以及toOctalString()分别将值转换为二进制、十六进制和八进制
        String str1 = Integer.toString(456);
        String str2 = Integer.toBinaryString(456);
        String str3 = Integer.toHexString(456);
        String str4 = Integer.toOctalString(456);
        System.out.println("456的十进制表示：" + str1);
        System.out.println("456的二进制表示：" + str2);
        System.out.println("456的十六进制表示：" + str3);
        System.out.println("456的八进制表示：" + str4);

        System.out.println("int型可取的最大值：" + Integer.MAX_VALUE);
        System.out.println("int型可取的最小值：" + Integer.MIN_VALUE);
        System.out.println("int型的二进制位数：" + Integer.SIZE);
        System.out.println("int型的class实例：" + Integer.TYPE);


        Boolean b = new Boolean(true);
        Boolean bool = new Boolean("ok");
        System.out.println("value创建Boolean："+b);
        System.out.println("string创建Boolean："+bool);
        System.out.println("将Boolean对象的值以对应的boolean值返回："+b.booleanValue());
        System.out.println("将Boolean对象的值以对应的boolean值返回："+bool.booleanValue());
        System.out.println("将字符串参数解析为boolean值:"+Boolean.parseBoolean("TRuE")); //忽略大小写
        System.out.println("返回一个用指定的字符串表示值的boolean值:"+Boolean.valueOf("ok"));
        System.out.println("基值为true的boolean对象："+Boolean.TRUE);
        System.out.println("基值为false的boolean对象："+Boolean.FALSE);
        System.out.println("boolean的class类："+Boolean.TYPE);

        /*
       
         */
        byte mybyte = 45;
        Byte bit = new Byte(mybyte);  //value构造法
        Byte bit2 = new Byte("12");  //字符串构造法
        System.out.println(bit);
        System.out.println(bit2);
        System.out.println(Byte.valueOf("12"));
        System.out.println(bit2.equals(Byte.parseByte("12")));
        System.out.println(Byte.MAX_VALUE);  //127
        System.out.println(Byte.MIN_VALUE);  //-128
        System.out.println(Byte.SIZE);    //8位
        System.out.println(Byte.TYPE);

        /*
       
         */
        Character c = new Character('a');
        System.out.println(c.charValue());
        System.out.println(Character.isUpperCase('c'));
        System.out.println(Character.toString('c'));

        /*
       
         */

        Double d = new Double(1);
        System.out.println(d);
        System.out.println(d.longValue());
        System.out.println(Double.valueOf("1.2222"));
        System.out.println(Double.MAX_EXPONENT);
        System.out.println(Double.MIN_EXPONENT);
        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);

        /*
        抽象类Number是BigDecimal、BigInteger、Byte、Double、Float、Integer、Long、Short类的父类
        Number的所有子类包含表示数值转换的方法---byteValue()|intValue()|floatValue()|shortValue()|longValue()|doubleValue()
         */
    }
}

六、数字处理类

数字格式化

Java中使用DecimalFormat类进行格式化，DecimalFormat是NumberFormat的一个子类，用于格式化十进制数字。
DecimalFormat类中的特殊字符说明：

• 0--表示一个阿拉伯数字，如果该位置不存在数字，则用0填充；
• #--表示一个阿拉伯数字，如果该位置不存在数字，则不显示；存在数字则显示字符
• .--表示分隔符或货币小数分隔符
• - 负号
• ， 分组分隔符
• E 分割科学计数法中的尾数和指数
•  % 放置在数字的前缀或后缀，将数字乘以100显示为百分数
•  \u2030 放置在数字的前缀或后缀，将数字乘以1000显示为千分数
• \u00A4 放置在数字的前缀或后缀，作为货币记号
• ‘ 单引号

数学运算

Math类 --- 三角函数方法、指数函数方法、取整函数方法、取最大值、最小值以及平均值函数方法，这些方法都被定义为static形式
使用方法：Math.数学方法（数学常量：PI、E）
三角函数方法：

sin()、cos()、tan()、asin()、acos()、atan()、toRadians()--将角度转换为弧度、toDegrees()--将弧度转换为角度
            返回值都是double类型
 指数函数方法：exp(double a)  e的a次方
                       log(double a)  取自然对数 lna
                       log10(double a) 取底数为10的对数
                       sqrt(double a) a的平方根，a不能为负值
                       cbrt(double a) a的立方根
                       pow(double a,double b) 取a的b次方
 取整函数：

          ceil(double a) 上取整
          floor(double a) 下取整
          rint(double a) 返回与参数最接近的整数，如果两个同为整数且同样接近，则结果取偶数
          int round(float a) 将参数加上0.5后返回与参数最近的整数
          long round(double a) 将参数加上0.5后返回与参数最近的整数，然后强制转换为长整型
最大值、最小值、绝对值：

                max(double a,double b) 取a,b之间最大值
                min(a,b) 取a,b之间最小值，参数为整型、长整型、浮点型或双精度型
                abs(a) 返回整形、长整型、浮点型、双精度型的绝对值
随机数：Math.random()方法  默认产生大于等于0.0小于1.0的double型随机数
               (int)Math.random()*n 返回大于等于0小于n的随机数
               m+(int)Math.random()*n 返回大于等于m小于m+n的随机数
                   (char)('a'+Math.random()*('z'-'a'+1))  生成a~z之间的随机字符
                   (char)(cha1+Math.random()*(cha2-cha1+1))  任意两个字符之间的随机字符

                  Random类---java.util.Random() 通过实例化一个Random对象创建一个随机数生成器
                   Random r = new Random();
                   Random r = new Random(seedValue);  --Random对象，seedValue随机生成器的种子
                   nextInt() 返回一个随机整数
                   nextInt(int n) 返回一个大于等于0小于n的随机整数
                   nextLong() 返回一个随机长整型值
                   nextBoolean()  返回一个随机布尔型值
                   nextFloat()  返回一个随机浮点型值
                   nextDouble()  返回一个随机双精度型值
                   nextGaussian()  返回一个概率密度为高斯分布的双精度值
大数字运算：

java.math.BigInteger（大整数） 和 java.math.BigDecimal（大小数）两个类用于高精度计算

BigInteger类

封装了多种操作 语法--public BigInteger(String val) 参数以字符串形式代表要处理的数字
        使用： BigInteger b = new BigInteger("2"); 将十进制2转换为BigInteger形式
        运算方法： add(BigInteger val)  做加法运算
                 subtract(BigInteger val) 做减法操作
                 multiply(BigInteger val) 做乘法操作
                 divide(BigInteger val)  做除法操作
                 public BigInteger[] divideAndRemainder(BigInteger val)数组返回余数和商，第一个值为商，第二个值为余数
                 pow(int exponent)  取exponent次方操作
                 negate() 取相反数
                 shiftLeft(int n) 将数字左移n位，如果n位负数,做右移操作
                 shiftRight(int n)  将数字右移n位，如果n为负数，做左移操作
                 and(BigInteger val)  做与操作
                 or(BigInteger val) 做或操作
                 compareTo(BigInteger val) 做数字比较操作
                 equals(Object x)  当参数x是BigInteger类型的数字并且相等时，返回true
                 min(BigInteger val)  返回较小的数值
                 max(BigInteger val) 返回较大的数值

BigDecimal类

构造方法： BigDecimal(double val)---实例化双精度型转换为BigDecimal类型
                             BigDecimal(String val)---实例化将字符串形式转换为BigDecimal类型
运算方法： add(BigDecimal augend)  做加法运算
                 subtract(BigDecimal subtrahend) 做减法操作
                 multiply(BigDecimal multiplicand) 做乘法操作
                 divide(BigDecimal divisor,int scale,int roundingMode)  做除法操作,三个参数分别表示除数、商的小数点后的位数、近似处理模式
   处理模式：
           ROUND_UP---- 最后一位如果大于0，向前进位
           ROUND_DOWN --- 商的最后一位无论是什么都省略
           ROUND_CEILING---商如果是正数按ROUND_UP模式，是负数按照ROUND_DOWN模式
           ROUND_FLOOR --- 商如果是负数按ROUND_UP模式，是正数按照ROUND_DOWN模式
           ROUND_HALF_DOWN ---四舍五入，最后一位小于等于5舍弃,大于5进位 例如1.55 保留一位小数结果为1.5
           ROUND_HALF_UP -- 四舍五入，最后一位小于5舍弃，大于等于5进位, 1.55保留一位小数结果为1.6
           ROUND_HALF_EVEN -- 如果商的倒数第二位是奇数，使用ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.Random;

public class DigitalProcessingClass { //数字处理类

    /*
    

     */

    //使用格式化对象时设置格式化模式
    static public void SimgleFormat(String pattern,double value){
        //实例化DecimalFormat对象
        DecimalFormat myFormat = new DecimalFormat(pattern);
        String output = myFormat.format(value);  //将数字进行格式化
        System.out.println(value+""+pattern+""+output);

    }
    //使用applyPattern()方法对数字进行格式化
    static public  void UseApplyPatternMethodFormat(String pattern,double value){
        DecimalFormat myFormat = new DecimalFormat(); //实例化DecimalFormat对象
        myFormat.applyPattern(pattern);  //使用applyPattern方法设置格式化模板
        System.out.println(value+""+pattern+""+myFormat.format(value));
    }

    //产生随机偶数的方法
    public  static  int GetEvenNum(double num1,double num2){
        //产生num1~num2之间的随机数
        int s = (int)num1+(int)(Math.random()*(num2-num1));
        if(s%2==0){
            return s;
        }else{
            return s+1;
        }
    }

    public static void main(String[] args) {
        SimgleFormat("###,###.###",123456.789);  //调用静态方法
        SimgleFormat("00000000.###kg",123456.789);
        //按照格式化模板格式化数字，不存在的位以0显示
        SimgleFormat("00000.000",123.78);

        UseApplyPatternMethodFormat("#.###%",0.789); //将数字转换为百分数形式
        //将小数点后格式化为两位
        UseApplyPatternMethodFormat("###.##",123456.789);
        //将数字转换为千分数形式
        UseApplyPatternMethodFormat("0.00\u2030",0.789);

        DecimalFormat myFormat = new DecimalFormat(); //实例化DecimalFormat对象
        myFormat.setGroupingSize(2);  //设置将数字分组的大小
        String output = myFormat.format(123456.789);  //12,34,56.789
        System.out.println("将数字以每两个数字分组："+output);
        myFormat.setGroupingUsed(false); //设置是否支持分组
        String output2 = myFormat.format(123456.789); //123456.789
        System.out.println("不允许分组："+output2);

        System.out.println("90度的正弦值："+Math.sin(Math.PI/2));
        System.out.println("0度的余弦值："+Math.cos(0));
        System.out.println("60度的正切值："+Math.tan(Math.PI/3));
        System.out.println("2的平方根与2商的反弦值："+Math.asin(Math.sqrt(2)/2));
        System.out.println("2的平方根与2商的反余弦值："+Math.acos(Math.sqrt(2)/2));
        System.out.println("1的反正切值："+Math.atan(1));
        System.out.println("120度的弧度值："+Math.toRadians(120.0));
        System.out.println("pi/2的角度值："+Math.toDegrees(Math.PI/2));
        System.out.println("e的平方值："+Math.exp(2));
        System.out.println("以e为底2的对数值："+Math.log(2));
        System.out.println("以10为底2的对数值："+Math.log10(2));
        System.out.println("4的平方根："+Math.sqrt(4));
        System.out.println("8的立方根："+Math.cbrt(8));
        System.out.println("2的2次方："+Math.pow(2,2));
        System.out.println(Math.round(3.4f));  //3
        System.out.println(Math.round(2.5)); //3

        System.out.println("任意一个2~32之间的偶数："+GetEvenNum(2,32));
        //生成a~z之间的随机字符
        char c = (char)('a'+Math.random()*('z'-'a'+1));
        System.out.println("随机字符："+c);

        Random r = new Random();  //实例化一个Random类
        //随机产生一个整数
        System.out.println("随机产生一个整数："+r.nextInt());
        System.out.println("随机产生一个大于等于0小于10的整数："+r.nextInt(10));
        System.out.println("随机产生一个布尔值："+r.nextBoolean());
        System.out.println("随机产生一个双精度型值："+r.nextDouble());
        System.out.println("随机产生一个浮点数："+r.nextFloat());
        System.out.println("随机产生一个概率密度为高斯分布的双精度值："+r.nextGaussian());

        BigInteger big = new BigInteger("4"); //实例化一个大数字
        System.out.println("加法操作："+big.add(new BigInteger("2")));
        System.out.println("减法操作："+big.subtract(new BigInteger("1")));
        System.out.println("乘法操作："+big.multiply(new BigInteger("5")));

        System.out.println("余数和商："+big.divideAndRemainder(new BigInteger("3"))[0]);

        BigDecimal bigD1 = new BigDecimal("-7.5");
        BigDecimal bigD2 = new BigDecimal("8.9");
        System.out.println("加法操作："+bigD1.add(bigD2));
        System.out.println("减法操作："+bigD1.subtract(bigD2));
        System.out.println("乘法操作："+bigD1.multiply(bigD2));
        System.out.println("除法操作："+bigD1.divide(bigD2,5,BigDecimal.ROUND_HALF_UP));


    }
}