20189200余超 2018-2019-2 移动平台应用开发实践第三周作业
2018-2019-2 移动平台应用开发实践第三周作业
核心类
基本类型的封装类
- 封装类： 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中推荐放在数组名前。数组定义后还不能对数组进行访问，因为定义中只是声明了数组的类型和数组名，想要真正让数组发挥作用还需要对数组进行初始化，为当前数组分配内存空间。
数组的初始化
数组的初始化分为静态初始化和动态初始化两种。
1.动态初始化
动态初始化中需要给数组指定一个长度，语法格式为：
//先定义再初始化.
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.静态初始化
静态初始化中需要给定数组中的元素的值，由系统计算数组的长度。语法格式为:
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
