Java基础(九）——Arrays类、Math类和继承 Arrays类 Math类 概述 继承
概述
javajava.util.Arrays 此类主要是用来操作数组，里面提供了很多的操作的api方法，如【排序】和【搜索】功能。其所有的方法均为静态方法，调用起来非常简单
操作数组的方法
- public static String toString(int[] arr)：返回指定数组内容的字符串表示形式。
1 public static void main(String[] args) { 2 // 初始化一个int类型的数组 动态初始化只指定长度，不指定内容，而静态初始化只指定内容，不指定长度，两者不能混合使用。 3 int[] arr = {12,345,112,78,489}; 4 // 打印数组，输出内存地址值 5 System.out.println(arr);// 地址值 6 // 把数组内容转换成字符串 7 String str = Arrays.toString(arr); 8 // 打印字符串，输出数组内容 9 System.out.println(str);// [12,345,112,78,489] 内容顺序不变 10 }
- public static void sort(int[] arr)：对指定的int数组按照数字升序进行排序。从小到大
1 public static void main(String[] args) { 2 // 定义一个int类型数组 3 int[] arr = {12,345,112,78,489}; 4 //输出排序前的内容 5 System.out.println(Arrays.toString(arr));// 排序前 [12,345,112,78,489] 6 // 升序排序 7 Arrays.sort(arr); 8 System.out.println(Arrays.toString(arr));// 排序后 [12,78,112,345,489] 9 }
练习：使用Arrays相关的api方法，将一个任意给定的字符串中的所有字符按照升序排序，倒序打印输出。
1 public class ArraysDemo01 { 2 public static void main(String[] args) { 3 // 定义一个任意字符串 4 String str = "asdhfkjadhfs2342354234kjhkljhkj"; 5 // 把字符串转换成字符数组 6 char[] chs = str.toCharArray(); 7 // 使用Arrays类中的sort()方法 8 Arrays.sort(chs); 9 // 倒序打印输出 10 // 反向遍历 11 for (int i = chs.length-1; i >= 0 ; i--) { 12 System.out.print(chs[i] + " "); 13 } 14 } 15 }
- 使用binarySearch()方法。搜索数组当中的元素时，数组必须是有序的。【升序】得到的索引值是排序之后的新的数组的索引值。
1 public static void main(String[] args) { 2 // 定义一个int类型的数组 3 int[] arr = {10,20,5,30,40,15,18}; 4 // 对arr数组进行排序 5 Arrays.sort(arr); 6 // 搜索5这个数值在arr数组当中的索引值 7 int index = Arrays.binarySearch(arr,5); 8 // 打印输出index的值 9 System.out.println("5在arr数组当中的索引值为：" + index); 10 }
1 public static void main(String[] args) { 2 // 定义一个int数组 3 int[] arr = {10,20,5,30,40,15,18}; 4 // 想要把100元素值分配给arr数组 5 Arrays.fill(arr,100); 6 // 打印输出 7 System.out.println(Arrays.toString(arr));//[100, 100, 100, 100, 100, 100, 100] 8 }
1 double d1 = Math.abs(-5.3);// d1的值为5.3 2 double d2 = Math.abs(5.3);// d2的值为5.3 3 double d3 = Math.abs(0.0);// d3的值为0.0
1 double d1 = Math.ceil(5.3);// d1的值为6.0 2 double d2 = Math.ceil(5.9);// d2的值为6.0 3 double d3 = Math.ceil(-5.9);// d3的值为-5.0
1 double d1 = Math.floor(5.9);// d1的值为5.0 2 double d2 = Math.floor(5.1);// d2的值为5.0 3 double d3 = Math.floor(-5.9);// d3的值为-6.0
-
public static long round(double a)：返回最接近参数的long类型值。（相当于四舍五入运算）。
1 long d1 = Math.round(5.5);// d1的值为6 2 long d2 = Math.round(5.4);// d2的值为5 3 long d3 = Math.round(-5.5);// d3的值为-5 4 long d4 = Math.round(-5.6);// d4的值为-6
练习：使用Math类相关的api方法，计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个，分别是哪些数字？
1 public static void main(String[] args) { 2 double max = 5.9; 3 double min = -10.8; 4 int count = 0;// 统计个数 5 // 遍历循环 获取整数 6 for (double i = Math.ceil(min) ; i <= Math.floor(max); i++) { 7 // 判断条件 8 if (Math.abs(i) > 6 || Math.abs(i) < 2.1) { 9 System.out.print(i + " "); 10 count++; 11 } 12 } 13 System.out.println(); 14 // 打印输出个数 15 System.out.println("满足条件整数个数为：" + count + "个"); 16 }
例如：父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。
一般情况下，父类更通用，子类更具体。我们可以通过继承，使多种事物之间形成一种关系体系。
定义
-
继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的【非私有】的属性和行为。
好处：
-
可以提高代码的复用性。
-
类与类之间可以产生一种关系，是【多态的前提】。
继承的格式
通过extends
1 public class FuClass { 2 //.... 3 } 4 public class ZiClass extends FuClass { 5 // .... 6 }
1 /* 2 定义一个员工类Employee,父类 3 */ 4 public class Employee { 5 String name;// name属性 6 int id;// 工号属性 7 // 定义一个员工的工作方法 8 public void work() { 9 System.out.println( name + "努力的工作！"); 10 } 11 } 12 /* 13 定义讲师类Teacher 继承 员工类Employee 14 */ 15 public class Teacher extends Employee { 16 // 定义讲师类中的专有的方法 17 public void teach() { 18 System.out.println(name + "在教课"); 19 } 20 } 21 /* 22 定义一个测试类 23 */ 24 public class TestExtendsDemo01 { 25 public static void main(String[] args) { 26 // 创建一个讲师类 27 Teacher t = new Teacher(); 28 // 为该员工类的name属性赋值 29 t.name = "小张"; 30 // 调用该员工中的教课的方法 31 t.teach(); 32 // 调用Teacher类继承过来的work()方法 33 t.work(); 34 } 35 }
继承后的特点----成员变量
当类之间产生了关系后，其中各类中的成员变量有哪些影响？
成员变量不重名
如果子类父类中定义的成员变量名字不重名，这时的的访问没有任何影响。代码演示
1 public class Fu { 2 // 定义一个变量 3 int num = 10; 4 } 5 public class Zi extends Fu { 6 // 定义一个变量 7 int num2 = 20; 8 // 定义一个子类的成员方法 9 public void show() { 10 // 访问父类中的成员变量 num 11 System.out.println("父类中的成员变量num = " + num);// 10 继承而来的，可以直接访问 12 // 访问子类中的成员变量 num2 13 System.out.println("子类中的成员变量num2 = " + num2);// 20 14 } 15 } 16 public class TestExtendsField { 17 public static void main(String[] args) { 18 // 创建子类的对象 19 Zi zi = new Zi(); 20 // 调用子类的方法 21 zi.show(); 22 } 23 } 24 // 演示结果： 25 // 10 26 // 20
成员变量重名
如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码演示：
1 public class Fu { 2 // 定义父类中的成员变量 3 int num = 10; 4 } 5 public class Zi extends Fu { 6 // 定义子类中的成员变量 7 int num = 20; 8 // 定义子类中的成员方法 9 public void show() { 10 // 访问父类中的成员变量 num 11 System.out.println("父类中的成员变量num = " + num);// 20 12 // 访问子类中的成员变量 num 13 System.out.println("子类中的成员变量num = " + num);// 14 } 15 } 16 // 结果展示 17 // 20 18 // 20
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有会向上找
间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则继续向上找。
子父类中出现了重名的成员变量时，在子类中想要访问父类中的非私有的成员变量时，需要使用super关键字，修饰父类的成员变量，类似于this操作。
使用格式：
super.父类的成员变量名
子类方法中的代码需要修改
1 public class Zi extends Fu { 2 // 定义子类中的成员变量 3 int num = 20; 4 // 定义子类中的成员方法 5 public void show() { 6 // 访问父类中的成员变量 num 7 System.out.println("父类中的成员变量num = " + super.num);// 10 8 // 访问子类中的成员变量 num 9 System.out.println("子类中的成员变量num = " + num);// 10 } 11 } 12 // 结果展示 13 // 10 14 // 20
备注：Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类不能直接访问。通常编码时，我们遵循的是封装的原则，使用private关键字修饰成员变量，那么如何访问父类中的私有成员变量呢？可以借助于父类中的提供的公共的setXxx和getXxx方法。