JAVA 基础知识学习15

目录

API

api的概述： 就是java替我们写好的一些类，他封装了一些功能，我们仅仅只需要知道如何使用即可

Object

object的概述：
   A、 object是所有的类父类
   B、 object中的所有方法，子类都能使用（接口不是object的子类）

Object 类中常用方法

 A、equals()  
    底层调用其实就是== 方法
    == 方法：
       基本数据类： 比较的是内容(值)
       引用数据类型：比较的是内存地址值
  String 的equals比较的是内容  

 B、String toString()
    问题：为什么要重写toString()方法

    答：打印时默认会调用toString()方法
     因为toString()方法来源于object中，object中getClass.getName()+"@" +Integer.toHexString(hasCode() ) --->打印就是内存地址值
    很多时候，我们不想看见内存地址值，想看到的是子类的特有属性值，这时就需要重写toString()方法

String

 在String 中认为都是对象，String str = "...";
 所以str 是对象，""也是对象
  String 是一个常量，其本质就是private final 修饰的字符数组     

String的构造方法:
 new String(byte [] bytes, int offset,int length);
 offset: 数据解锁起始位置
 length:需要解锁的位数

substring(int start ,int end );   包含头，不包含尾。 截取一段字符
substring(int start);             从某一位到尾
startsWith(String str)            判断以什么开头
endsWith(String str)                        判断以什么结尾    
contains(String str)               判断是否包含
indexOf（String str）      
charAt(int index)
equals()                           注意：要区分大小写
equalsIgnoreCase                   不区分大小写
getBytes（）    
toCharArray()            

StringBuilder && StringBuffer

1、 StringBuilder 是字符串缓冲对象，底层是一个没有用final修饰的数组，并且长度默认为16,底层是一个"可变数组"

注意：是底层自动帮我们创建新数组，数组一旦创建，是不可变的

---

面试题

object类有哪些方法

　final

　　　A、修饰类 ： 不能被继承
　　　B、修饰方法 ： 不能被重写
C、修饰变量 ： 基本数据类型： 值不能改变
引用数据类型： 地址值不能改变

重写和重载

 重写：子类中出现和父类方法声明一模一样的方法,重写
 重载：本类中出现方法名相同，但参数列表不同，注意：与返回值类型无关

封装

封装好处：
 A、提高了代码的复用性
 B、提高了代码的安全性
 C、隐藏了对象实现的细节，仅仅对外提供方法

继承

A、提高了代码的复用性
B、提高了代码的可维护性
C、是类和类之间耦合起来了，这是多态的前提
继承的弊端：
开发的原则：高内聚，低耦合
内聚：完成一个功能的能力
耦合：类和类之间的关系   继承的注意事项：

 1、 子类继承父类，只能继承父类中非private修饰的成员变量和方法
 2、 简单说：子类有，父类有，找子类，子类没有，父类有，找父类

01正则表达式的概念和作用

* A: 正则表达式的概念和作用
    * a: 正则表达式的概述
        * 正则表达式也是一个字符串，用来定义匹配规则，在Pattern类中有简单的规则定义。
          可以结合字符串类的方法使用。
        * 简单记：正则表达式是具有特殊含义的字符串。
    * b: 正则表达式的作用
    * 比如注册邮箱,邮箱有用户名和密码,一般会对其限制长度,这个限制长度的事情就是正则表达式做的

02正则表达式语法规则

* A: 正则表达式语法规则
    * a: 字符
        * x  代表的是字符x
        * \\ 代表的是反斜线字符'\'
        * \t 代表的是制表符
        * \n 代表的是换行符
        * \r 代表的是回车符
    * b: 字符类
        * [abc]    a、b 或 c（简单类）
        * [^abc]   任何字符，除了 a、b 或 c（否定）
        * [a-zA-Z] a到 z 或 A到 Z，两头的字母包括在内（范围） 
        * [0-9]    0到9的字符都包括
        * [a-zA-Z_0-9] 代表的字母或者数字或者下划线(即单词字符)
    * c: 预定义字符类
        * . 任何字符。
        * \d 数字：[0-9]
        * \w 单词字符：[a-zA-Z_0-9]如"com.itheima.tests"/finish
    * d: 边界匹配器
        * ^  代表的是行的开头
        * $  代表的是行的结尾
        * \b 代表的是单词边界
    * e: 数量词
        * X?     X，一次或一次也没有
        * X*     X，零次或多次
        * X+     X，一次或多次
        * X{n}   X，恰好 n 次 
        * X{n,}  X，至少 n 次 
        * X{n,m} X，至少 n 次，但是不超过 m 次

03正则表达式练习和相关的String类方法

* A: 正则表达式练习和相关的String类方法
    * a: boolean matches(String 正则的规则)
        * "abc".matches("[a]")  
        * 匹配成功返回true
    * b: String[] split(String 正则的规则)
        * "abc".split("a")  
        * 使用规则将字符串进行切割
    * c: String replaceAll( String 正则规则,String 字符串)
        * "abc0123".repalceAll("[\\d]","#") 
        * 按照正则的规则,替换字符串

04正则表达式匹配练习

* A: 正则表达式匹配练习
    * a: 案例代码

public class RegexDemo {
                public static void main(String[] args) {
                    checkTel();
                }


                /*
                 *  检查手机号码是否合法
                 *  1开头 可以是34578  0-9 位数固定11位
                 */
                public static void checkTel(){
                    String telNumber = "1335128005";
                    //String类的方法matches
                    boolean b = telNumber.matches("1[34857][\\d]{9}");
                    System.out.println(b);
                }

                /*
                 *  检查QQ号码是否合法
                 *  0不能开头,全数字, 位数5,10位
                 *  123456 
                 *  \\d  \\D匹配不是数字
                 */
                public static void checkQQ(){
                    String QQ = "123456";
                    //检查QQ号码和规则是否匹配,String类的方法matches
                    boolean b = QQ.matches("[1-9][\\d]{4,9}");
                    System.out.println(b);
                }
            }

05正则表达式切割练习

* A: 正则表达式切割练习
    * a: 案例代码

public class RegexDemo1 {
                public static void main(String[] args) {
                    split_1();
                    split_2();
                    split_3();

                }

                /*
                 * String类方法split对字符串进行切割
                 * 192.168.105.27 按照 点切割字符串
                 */
                public static void split_3(){
                    String ip = "192.168.105.27";
                    String[] strArr = ip.split("\\.");
                    System.out.println("数组的长度"+strArr.length);
                    for(int i = 0 ; i < strArr.length ; i++){
                        System.out.println(strArr[i]);
                    }
                }

                /*
                 * String类方法split对字符串进行切割
                 * 18 22 40 65 按照空格切割字符串
                 */
                public static void split_2(){
                    String str = "18    22     40          65";
                    String[] strArr = str.split(" +");
                    System.out.println("数组的长度"+strArr.length);
                    for(int i = 0 ; i < strArr.length ; i++){
                        System.out.println(strArr[i]);
                    }
                }

                /*
                 *  String类方法split对字符串进行切割
                 *  12-25-36-98  按照-对字符串进行切割
                 */
                public static void split_1(){
                    String str = "12-25-36-98";
                    //按照-对字符串进行切割,String类方法split
                    String[] strArr = str.split("-");
                    System.out.println("数组的长度"+strArr.length);
                    for(int i = 0 ; i < strArr.length ; i++){
                        System.out.println(strArr[i]);
                    }
                }
            }       

06正则表达式替换练习

* A: 正则表达式替换练习
    * a: 案例代码

public class RegexDemo1 {
                public static void main(String[] args) {
                    replaceAll_1();
                }

                /*
                 * "Hello12345World6789012"将所有数字替换掉
                 * String类方法replaceAll(正则规则,替换后的新字符串)
                 */
                public static void replaceAll_1(){
                    String str = "Hello12345World6789012";
                    str = str.replaceAll("[\\d]+", "#");
                    System.out.println(str);
                }
            }

07正则表达式邮箱地址验证

* A: 正则表达式邮箱地址验证
    * a: 案例代码

public class RegexDemo2 {
                public static void main(String[] args) {
                    checkMail();
                }
                /*
                 *  检查邮件地址是否合法
                 *  规则:
                 *   1234567@qq.com
                 *   mym_ail@sina.com
                 *   nimail@163.com
                 *   wodemail@yahoo.com.cn    
                 *   
                 *   @: 前  数字字母_ 个数不能少于1个
                 *   @: 后  数字字母     个数不能少于1个
                 *   .: 后面 字母 
                 *     
                 */
                public static void checkMail(){
                    String email ="abc123@sina.com";
                    boolean b = email.matches("[a-zA-Z0-9_]+@[0-9a-z]+(\\.[a-z]+)+");
                    System.out.println(b);
                }
            }

08毫秒值概念

* A: 毫秒值概念
    * a: 时间和日期类
        * java.util.Date
    * b: 毫秒概念
        * 1000毫秒=1秒
    * c: 毫秒的0点
         * System.currentTimeMillis() 返回值long类型参数
         * 获取当前日期的毫秒值   3742769374405    
         * 时间原点; 公元1970年1月1日,午夜0:00:00 英国格林威治  毫秒值就是0
         * 时间2088年8月8日    
         * 时间和日期的计算，必须依赖毫秒值

09Date类的构造方法

* A: Date类的构造方法
    * a: 空参构造
        * public Date()
    * b: 带参构造
        * public Date(long times)

==============================第二阶段====================================

10Date类的get和set方法

* A：Date类的get和set方法
    * public long getTime() 
        * 将当前的日期对象，转为对应的毫秒值
    * public void setTime(long times);
        * 根据给定的毫秒值，生成对应的日期对象

11日期格式化SimpleDateFormat

* A: 日期格式化SimpleDateFormat
    * a: 对日期进行格式化(自定义)
        * 对日期格式化的类 java.text.DateFormat 抽象类, 普通方法,也有抽象的方法
        * 实际使用是子类 java.text.SimpleDateFormat 可以使用父类普通方法,重写了抽象方法
    * b: 对日期进行格式化的步骤
        * 1: 创建SimpleDateFormat对象
            * 在类构造方法中,写入字符串的日期格式 (自己定义)
        * 2: SimpleDateFormat调用方法format对日期进行格式化
            * public String format(Date date) 传递日期对象,返回字符串
            * 日期模式:
            * yyyy    年份
            * MM      月份
            * dd      月中的天数
            * HH       0-23小时
            * mm      小时中的分钟
            * ss      秒
            * yyyy年MM月dd日 HH点mm分钟ss秒  汉字修改,: -  字母表示的每个字段不可以随便写

12字符串转成日期对象

* A: 字符串转成日期对象
    * a: 使用步骤
        * 1: 创建SimpleDateFormat的对象
            * 构造方法中,指定日期模式
        * 2: 子类对象,调用方法 parse 传递String,返回Date
            * 注意: 时间和日期的模式yyyy-MM-dd, 必须和字符串中的时间日期匹配

13Calendar类_1

* A: Calendar类_1
    * a: 日历类(抽象类)
        * java.util.Calendar
    * b: 创建对象
        * Calendar类写了静态方法 getInstance() 直接返回了子类的对象
        * 不需要直接new子类的对象,通过静态方法直接获取

14Calendar类_2

* A: Calendar类_2
    * a: 成员方法
        * getTime() 把日历对象,转成Date日期对象
        * get(日历字段) 获取指定日历字段的值
    * b: 代码演示
        Calendar c = Calendar.getInstance();
        // 获取年份
        int year = c.get(Calendar.YEAR);
        // 获取月份
        int month = c.get(Calendar.MONTH) + 1;
        // 获取天数
        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "年" + month + "月" + day + "日");

15Calendar类_3

*

 A: Calendar类_3
        * a: 成员方法
            * set(int field,int value)  设置指定的时间
        * b: 代码演示
            /*
             * Calendar类的set方法 设置日历 set(int field,int value) field 设置的是哪个日历字段 value
             * 设置后的具体数值
             * 
             * set(int year,int month,int day) 传递3个整数的年,月,日
             */
            public static void function_1() {
                Calendar c = Calendar.getInstance();
                // 设置,月份,设置到10月分
                // c.set(Calendar.MONTH, 9);

                // 设置年,月,日
                c.set(2099, 4, 1);

                // 获取年份
                int year = c.get(Calendar.YEAR);
                // 获取月份
                int month = c.get(Calendar.MONTH) + 1;
                // 获取天数
                int day = c.get(Calendar.DAY_OF_MONTH);
                System.out.println(year + "年" + month + "月" + day + "日");
            }

16Calendar类_4

* 

A: Calendar类_4
        * a: 成员方法
            * add(int field, int value) 进行整数的偏移
            * int get(int field) 获取指定字段的值
        * b: 案例演示
            /*
             * Calendar类方法add 日历的偏移量,
             * 可以指定一个日历中的字段,
             * 进行整数的偏移 add(int field, int value)
             */
            public static void function_2() {
                Calendar c = Calendar.getInstance();
                // 让日历中的天数,向后偏移280天
                c.add(Calendar.DAY_OF_MONTH, -280);
                // 获取年份
                int year = c.get(Calendar.YEAR);
                // 获取月份
                int month = c.get(Calendar.MONTH) + 1;
                // 获取天数
                int day = c.get(Calendar.DAY_OF_MONTH);
                System.out.println(year + "年" + month + "月" + day + "日");
            }

17日期练习_活了多少天

* A: 日期练习_活了多少天
    * a: 案例代码
        /*
         *  计算活了多少天
         *   生日  今天的日期
         *   两个日期变成毫秒值,减法
         */

public static void function() throws Exception {
                System.out.println("请输入出生日期 格式 YYYY-MM-dd");
                //获取出生日期,键盘输入
                String birthdayString = new Scanner(System.in).next();
                //将字符串日期,转成Date对象
                //创建SimpleDateFormat对象,写日期模式
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                //调用方法parse,字符串转成日期对象
                Date birthdayDate = sdf.parse(birthdayString);

                //获取今天的日期对象
                Date todayDate = new Date();

                //将两个日期转成毫秒值,Date类的方法getTime
                long birthdaySecond = birthdayDate.getTime();
                long todaySecond = todayDate.getTime();
                long secone = todaySecond-birthdaySecond;

                if(secone < 0){
                    System.out.println("还没出生呢");
                }
                else{
                System.out.println(secone/1000/60/60/24);
                }

            }

18日期练习_闰年计算

* A: 日期练习_闰年计算
    * a: 案例代码
        /*
         *  闰年计算
         *  2000 3000
         *  高级的算法: 日历设置到指定年份的3月1日,add向前偏移1天,获取天数,29闰年
         */

    public static void function_1(){
                Calendar c = Calendar.getInstance();
                //将日历,设置到指定年的3月1日
                c.set(2088, 2, 1);
                //日历add方法,向前偏移1天
                c.add(Calendar.DAY_OF_MONTH, -1);
                //get方法获取天数
                int day = c.get(Calendar.DAY_OF_MONTH);
                System.out.println(day);
            }

01基本数据类型对象包装类概述

 *A:基本数据类型对象包装类概述
   *a.基本类型包装类的产生
       在实际程序使用中，程序界面上用户输入的数据都是以字符串类型进行存储的。而程序开发中，我们需要把字符串数据，根据需求转换成指定的基本数据类型，如年龄需要转换成int类型，考试成绩需要转换成double类型等

    *b.八种基本类型对应的包装类
           char    Character
           int     Integer
           byte    Byte
           short   Short
           long    Long
           float   Float
           double  Double
           boolean Boolean

02Integer类parseInt方法

*A:Integer类parseInt方法:
        *a:parseInt()
            int i = Integer.parseInt("12");
            System.out.println(i/2);//6

        *b:parseInt(String s, int radix)
            /*
             * Integer类静态方法parseInt(String s, int radix)
             * radix基数,进制
             * "110",2 含义 前面的数字是二进制的,但是方法parseInt运行结果都是十进制
             *  指定进制的字符串转换为十进制的整数
             */
            public static void function_1(){
                int i = Integer.parseInt("110", 2);
                System.out.println(i);
            }

03Integer类int转成字符串

 *A:Integer类int转成字符串:
       *a:使用+与字符串拼接
            int i = 3;
            String s = i+"";
            System.out.println(s+1);//"31"

       *b:toString(int ,int 进制),任意进制整数转成任意进制的字符串 (了解)
            String s1 = Integer.toString(5,2);
            System.out.println(s1);

04Integer类构造方法

 *A:Integer类构造方法
        /*
         *  Integer类构造方法
         *   Integer (String s)
         *   将数字格式的字符串,传递到Integer类的构造方法中
         *   创建Integer对象,包装的是一个字符串
         *   将构造方法中的字符串,转成基本数据类型,调用方法,非静态的, intValue()
         */
        public static void function_3(){
            Integer in = new Integer("100");
            int i = in.intValue();
            System.out.println(--i);//99
        }

05Integer类其他方法

*A:Integer类其他方法
         /*
         * Integer类的3个静态方法
         * 做进制的转换
         * 十进制转成二进制  toBinarString(int)
         * 十进制转成八进制  toOctalString(int)
         * 十进制转成十六进制 toHexString(int)
         * 三个方法,返回值都是以String形式出现
         */
          a:十进制转二,八,十六进制
              public static void function_1(){
                    System.out.println(Integer.toBinaryString(99));
                    System.out.println(Integer.toOctalString(99));
                    System.out.println(Integer.toHexString(999));
              }
          b:获取int的最大值和最小值
          /*
           *   Integer类的静态成员变量
           *   MAX_VALUE
           *   MIN_VALUE
           */
          public static void function(){
            System.out.println(Integer.MAX_VALUE);
            System.out.println(Integer.MIN_VALUE);
          }

06自动装箱和自动拆箱

*A:自动装箱与自动拆箱:
    //JDK1.5新特性
    //自动装箱,拆箱的 好处: 基本类型和引用类直接运算
    //自动装箱:使用Integer.valueOf(整数值)返回一个封装了该整数值的Integer对象
    //自动拆箱:使用Integer对象.intValue()返回Integer对象中封装的整数值
    public static void function(){
        //引用类型 , 引用变量一定指向对象
        //自动装箱, 基本数据类型1, 直接变成了对象

        Integer in = 1; // Integer in = new Integer(1)
        //in 是引用类型,不能和基本类型运算, 自动拆箱,引用类型in,转换基本类型

        //in+1  ==> in.inValue()+1 = 2    
        //in = 2    自动装箱
        in = in + 1;

        System.out.println(in);

    }

07自动装箱和自动拆箱练习题

 *A:自动装箱与自动拆箱:
        Integer i = new Integer(1);
        Integer j = new Integer(1);
        System.out.println(i==j);// false 对象地址
        System.out.println(i.equals(j));// true  继承Object重写equals,比较的对象数据

        System.out.println("===================");

        Integer a = 500;//Integer integer=Integer.valueOf(500)
                        //integer=new Integer(500);
        Integer b = 500;
        System.out.println(a==b);//false
        System.out.println(a.equals(b));//true

        System.out.println("===================");


        //数据在byte(-128~127)范围内,JVM不会从新new对象
        Integer aa = 127; // Integer aa = new Integer(127)
        Integer bb = 127; // Integer bb = aa;
        System.out.println(aa==bb); //true
        System.out.println(aa.equals(bb));//true

=========================第二节课开始====================================

08System类方法currentTimeMillis

*A:System类方法currentTimeMillis():用于计算程序的执行时间
/*
* 获取系统当前毫秒值
* static long currentTimeMillis()
* 对程序执行时间测试
*/

        public static void function(){
            long start = System.currentTimeMillis();//当前时间x-1970年1月1日零时零分零秒
            for(int i = 0 ; i < 10000; i++){
                System.out.println(i);
            }
            long end = System.currentTimeMillis();//当前时间y-1970年1月1日零时零分零秒
            System.out.println(end - start);//当前时间y-当前时间x 
        }

09System类方法exit

 *A:System类方法exit()方法
         /*
         *  退出虚拟机,所有程序全停止
         *  static void exit(0)
         */

public static void function_1(){
                while(true){
                    System.out.println("hello");
                    System.exit(0);//该方法会在以后的finally代码块中使用(讲到再说)
                }
            }

10System类方法gc

A:System类方法gc

     public class Person {
            public void finalize(){
                System.out.println("垃圾收取了");
            }
        }

        /*
         *  JVM在内存中,收取对象的垃圾
         *  当没有更多引用指向该对象时,会自动调用垃圾回收机制回收堆中的对象
         *  同时调用回收对象所属类的finalize方法()
         *  static void gc()
         */
        public static void function_2(){
            new Person();
            new Person();
            new Person();
            new Person();
            new Person();
            new Person();
            new Person();
            new Person();
            System.gc();
        }

11System类方法getProperties

A:System类方法getProperties(了解)
/*
* 获取当前操作系统的属性:例如操作系统名称,
* static Properties getProperties()
*/

     public static void function_3(){
        System.out.println( System.getProperties() );
     }

12System类方法arraycopy

 A:System类方法arraycopy：
  /*

  * System类方法,复制数组
       * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
       * Object src, 要复制的源数组
       * int srcPos, 数组源的起始索引
       * Object dest,复制后的目标数组
       * int destPos,目标数组起始索引 
       * int length, 复制几个
       */
      public static void function_4(){
        int[] src = {11,22,33,44,55,66};
        int[] desc = {77,88,99,0};

        System.arraycopy(src, 1, desc, 1, 2);//将src数组的1位置开始(包含1位置)的两个元素,拷贝到desc的1,2位置上
        for(int i = 0 ;  i < desc.length ; i++){
            System.out.println(desc[i]);
        }
      }

================================第三节课开始======================================================

13Math类的方法_1

A:Math类中的方法
/*

     * static double sqrt(double d)
     * 返回参数的平方根
     */
    public static void function_4(){
        double d = Math.sqrt(-2);
        System.out.println(d);
    }

    /*0
     * static double pow(double a, double b)
     * a的b次方
     */
    public static void function_3(){
        double d = Math.pow(2, 3);
        System.out.println(d);
    }

    /*
     * static double floor(double d)
     * 返回小于或者等于参数d的最大整数
     */
    public static void function_2(){
        double d = Math.floor(1.5);
        System.out.println(d);
    }

    /*
     *  static double ceil(double d)
     *  返回大于或者等于参数d的最小整数
     */
    public static void function_1(){
        double d = Math.ceil(5.1);
        System.out.println(d);
    }

    /*
     *  static int abs(int i)
     *  获取参数的绝对值
     */
     public static void function(){
        int i = Math.abs(0);
        System.out.println(i);
     }

14Math类的方法_2

A:Math类的方法_2

 /*
   *  static double round(doubl d)
   *  获取参数的四舍五入,取整数
   */
  public static void function_6(){
    double d = Math.round(5.4195);
    System.out.println(d);
  }

  /*
   *  static double random() 返回随机数 0.0-1.0之间
   *  来源,也是Random类
   */
  public static void function_5(){
    for(int i = 0 ; i < 10 ;i++){
        double d = Math.random();
        System.out.println(d);
    }
  }

15Arrays工具类

A:Arrays工具类:

 public class ArraysDemo {
        public static void main(String[] args) {
            function_2();
            int[] arr = {56,65,11,98,57,43,16,18,100,200};
            int[] newArray = test(arr);
            System.out.println(Arrays.toString(newArray));
        }
        /*
         *  定义方法,接收输入,存储的是10个人考试成绩
         *  将最后三个人的成绩,存储到新的数组中,返回新的数组
         */
        public static int[] test(int[] arr){
            //对数组排序
            Arrays.sort(arr);
            //将最后三个成绩存储到新的数组中
            int[] result = new int[3];
            //成绩数组的最后三个元素,复制到新数组中
        //  System.arraycopy(arr, 0, result, 0, 3);
            for(int i = 0 ;  i < 3 ;i++){
                result[i] = arr[i];
            }
            return result;
        }

        /*
         *  static String toString(数组)
         *  将数组变成字符串
         */
        public static void function_2(){
            int[] arr = {5,1,4,6,8,9,0};
            String s = Arrays.toString(arr);
            System.out.println(s);
        }

        /*
         *  static int binarySearch(数组, 被查找的元素)
         *  数组的二分搜索法
         *  返回元素在数组中出现的索引
         *  元素不存在, 返回的是  (-插入点-1)
         */
        public static void function_1(){
            int[] arr = {1,4,7,9,11,15,18};
            int index =  Arrays.binarySearch(arr, 10);
            System.out.println(index);
        }

        /*
         *  static void sort(数组)
         *  对数组升序排列
         */
        public static void function(){
            int[] arr = {5,1,4,6,8,9,0};
            Arrays.sort(arr);
            for (int i = 0; i < arr.length; i++) {
                System.out.println(arr[i]);
            }
        }
    }

16数组复制练习

*A:数组复制练习:

   public static void main(String[] args) {
                int[] arr = {56,65,11,98,57,43,16,18,100,200};
                int[] newArray = test(arr);
                System.out.println(Arrays.toString(newArray));
            }
            /*
             *  定义方法,接收输入,存储的是10个人考试成绩
             *  将最后三个人的成绩,存储到新的数组中,返回新的数组
             */
            public static int[] test(int[] arr){
                //对数组排序
                Arrays.sort(arr);
                //将最后三个成绩存储到新的数组中
                int[] result = new int[3];
                //成绩数组的最后三个元素,复制到新数组中
                //System.arraycopy(arr, 0, result, 0, 3);
                for(int i = 0 ;  i < 3 ;i++){
                    result[i] = arr[i];
                }
                return result;
            }

====================第四节课开始============================

17BigInteger类概述和构造方法

A:BigInteger类概述和构造方法

public static void main(String[] args) {
        function();
    }
    /*
     * BigInteger类的构造方法
     * 传递字符串,要求数字格式,没有长度限制
     */
    public static void function(){
        BigInteger b = new BigInteger("8465846668464684562385634168451684568645684564564");
        System.out.println(b);
        BigInteger b1 = new BigInteger("5861694569514568465846668464684562385634168451684568645684564564");
        System.out.println(b1);
    }

###18BigInteger类四则运算  
 A:BigInteger类四则运算
    public static void main(String[] args) {
        function_1();
    }
    /*
     * BigInteger对象的四则运算
     * 调用方法计算,计算结果也只能是BigInteger对象
     */
     public static void function_1(){
         BigInteger b1 = new BigInteger("5665464516451051581613661405146");
         BigInteger b2 = new BigInteger("965855861461465516451051581613661405146");

         //计算 b1+b2对象的和,调用方法 add
         BigInteger bigAdd = b1.add(b2);//965855867126930032902103163227322810292
         System.out.println(bigAdd);

         //计算b1-b2对象的差,调用方法subtract
         BigInteger bigSub = b1.subtract(b2);
         System.out.println(bigSub);

         //计算b1*b2对象的乘积,调用方法multiply
         BigInteger bigMul = b1.multiply(b2);
         System.out.println(bigMul);

         //计算b2/b1对象商,调用方法divied
         BigInteger bigDiv = b2.divide(b1);
         System.out.println(bigDiv);
     }

19员工案例的子类的编写

A:BigDecimal类概述

 /*
     * 计算结果,未知
     * 原因: 计算机二进制中,表示浮点数不精确造成
     * 超级大型的浮点数据,提供高精度的浮点运算, BigDecimal
    System.out.println(0.09 + 0.01);//0.09999999999999999
    System.out.println(1.0 - 0.32);//0.6799999999999999
    System.out.println(1.015 * 100);//101.49999999999999
    System.out.println(1.301 / 100);//0.013009999999999999 
    */

20BigDecimal类实现加法减法乘法

A:BigDecimal类实现加法减法乘法

  /*
     *  BigDecimal实现三则运算
     *  + - *
     */
    public static void function(){
        BigDecimal b1 =  new BigDecimal("0.09");
        BigDecimal b2 =  new BigDecimal("0.01");
        //计算b1+b2的和,调用方法add
        BigDecimal bigAdd = b1.add(b2);
        System.out.println(bigAdd);

        BigDecimal b3 = new BigDecimal("1");
        BigDecimal b4 = new BigDecimal("0.32");
        //计算b3-b2的差,调用方法subtract
        BigDecimal bigSub = b3.subtract(b4);
        System.out.println(bigSub);

        BigDecimal b5 = new BigDecimal("1.015");
        BigDecimal b6 = new BigDecimal("100");
        //计算b5*b6的成绩,调用方法 multiply
        BigDecimal bigMul = b5.multiply(b6);
        System.out.println(bigMul);
    }

21BigDecimal类实现除法

 A:BigDecimal类实现除法

 /*
      * BigDecimal实现除法运算
      * divide(BigDecimal divisor, int scale, int roundingMode) 
      * int scale : 保留几位小数
      * int roundingMode : 保留模式
      * 保留模式 阅读API文档
      *   static int ROUND_UP  向上+1
      *   static int ROUND_DOWN 直接舍去
      *   static int ROUND_HALF_UP  >= 0.5 向上+1
      *   static int ROUND_HALF_DOWN   > 0.5 向上+1 ,否则直接舍去
      */
     public static void function_1(){
        BigDecimal b1 = new BigDecimal("1.0301");
        BigDecimal b2 = new BigDecimal("100");
        //计算b1/b2的商,调用方法divied
        BigDecimal bigDiv = b1.divide(b2,2,BigDecimal.ROUND_HALF_UP);//0.01301
        System.out.println(bigDiv);
     }