20189200余超 2018-2019-2 移动平台应用开发实践第三周做业

时间 2019-12-14

标签移动平台应用开发实践第三栏目无线繁體版

原文原文链接

2018-2019-2 移动平台应用开发实践第三周做业

核心类

基本类型的封装类java

封装类： java语言认为一切皆对象。8个基本数据类型野应该具有对应的对象。经过封装类能够把8个基本类型的值封装对象进行使用。从JDK1.5开始，java容许把基本类型的值直接赋值给对应的封装类对象。
封装类的实例： int a=10； Integer o=new Integer（10）； 8个数据类型的封装类只有int 和char的封装类会改变，Integer 和Character
封装类的做用：
a.将字符串的值转换为基本类型。int a=new Integer(“100”);
b.基本类型的值转换成字符串。int a=10； String c=a+“ ”；或者 String b =Integer.toString(100);
---
装箱和拆箱
1.装箱和拆箱 →本质是基本类型和其封装类之间能自动进行转换
定义：装箱指的是把基本数据类型值转换成封装对象，即把栈中的数据封装成对象存放到堆中的过程。拆箱是装箱的反过程。装箱操做是数据由栈道堆，拆箱是数据由堆到栈
---
Object
1.object对象类定义在java.lang包中，是因此类的顶级父类，在java体系中，全部类都直接或者间接的继承了object类，因此，任何java对象均可以调用object类中的方法，并且任何类型的对象均可以赋给object类型的变量。
2.equals（）方法：判断指定的对象和传入的对象是否相等。
toString（）方法：返回当前对象的字符串表示。
”==“和equals（）二者比较，前者比较的地址是否相对，便是否同一个对象，后者比较的是值是否相等
toString（）方法要输出对象的详细信息时，须要对toString（）方法进行重写，不然会输出表明对象信息的表示字符串。 toString（）方法没有参数，可直接返回值须要的信息内容。如，return this.name；
两个引用类型的对象的比较是否相等有两种方式：
a.“==”运算符表示的是两个对象的地址是否相同，即引用的是同一个对象。
b.equals（）方法一般用于比较两个对象的内容是否相同

---
字符串类
1.String类（字符串常量）→subString是截取字符串的方法。length是字符串长度的方法。int compare（String s）是比较两个字符串的大小，相等返回0，不相等返回不相等字符编码值的差。
2.StringBuffer类（字符串能够改变，线程安全）→append（String str）在字符串末尾追加一个字符串。char charAt（int index）返回指定下标的字符。intcapacity（）表示返回字符串缓冲区容量。
3.StringBuilder类（字符串能够改变，线程不安全，所以性能比 StringBuffer 好）
要点：StringBuffer是线程同步的，StringBuilder是异步；对不常常变化的字符串使用String便可。常常变化、正在拼装的字符串不用String。如果全局变量，可能多线程引用，使用StringBuffer；如果局部变量，单线程使用，推荐StringBuilder
---
Scanner类和Math和Date类
Scanner类是用于接收用户的键盘输入，和对字符串的格式化处理。
写法：Scanner s=new Scanner（System.in）； String s1=s.next（）；
1.用做数学运算的类是Math。 Math.random（）；获取一个随机数。
2.用做日期处理的类是Date。示例：Date dateNow=new Dtae（）；获得当前的日期。数组

数组

数组的基本概念
数组是储存多个相同类型的元素，虽然数组中的元素均为基本元素,可是Java中使用了相似对象的处理方式处理数组。在数组的初始化中使用new进行初始化。
建立一个一维数组
定义数组的方式为:安全

数组元素类型 [ ]数组名;以下实例：多线程
```
int arr1[];     //定义一个int类型的数组
int []arr2;
String []arr3;          //定义一个String类型的数组
char []arr4;            //定义一个字符类型数组
boolean []arr5;         //定义一个boolean类型数组
```
数组定义中中括号[ ]能够在数组名的前面或者后面,表达式效果相同，Java中推荐放在数组名前。数组定义后还不能对数组进行访问，由于定义中只是声明了数组的类型和数组名，想要真正让数组发挥做用还须要对数组进行初始化，为当前数组分配内存空间。app

数组的初始化
数组的初始化分为静态初始化和动态初始化两种。
1.动态初始化
动态初始化中须要给数组指定一个长度，语法格式为：dom

//先定义再初始化.
    int []arr1;         
    arr1=new int[6];
//定义和初始化一块儿执行.
    int []arr2=new int [5];

动态初始化中只需给定一个数组长度，系统会默认给当前数组中的元素提供一个默认值。默认值随数组类型给出，好比：异步

int []arr1=new int[5];
System.out.println(arr1[2]);
    //此时会输出 0
String []arr2=new String[3];
System.out.println(arr2[2]);
    //此时会输出 null
boolean []arr3=new boolean[4];
System.out.println(arr3[2]);
    //此时会输出 false

2.静态初始化
静态初始化中须要给定数组中的元素的值，由系统计算数组的长度。语法格式为:ide

int []arr=new int[]{1,2,3,4,5};
int []arr2={3,4,5,6};

数组的遍历
1.for循环遍历工具

public class TextDemo {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        out(arr);
    }
 
    public static void out(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
    }
}
//输出结果为[1, 2, 3, 4, 5, 6, 7, 8, 9]

2.使用Arrays类中的toString方法遍历数组,此方法能够将数组转化成字符串遍历输出,该方法为静态方法使用类名调用。性能

import java.util.Arrays;//须要导包
public class arr {
    public static void main(String[] args) {
        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        System.out.println(Arrays.toString(arr));
        int[][] arr2 = { { 1, 2, 3 }, { 4, 5, 6 } };
        System.out.println(Arrays.toString(arr2[0]));
        System.out.println(Arrays.toString(arr2[1]));
    }
}
/**输出为：
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 2, 3]
[4, 5, 6]
 */

3.使用StringBuffer中的append方法

public class buffer {
    public static void main(String[] args) {
        int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
        StringBuffer a = new StringBuffer("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                a.append(arr[i]+"]");
            } else {
                a.append(arr[i]+", ");
            }
        }
        System.out.println(a);//[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    }
}

public class TextDemo {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        out(arr);
        reversed(arr);
        out(arr);
    }
 
    public static void reversed(int[] arr) {
        //数组逆序排列
        for(int i=0;i<=arr.length/2;i++) {
            int temp=arr[i];
            arr[i]=arr[arr.length-1-i];
            arr[arr.length-1-i]=temp;
        }
        
    }
    public static void out(int[] arr) {
        //打印数组
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
    }
}
/**输出为：
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 1]
*/

数组的查找

import java.util.Scanner;
public class TextDemo {
    public static void main(String[] args) {
        int[] arr = { 1, 2, 3, 4, 5, 4, 3, 2, 1 };
        find(arr);
    }
    public static void find(int[] arr) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入要查询的数:");
        int a = sc.nextInt();
        int j = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == a) {
                System.out.println("该元素在当前数组的第" + (i+1) + "位。");
                j++;
            }
        }
        if (j == 0) {
            System.out.println("该元素不在当前数组中。");
        }
    }

数组的排序
冒泡排序法

import java.util.Arrays; 
public class Arr {
    public static void main(String[] args) {
        int[] arr = { 2, 5, 6, 9, 1, 3, 8, 4, 10, 7 };
        System.out.println(Arrays.toString(arr)); // Arrays.toString方法遍历数组
        for (int i = 0; i < arr.length; i++) { // 控制循环排序次数,一共进行数组长度-1次
            for (int j = 0; j < arr.length - 1 - i; j++) { // 依次对比将大的交换到最后，每遍历过一次后比较的次数-1
                //注意由于有arr[j + 1]，因此j的取值只能取到数组长度-1次，否则会超出范围
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
// [2, 5, 6, 9, 1, 3, 8, 4, 10, 7]
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Arrays工具类

toString():将数组转化为字符串，有多个重载方法，能够支持boolean、float、int、long、short对象数组。
sort():将数组升序排列，是一个改进的快速排序，比起传统的冒泡，选择排序速度更快。
** binarySearch(int[] a,int key)**

import java.util.Arrays;
//使用Arrays工具类须要导包。
public class test {
    public static void main(String[] args) {
 
        int arr[] = { 5, 4, 8, 9, 6, 7, 1, 2, 3 };
        // 遍历数组
        System.out.println(Arrays.toString(arr));// [5, 4, 8, 9, 6, 7, 1, 2, 3]
        // 数组升序排列
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
        // 查找4在当前数组中的位置，使用二分法查找
        System.out.println(Arrays.binarySearch(arr, 4));
 
    }
 
}

错误处理

捕获异常
使用 try 和 catch 关键字能够捕获异常。try/catch 代码块放在异常可能发生的地方。try/catch代码块中的代码称为保护代码，使用 try/catch 的语法以下：

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

Catch 语句包含要捕获异常类型的声明。当保护代码块中发生一个异常时，try 后面的 catch 块就会被检查。若是发生的异常包含在 catch 块中，异常会被传递到该 catch 块，这和传递一个参数到方法是同样。

多重捕获块
一个 try 代码块后面跟随多个 catch 代码块的状况就叫多重捕获。多重捕获块的语法以下所示：

try{
   // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}

上面的代码段包含了 3 个 catch块。能够在 try 语句后面添加任意数量的 catch 块。若是保护代码中发生异常，异常被抛给第一个 catch 块。若是抛出异常的数据类型与 ExceptionType1 匹配，它在这里就会被捕获。若是不匹配，它会被传递给第二个 catch 块。如此，直到异常被捕获或者经过全部的。
catch 块

Exception 类的层次
1.全部的异常类是从 java.lang.Exception 类继承的子类。
2.Exception 类是 Throwable 类的子类。除了Exception类外，Throwable还有一个子类Error 。
3.Java 程序一般不捕获错误。错误通常发生在严重故障时，它们在Java程序处理的范畴以外。
4.Error 用来指示运行时环境发生的错误。
5.例如，JVM 内存溢出。通常地，程序不会从错误中恢复。异常类有两个主要的子类：IOException 类和 RuntimeException 类。

操做数字

Math类
Math就是一个专门进行数学计算的操做类，里面提供了一系列的数学计算方法。
在Math类里面提供的一切方法都是static型的方法，由于Math类里面没有普通属性。

Math有一个方法要引发注意：
四舍五入：public static long round(double a)。

Random类
这个类的主要功能是取得随机数的操做类。

public class TestDemo {
    public static void main(String args[]) {
        Random rand = new Random();
        for(int i = 0; i < 10; i++) {
            System.out.print(rand.nextInt(100) + "、");
        }
    }
}

大浮点数操做类：BigDecimal
BigInteger 不可以保存小数，而BigDecimal能够保存小数数据。在BigDecimal里提供有以下几种构造：

构造一：public BigDecimal(String val)。
构造二：public BigDecimal(double val)。

与BigInteger同样，BigDecimal自己也支持基础的数学计算，但是使用BigDecimal还有一个很是重要的目的，就是可使用它来实现准确的四舍五入操做。

以前使用的Math.round()实现四舍五入操做，可是这种操做有一个问题，全部的小数位都四舍五入了。
遗憾的是BigDecimal类里面没有直接提供有四舍五入的操做支持，但是能够利用除法实现：

除法操做：public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)。
BigDecimal divisor：被除数。
int scale：保留的小数位。
int roundingMode：进位模式（public static final int ROUND_HALF_UP）。

public class MyMath {
    /**
     * 实现准确位数的四舍五入操做
     * @param num 要进行四舍五入操做的数字
     * @param scale 要保留的小数位
     * @return 处理后的四舍五入数据
     */
    public static double round(double num, int scale) {
        BigDecimal bigA = new BigDecimal(num);
        BigDecimal bigB = new BigDecimal(1);
        return bigA.divide(bigB, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }
}

public class TestDemo {
    public static void main(String args[]) {
        System.out.println(MyMath.round(19.783231231, 2));
        System.out.println(MyMath.round(-15.5, 0));
        System.out.println(MyMath.round(15.5, 0));
    }
}

结果：
19.78
-16
16