宽禁带半导体 Android防重复点击 node.js 多线程 数据算法 ipv4 ajax caching webview handlebarsjs vue注册组件 网页后台模板 后台页面模板 网络营销视频 mysql安装后怎么使用 js回调函数写法 cad怎么重复上一次命令 python转java python编程教程 python手册 python随机整数 java入门 java基础教程 javaindexof java使用mysql java获取当前月份 java数组扩容 java语言代码大全 java数组删除 java中的数据结构 java查看数据类型 java中new java连接sql 霜之祝福 0x8002801c vbs编程教学 html特殊符号 bbm注册 netreflector 华为下拉开关设置
当前位置: 首页 > 学习教程  > 编程语言

java-Arrays、Math、继承

2020/11/24 9:49:51 文章标签: 测试文章如有侵权请发送至邮箱809451989@qq.com投诉后文章立即删除

今日内容 ​ Arrays类 ​ Math类 ​ 三大特征—继承 ​ 方法重写 ​ super关键字 ​ this关键字 ​ 抽象类 学习目标 能够解释类名作为参数和返回值类型 能够写出类的继承格式 能够说出继承的特点 能够说出子类调用父类的成员特点 能够说出方法重写的概念 能够说出…

今日内容

  • ​ Arrays类

  • ​ Math类

  • ​ 三大特征—继承

  • ​ 方法重写

  • ​ super关键字

  • ​ this关键字

  • ​ 抽象类

学习目标

  • 能够解释类名作为参数和返回值类型

  • 能够写出类的继承格式

  • 能够说出继承的特点

  • 能够说出子类调用父类的成员特点

  • 能够说出方法重写的概念

  • 能够说出super可以解决的问题

  • 描述抽象方法的概念

  • 写出抽象类的格式

  • 写出抽象方法的格式

  • 能够说出父类抽象方法的存在意义

  • 能够使用抽象类完成相关的案例开发

    Arrays类

    概述

​ java.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方法。

继承后的特点----成员方法

本文链接: http://www.dtmao.cc/news_show_400152.shtml

附件下载

相关教程

    暂无相关的数据...

共有条评论 网友评论

验证码: 看不清楚?