Java基础(九）——Arrays类、Math类和继承

Arrays类

　　概述

　　　　　javajava.util.Arrays 此类主要是用来操作数组，里面提供了很多的操作的api方法，如【排序】和【搜索】功能。其所有的方法均为静态方法，调用起来非常简单

　　 操作数组的方法

•   public static String toString(int[] arr)：返回指定数组内容的字符串表示形式。

　　

public static void main(String[] args) {
   　　// 初始化一个int类型的数组 动态初始化只指定长度，不指定内容，而静态初始化只指定内容，不指定长度，两者不能混合使用。
   　　 int[] arr = {12,345,112,78,489};
    　　// 打印数组，输出内存地址值
    　　System.out.println(arr);// 地址值
   　　 // 把数组内容转换成字符串
    　　String str = Arrays.toString(arr);
    　　// 打印字符串，输出数组内容
   　　 System.out.println(str);// [12,345,112,78,489]  内容顺序不变
　　}

• 　　public static void sort(int[] arr)：对指定的int数组按照数字升序进行排序。从小到大

　　　　

public static void main(String[] args) {
    　　　　// 定义一个int类型数组
    　　　　int[] arr = {12,345,112,78,489};
    　　　　//输出排序前的内容
    　　　　System.out.println(Arrays.toString(arr));// 排序前 [12,345,112,78,489]
   　　　　 // 升序排序
    　　　　Arrays.sort(arr);
    　　　　System.out.println(Arrays.toString(arr));// 排序后  [12,78,112,345,489]
　　　　　}

　　练习：使用Arrays相关的api方法，将一个任意给定的字符串中的所有字符按照升序排序，倒序打印输出。

　　　　

public class ArraysDemo01 {
    　　　　　public static void main(String[] args) {
        　　　　　　// 定义一个任意字符串
        　　　　　　String str = "asdhfkjadhfs2342354234kjhkljhkj";
        　　　　　　// 把字符串转换成字符数组
        　　　　　　char[] chs = str.toCharArray();
        　　　　　　// 使用Arrays类中的sort()方法
        　　　　　　Arrays.sort(chs);
       　　　　　　 // 倒序打印输出
        　　　　　　// 反向遍历
        　　　　　　for (int i = chs.length-1; i >= 0 ; i--) {
            　　　　　　　　System.out.print(chs[i] + " ");
        　　　　　　　　}
    　　　　　　}  
　　　　　　}

• 　public static int binarySearch(int[] arr,int key)：使用二分搜索法来搜索指定的 int 型数组，以获得指定的值，此时key指的是要搜索的值，而方法返回值声明的int指的是搜索值对应的索引值。 使用binarySearch()方法。搜索数组当中的元素时，数组必须是有序的。【升序】得到的索引值是排序之后的新的数组的索引值。　如果没有找到对应的元素值，得到的索引值是负值。

public static void main(String[] args) {
    　　　　　　　　// 定义一个int类型的数组
    　　　　　　　　int[] arr = {10,20,5,30,40,15,18};
    　　　　　　　　 // 对arr数组进行排序
    　　　　　　　　Arrays.sort(arr);
    　　　　　　　　// 搜索5这个数值在arr数组当中的索引值
   　　　　　　　　 int index = Arrays.binarySearch(arr,5);
    　　　　　　　　// 打印输出index的值
    　　　　　　　　System.out.println("5在arr数组当中的索引值为：" + index);
　　　　　　　　}

 

 

• 　public static void fill(int[] arr,int val)： 将指定的 int 值分配给指定 int 型数组的每个元素。

　　　　

public static void main(String[] args) {
    　　　　// 定义一个int数组
    　　　　int[] arr = {10,20,5,30,40,15,18};
    　　　　// 想要把100元素值分配给arr数组
    　　　　Arrays.fill(arr,100);
    　　　　// 打印输出
    　　　　System.out.println(Arrays.toString(arr));//[100, 100, 100, 100, 100, 100, 100]
　　　　　　}

 

 

Math类　

　　概述

　　　　java.util.Math 包含了用于执行基本数学运算的方法，如指数，幂次方，对数，平方根，三角函数等运算。里面的方法均是静态方法，并且也不需要创建对象，调用起来也是非常方便。

　　基本运算的方法

• 　public static double abs(double a)：返回double值的绝对值。

　　　 

double d1 = Math.abs(-5.3);// d1的值为5.3
double d2 = Math.abs(5.3);//  d2的值为5.3
double d3 = Math.abs(0.0);//  d3的值为0.0

• 　public static double ceil(double a)：返回大于等于参数的最小整数。往上取整。　　　

double d1 = Math.ceil(5.3);// d1的值为6.0
double d2 = Math.ceil(5.9);// d2的值为6.0
double d3 = Math.ceil(-5.9);// d3的值为-5.0

•  public static double floor(double a)：返回小于等于参数的最大整数。往下取整。

double d1 = Math.floor(5.9);// d1的值为5.0
double d2 = Math.floor(5.1);// d2的值为5.0
double d3 = Math.floor(-5.9);// d3的值为-6.0

• public static long round(double a)：返回最接近参数的long类型值。（相当于四舍五入运算）。

     long d1 = Math.round(5.5);// d1的值为6
     long d2 = Math.round(5.4);// d2的值为5
     long d3 = Math.round(-5.5);// d3的值为-5
     long d4 = Math.round(-5.6);// d4的值为-6  

练习：使用Math类相关的api方法，计算在-10.8到5.9之间，绝对值大于6或者小于2.1的整数有多少个，分别是哪些数字？

 public static void main(String[] args) {
     double max = 5.9;
     double min = -10.8;
     int count = 0;// 统计个数
     // 遍历循环 获取整数
     for (double i = Math.ceil(min) ; i <= Math.floor(max); i++) {
         // 判断条件
         if (Math.abs(i) > 6 || Math.abs(i) < 2.1) {
             System.out.print(i + " ");
             count++;
         } 
     }
     System.out.println();
     // 打印输出个数
     System.out.println("满足条件整数个数为：" + count + "个");
 }

继承　　

　　　概述

　　　　如果多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类就无需再定义这些属性和行为，只要去继承这个单独的类即可。

　　　其中，多个类称为子类，派生类，单独的那一个类称为父类、超类(superclass)、基类

　　　继承描述的是事物之间的所属关系，这种关系是：is-a的关系，在继承关系中，“子类就是一个父类”。也就是说，子类可以被当作父类看待。

　　  例如：父类是员工，子类是讲师，那么“讲师就是一个员工”。关系：is-a。

　　　　一般情况下，父类更通用，子类更具体。我们可以通过继承，使多种事物之间形成一种关系体系。 

　　定义 

•   继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接访问父类中的【非私有】的属性和行为。

　　好处：

1. 可以提高代码的复用性。

2. 类与类之间可以产生一种关系，是【多态的前提】。

继承的格式 

　　通过extends关键字，可以声明一个子类继承另一个父类：

　　　　

public class FuClass {
    　　//....
　　　　}
　　　　public class ZiClass extends FuClass {
    　　// ....
　　　　}

 

　　代码演示：

　　　　

　　　　/*
  　　　　定义一个员工类Employee,父类
　　　　*/
　　　　public class Employee {
     　　　　String name;// name属性
     　　　　int id;//  工号属性
   　　　　 // 定义一个员工的工作方法
    　　　　public void work() {
        　　　　System.out.println( name + "努力的工作！");
    　　　　}
　　　　}
　　　　/*
    　　　　定义讲师类Teacher  继承  员工类Employee
　　　　*/
　　　　public class Teacher extends Employee {
    　　　　// 定义讲师类中的专有的方法
    　　　　public void teach() {
        　　　System.out.println(name + "在教课");
    　　　　}
　　　　}
　　　　/*
   　　　　定义一个测试类
　　　　*/
　　　　public class TestExtendsDemo01 {
    　　　　public static void main(String[] args) {
        　　　　// 创建一个讲师类
        　　　　Teacher t = new Teacher();
        　　　　// 为该员工类的name属性赋值
        　　　　t.name = "小张";
        　　　　// 调用该员工中的教课的方法
       　　　　 t.teach();
        　　　　// 调用Teacher类继承过来的work()方法
        　　　　t.work();
    　　　　} 
　　　　}

继承后的特点----成员变量

　　　　　　当类之间产生了关系后，其中各类中的成员变量有哪些影响？

　　成员变量不重名

　　　　　　如果子类父类中定义的成员变量名字不重名，这时的的访问没有任何影响。代码演示

public class Fu { 
     　　　　// 定义一个变量
     　　　　int num = 10;
 　　　　}
 　　　　public class Zi extends Fu {
     　　　　// 定义一个变量
     　　　　int num2 = 20;
     　　　　// 定义一个子类的成员方法
     　　　　public void show() {
         　　　// 访问父类中的成员变量 num
         　　　　System.out.println("父类中的成员变量num = " + num);// 10  继承而来的，可以直接访问
         　　　　// 访问子类中的成员变量 num2
         　　　　System.out.println("子类中的成员变量num2 = " + num2);// 20
     　　　　}
 　　}
 　　public class TestExtendsField {
     　　public static void main(String[] args) {
         // 创建子类的对象
         Zi zi = new Zi();
         // 调用子类的方法
         zi.show();
     }​
 }
 // 演示结果：
 //  10
 //  20

成员变量重名

　　如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码演示：

　public class Fu {
     　　// 定义父类中的成员变量
    　　 int num = 10;
 　　}
 　　public class Zi extends Fu {
            // 定义子类中的成员变量
         　int num = 20;
              // 定义子类中的成员方法
     　　  public void show() {
         　　// 访问父类中的成员变量 num
         　　System.out.println("父类中的成员变量num = " + num);// 20
         　　// 访问子类中的成员变量 num
         　　System.out.println("子类中的成员变量num = " + num);// 
     　　}  
 　　}
 　　// 结果展示
　　 // 20
 　　// 20​

　　在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：

　　直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有会向上找

　　间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则继续向上找。

　　子父类中出现了重名的成员变量时，在子类中想要访问父类中的非私有的成员变量时，需要使用super关键字，修饰父类的成员变量，类似于this操作。

　　使用格式：

 　　super.父类的成员变量名

　　子类方法中的代码需要修改

 public class Zi extends Fu {
     // 定义子类中的成员变量
     int num = 20;
     // 定义子类中的成员方法
     public void show() {
         // 访问父类中的成员变量 num
         System.out.println("父类中的成员变量num = " + super.num);// 10
         // 访问子类中的成员变量 num
         System.out.println("子类中的成员变量num = " + num);// 
     }  
 }
 // 结果展示
 // 10
 // 20

　　备注：Fu类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类不能直接访问。通常编码时，我们遵循的是封装的原则，使用private关键字修饰成员变量，那么如何访问父类中的私有成员变量呢？可以借助于父类中的提供的公共的setXxx和getXxx方法。