今日内容
- Arrays类
- Math类
- 三大特征--继承
- 方法重写
- super关键字
- this关键字
- 抽象类
学习目标：
- 能够解释类名作为参数和返回值类型
- 能够说出类的继承格式
- 能够说出继承的特点
- 能够说出子类调用父类的成员特点
- 能够说出方法重写的概念
- 能够说出super可以解决的问题
- 描述抽象方法的概念
- 写出抽象类的格式
- 写出抽象方法的格式
- 能够说出父类抽象方法的存在意义
- 能够使用抽象类完成相关的案例开发
Arrays类
概述：
Java.util.Arrays 此类主要是用来操作数组吗，里面提供了很多的操作的api的方法，如【排序】和【搜索】功能，其说有的方法为静态方法，调用起来非常简单
操作数组的方法
-
public static String toString[int[] a]: 返回指定数组内容的字符串表示形式。
public static void main(String[] args){ // 初始化一个int类型的数组，动态初始化只指定长度，不指定内容，而静态初始化值指定内容，不指定长度，二者不能混合使用。 int[] arr = {12,345,112,34,456}; // 打印数组，输出内存地址值 System.out.println(arr);// 地址值 // 把数组内容转换成字符串 String str = Arrays.toString(arr); // 打印字符串，输出数组内容 System.out.println(str);// [12,345,112,34,456] 内容顺序不变 }-
public static void sort(int[] arr): 对指定的int数组按照数字升序进行排序，从小到大
public static void main(String[] args){ // 定义一个int类型数组 int[] arr = {12,345,112,34,456}; //输出排序的内容 System.out,println(Arrays.toString(arr));//排序前 // 升序排列 Arrays.sort(arr); System.out,println(Arrays.toString(arr));//排序后 }练习：使用
public class ArraysDemo01{ public static void main(String[] args){ //定义一个任意字符串 String str = "asddfvss345465dfg"; // 把字符串转化成字符数组 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(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 d2 = Math.abs(0.0);// d2的值为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 d2 = Math.ceil(-5.9);// d2的值为-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 d2 = Math.floor(-5.9);// d2的值为-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);// d2的值为-5 long d4 = Math.round(-5.6);//d1的值为-6public static void main(String[] args){ double max = 5.9; double min = -10.8; int count = 0;// 统计个数 // 遍历循环 获取整数 for(int i = Math.ceil(min);i<=Math.floor(max);i++){ // 判断条件 if(Math.abs(i)>6|| Math.abs(i)<2.1){ System.out.println(i + " "); count++; } } System.out.println(); // 打印输出个数 System.out.println("满足条件整数个数为："+ count); }
-
继承
面向对象的三大特征：封装性、继承性、多态性
继承是多态的前提，如果没有继承，就没有多态。
继承关系当中的特点：
1.子类可以拥有父类的“内容”。
2.子类还可以拥有自己专有的内容。
概述：
多个类中存在相同的属性和行为时，将这些内容抽取到单独的一个类中，那么多个类就无需再定义这些属性和行为，只要去继承这个单独的类即可。
其中，多个类称为子类，派生类。单独的哪一个类称为父类、超类(superclass)、基类
继承描述的是事物之间的所属关系，这种关系是：“is-a”的关系，在继承关系中，子类就是一个“父类”、也就是说，子类可以被当作父类看待。
例如：父类是员工，子类是讲师，那么“讲师就是一个员工”。 关系：is-a。
一般情况下，父类更通用，子类更具体。我们可以通过继承，使多种事物之间形成一种关系体系
定义
-
继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为，子类可以直接访问父类中【非私有】的属性和行为。
好处：
- 可以提高代码的复用性。
- 类与类之间可以产生一种关系，是【多态的前提】。
继承的格式：
通过【extends】关键字，可以声明一个子类继承另一个父类；
public class FuClass{ //.... } public class ZiClass extends FuClass{ //.... }代码演示：
/* 定义一个员工类Employee,父类 */ public class Employee{ String name; int id; // 定义一个员工的工作方法 public void work(){ System.out.println("努力工作！")； } } /* 定义讲师类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 );// 10
// 访问子类中的成员变量 num2
System.out.println(num2); // 20
}
}
public class TestExtendsField{
// 创建子类的对象
Zi zi = new Zi();
// 调用子类的方法
zi.show();
}
成员变量重名
如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码演示：
public class Fu{
// 定义父类中的成员变量
int num = 10;
}
public class Zi extends Fu{
// 定义子类中的成员变量
int num = 20;
// 定义子类中的成员方法
public void show(){
// 访问父类的成员变量 num
System.out.println("父类中的成员变量：" + num );// 20
// 访问子类中的成员变量 num2
System.out.println(num); // 20
}
}
在父子类的继承关系当中，如果成员变量重名，则创建子类对象时，访问有两种方式：
直接通过子类对象访问成员变量：等号左边是谁，就优先用谁，没有会向上找
间接通过成员方法访问成员变量：该方法属于谁，就优先用谁，没有则继续向上找。
子父类中出现了重名的成员变量时，在子类中想要访问父类中的非私有的成员变量时，需要使用【super】关键字
修饰父类中的成员变量，类似于【this】操作。
使用格式：
super.父类的成员变量名
子类方法中的代码需要修改
public class Zi extends Fu{
// 定义子类中的成员变量
int num = 20;
// 定义子类中的成员方法
public void show(){
// 访问父类的成员变量 num
System.out.println("父类中的成员变量：" + super.num );// 10
// 访问子类中的成员变量 num2
System.out.println(num); // 20
}
}
备注：Fu类中的成员变量是非私有的，子类中可以直接访问，若F类中的成员变量私有了，子类不能直接访问。
通常编码时，我们遵循的是封装的原则，使用private关键字修饰成员变量，那么如何访问父类中的私有成员
变量呢？ 可以借助父类中的提供的公共的setXxx和getXxx方法。
继承后的特点----成员方法