day05 API异常

最新推荐文章于 2024-05-12 14:03:28 发布
最新推荐文章于 2024-05-12 14:03:28 发布
阅读量99 收藏
点赞数
分类专栏： DAY
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_48504504/article/details/106671249
版权

BigDecimal类小数

import java.math.BigDecimal;

//BigDecimal类的加减乘与BigInteger类相同,除法不同
public class BigDecimalTest {
    public static void main(String[] args) {
    method01();
    }

    /* 除法
    *  BigDecimal 进行除法运算
    *  方法名字 divide
    *  如果计算的结果，是无限小数，出现异常
    *
    *  divide方法参数 divide(BigDecimal b,int scale,int round)
    *   b : 除数
     *  scale : 保留的位数
     *  round : 舍入模式:
     *    BigDecimal定义了静态成员变量 (舍入模式)
     *    ROUND_UP  向上加1
     *    ROUND_DOWN 直接舍去
     *    ROUND_HALF_UP 四舍五入
    *
    * */
    public static void method03(){
        BigDecimal b1 = new BigDecimal("5.56");
        BigDecimal b2 = new BigDecimal("1.55");

        //b1/b2
        //保留指定的位数,进行取舍
        //BigDecimal divide = b1.divide(b2, 2, BigDecimal.ROUND_UP); 向上加1
        // BigDecimal divide = b1.divide(b2,2,BigDecimal.ROUND_DOWN); 直接舍去
        BigDecimal divide= b1.divide(b2,12,BigDecimal.ROUND_HALF_UP); //四舍五入
        System.out.println(divide);
    }




    /*加减乘
     *  BigDecimal 高精度的浮点运算
     *  四则运算,使用方式和BigInteger几乎一样
     *  +  -   *
     */
    public static void method02(){
        BigDecimal b1 = new BigDecimal("5.56");
        BigDecimal b2 = new BigDecimal("1.55");

        //b1+b2
        BigDecimal add = b1.add(b2);
        System.out.println(add);

        //b1-b2
        BigDecimal subtract = b1.subtract(b2);
        System.out.println(subtract);

        //b1*b2
        BigDecimal multiply = b1.multiply(b2);
        System.out.println(multiply);
    }





    /*
    * BigDecimal构造方法
    * 运算精确性和超级大数，选择使用String参数的构造
    *  BigDecimal(String value)
    * */
    public static void method01(){
        BigDecimal bigDecimal = new BigDecimal("132132132.156313");
        System.out.println(bigDecimal);
    }
}

--------------------------------------------------------

BigInteger类整数

import java.math.BigInteger;

/*
 *  大数据运算类
 *  基本类型 int long 取值范围
 *  数据可能远超过long的范围
 *  Java: 超过long范围的整数,
 *    java.math.BigInteger 封装了超级大整数
 *    称为BigInteger对象,超级大数计算的方式和结果,称为对象
 */
public class BigIntegerTest {
    public static void main(String[] args) {
    method02();
    }

    /*
    * BigInteger 四则运算 + - * /
    * 而是BigInteger对象的运算，计算结果不是数，是BigInteger对象
    * add（BigInteger）+运算
    * subtract(BigInteger) -运算
    * multiply(BigInteger) *运算
    * divide(BigInteger) /运算
    * */

    public static void method02(){
        BigInteger b1 = new BigInteger("1564165341653454165321");
        BigInteger b2 = new BigInteger("1231345646");

        //b1对象+b2对象
        BigInteger add = b1.add(b2);
        System.out.println(add);

        //b1对象-b2对象
        BigInteger subtract = b1.subtract(b2);
        System.out.println(subtract);

        //b1对象*b2对象
        BigInteger multiply = b1.multiply(b2);
        System.out.println(multiply);

        //b1对象/b2对象
        BigInteger divide = b1.divide(b2);
        System.out.println(divide);
    }




    /*
    * BigInteger构造方法
    * BigInteger(String value)可以传递任意长度的整数
    * */

    public static void method01(){
        BigInteger bigInteger = new BigInteger("45643135416532413524165324156532416");
        System.out.println(bigInteger);
    }


}

--------------------------------------------------------

Math类

/*
 *  java.lang.Math类,数学计算类
 *   最终类,不能继承
 *   Math类的方法全部静态修饰,类名调用即可
 *   私有构造方法
 */
public class MathTest {
    public static void main(String[] args) {
        method02();
    }


    /*
    * static double sqrt(double d)
    * 计算参数的平方根
    * */
    public static void method07(){
        double sqrt = Math.sqrt(4);
        System.out.println(sqrt);
    }




    /*
    * static double random()
    * 产生随机数：是浮点型，范围0.0-1.0之间
    * 范围：可能是0.0，不可能到1.0
    * */
    public static void method06(){
        for (int i = 0; i < 10; i++) {
            double random = Math.random();
            System.out.println(random);
        }
    }


    /*
    * static double pow(double a,double b)
    * 幂运算：a的b次幂
    * poe(2,3)   2的3次方
    * */
    public static void method05(){
        double pow = Math.pow(2, 3);
        System.out.println(pow);
    }



    /*
    * static long round (double d)
    * 对参数进行四舍五入，取整数部分
    * 算法：参数d+0.5
    * */
    public static void method04(){
        long round = Math.round(5.4999);
        System.out.println(round);
    }



    /*
    * static double floor(double d)
    * 向下取整
    * */
    public static void method03(){
        double floor = Math.floor(11.2);
        System.out.println(floor);
    }



    /*
    * static double ceil(double d)
    * 传递参数返回结果，结果大于或者等于参数
    * 向上取整数
    * */
    public static void method02(){
        double ceil = Math.ceil(8.1);
        double ceil02 = Math.ceil(-18.1);
        System.out.println(ceil);
        System.out.println(ceil02);
    }



    /*
    * static int abs(int a)
    * 绝对值：传递参数，返回他的绝对值
    * */
    public static void method01(){
        int abs = Math.abs(-5);
        System.out.println(abs);
    }
}

--------------------------------------------------------

基本类型包装类

/*
 *  基本数据类型,对象包装类
 *  提供8个基本类型,除去布尔类型以外,其他类型进行基本数学计算
 *  JDK提供每个基本类型的包装类, 一切多是对象,基本数据类型也是对象
 *  基本类型对应的包装类（位于java.lang包中）
 *  byte    Byte
 *  short   Short
 *  int     Integer
 *  long    Long
 *  float   Float
 *  double  Double
 *  char    Character
 *  boolean Boolean
 */
public class BaseTest {
    public static void main(String[] args) {
        //范围
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);

        System.out.println(Long.MAX_VALUE);
        System.out.println(Long.MIN_VALUE);

        System.out.println(Double.MAX_VALUE);
        System.out.println(Double.MIN_VALUE);
    }
}

01 Integer类
字符串转成Integer对象

/*
 *  int类型的对象包装类 java.lang.Integer
 *  包装int类型 ,基本类型提供了更多的功能
 */
public class IntegerTest01字符串转成Integer对象 {
    public static void main(String[] args) {
        method02();
    }

    /*第二种
     * static Integer valueOf(String s)传递字符串,字符串转成Integer对象
     */
    public static void method02(){
        Integer integer = Integer.valueOf("100");
        System.out.println(integer);
    }




    /*第一种
     * Integer 类的构造方法
     * Integer(String s) 传递字符串,字符串转成Integer对象
     * 注意: 字符串必须是数字格式
     */
    public static void method01(){
        Integer integer = new Integer("100");
        System.out.println(integer);
    }
}

字符串转成int

/*
 * 基本数据类型包装类:
 *   实现了基本数据类型和字符串的互转
 *   "100"数据类型是String  "100"+1 1001
 */
public class IntegerTest02字符串转成int {
    public static void main(String[] args) {
        method02();
    }
    /*第二种
     * 使用Integer类的非静态方法，需要new对象
     * intValue() 返回值int类型
     * 将Integer构造方法中的字符串转成int
     */
    public static void method02(){
        Integer integer = new Integer("100");
        int i = integer.intValue();//构造方法中的字符串转成int
        System.out.println(i+1);
    }




    /*第一种
     *  Integer类静态方法，直接.调用
     *  static int parseInt(String str)方法参数字符串,转成int基本类型
     *  必须数字格式字符串
     */
    public static void method01(){
        int i = Integer.parseInt("100");
        System.out.println(i+1);
    }

}

02 自动装箱和拆箱

import java.util.ArrayList;

/*
 * JDK5版本,出现新特性: 自动装箱和自动拆箱
 * 自动装箱 : 基本数据类型自动包装成对象
 * 自动拆箱 : 对象在自动转成基本数据类型
 */
public class AutoBoxTest101 {
    public static void main(String[] args) {
    method03();
    }



    /*
     * 自动装箱和自动拆箱例子
     */
public static void method03(){
    //创建集合,ArrayList 存储整数
    ArrayList<Integer> list = new ArrayList<>();
    //存储的时候,自动装箱, 自动提升为Integer对象
    list.add(100);
    list.add(200);
    list.add(300);
    for (int i = 0; i < list.size(); i++) {
        //合理,自动拆箱
        int j=list.get(i);
        System.out.println(j);
    }
}



    /*
     *  代码上出现问题:
     *    任何引用类型,都可以赋值为null
     */
    public static void method02(){
        Integer i=null;
        if(i!=null){
            i=i+1; //拆箱, i.intValue()
            System.out.println(i);
        }
    }



    /*
     * 自动装箱和拆箱
     */
public static void method01(){
    //基本类型的数据,赋值到引用类型,自动装箱过程
    //自动将基本类型1,封装成Integer对象
    Integer i=1;//等同于 i = new Integer(1)

    //先将引用类型i,转成基本类型(自动拆箱)
    //i+1的结果,还是基本类型, 赋值的时候,进行了装箱操作
    i=i+1;//等同于  i.intValue()+1 -->拆箱  结果等到2  装箱

    System.out.println(i);
}

}


public class AutoBoxTest102细节问题 {
    public static void main(String[] args) {
        method();
    }
    /*
     * 自动装箱和拆箱细节问题
     */
    public static void method(){
        Integer ii = new Integer(100);
        Integer jj = new Integer(100);
        System.out.println(ii==jj);//引用类型比较地址  F
        System.out.println(ii.equals(jj));//继承Object,重写方法equals,比较的具体数据 T
        System.out.println("----------------------------");

        Integer a=200;//new Integer(200)
        Integer b=200;
        System.out.println(a==b);//引用类型比较地址 F
        System.out.println(a.equals(b));//继承Object,重写方法equals,比较的具体数据 T
        System.out.println("----------------------------");

        /*
         * 数据在byte范围内,从缓存中取出对象使用,不会new
         * -128到127的范围，为了节约内存空间
         * 200大于，所以new了对象，比较地址值
         * 而100在范围内，直接用，比较数值大小
         */
        Integer aa=100;// static Integer Integer.valueOf(100)
        Integer bb=100;
        System.out.println(aa==bb);//引用类型比较地址  True
        System.out.println(aa.equals(bb));//继承Object,重写方法equals,比较的具体数据 T
    }
}

--------------------------------------------------------

异常
01

/*
* 异常：
*    定义就是指程序在运行期间，出现的不正常现象
*    面向对象语言，什么都是对象，异常也是对象
*    对象是由类产生的，new对象（）
*
*    java.lang.Throwable类，是java语言中所有错误和异常的父类
*    具有2个子类：Error，Exception
*
*    Error:表示程序中的所有错误
*          程序中出现了严重问题，不能修改源代码，不能执行
*          比如：非典，艾滋病，癌症
*
*    Exception：表示程序中的所有异常
*           程序中出现的小问题，处理完，程序继续执行
*           比如：扎刺，阑尾炎
*
*     异常的继承体系：
*           Throwable类中的方法，所有的子类具备
*           String toString():返回字符串，表示异常信息的简短描述
*           String getMessage（）：返回字符串，表示异常信息的详细描述
*           void  printStackTrace(): 将异常信息,追踪到标准错误流
* */
public class ExceptionTest01 {
    public static void main(String[] args) {
        int[]arr=new int[99999999];
    }
}

02

/*
* 异常：
*    异常产生的过程和JVM的默认处理方式
*
*    以前的程序，出现异常的几率很大
* */
public class ExceptionTest02 {
    public static void main(String[] args) {
        int[]arr={1,2,3,4,5};
        int element = getElement(arr, 5);
        System.out.println(element);
        System.out.println("程序结束");

    }
    /*
     * 创建方法: 传递数组和索引
     * 返回该索引上的元素
     */
    public static int getElement(int[]arr,int index){
        return arr[index];
    }
}
//ArrayIndexOutOfBoundsException用非法索引访问数组时抛出的异常。如果索引为负或大于等于数组大小，则该索引为非法索引。

03

/*
 *  异常处理,自己处理,不让JVM处理
 *  异常处理的方式: try(尝试) catch(捕获)方式
 *  try{
 *      要被检测的代码
 *      可能出现异常的代码
 *  }catch(异常类的类名  变量名){
 *      异常的处理方式代码
 *      写输出语句,循环,判断,调用方法...
 *  }finally{
 *      一定要执行的代码
 *  }
 */
public class ExceptionTest03 {
    public static void main(String[] args) {
        int[]arr={1,2,3,4,5};
        try {
            int element = getElement(arr, 5);
            System.out.println(element);
        }catch (Exception ex){
            System.out.println("异常被处理了");
        }
        System.out.println("程序结束");
    }
    /*
     * 创建方法: 传递数组和索引
     * 返回该索引上的元素
     */
    public static int getElement(int[]arr,int index){
        return arr[index];
    }
}

04

/*
 *  多catch并行处理
 *  try{
 *
 *  }catch(异常类名  变量){
 *
 *  }catch(异常类名  变量){
 *
 *  }
 *
 *  ArrayIndexOutOfBoundsException和NullPointerException
 *  当多个catch中,捕获的异常类,没有父子关系的时候,先写谁都可以
 *
 *  ArrayIndexOutOfBoundsException继承IndexOutOfBoundsException
 *  IndexOutOfBoundsException继承RuntimeException
 *
 *  NullPointerException继承RuntimeException
 *
 *  当多个catch中,捕获的异常类,异常类之间存在继承关系
 *  越是父类,越往后写
 */
public class ExceptionTest04 {
    public static void main(String[] args) {
        //进行异常处理了
        try {
            show(10);
        }catch (ArrayIndexOutOfBoundsException ex){
            System.out.println("处理了数组越界异常");
        }catch (NullPointerException ex){
            System.out.println("处理了空指针异常");
        }
    }





    /*
     * 创建方法,设置一个参数int类型
     * 要求:
     *    参数传递的是0,方法抛出数组的越界异常
     *    参数传递的是非0,方法抛出空指针异常
     */
    public static void show(int i){
        if(i==0){
            //方法抛出数组的越界异常
            int[]arr=new  int[1];
            arr[1]=1;
        }else {
            int[]arr=null;
            arr[i]=1;
        }
    }
}

05

/*
 * 多个catch合并为一个catch
 *   catch中捕获的异常类,没有继承关系
 *   不推荐使用: 多个合并为一个之后,处理方式只有一个
 */
public class ExceptionTest05{
    public static void main(String[] args) {
        //进行异常处理了
        try {
            show(10);
        }catch (ArrayIndexOutOfBoundsException | NullPointerException ex){
            System.out.println("异常被处理了");
        }
    }
    /*
     * 创建方法,设置一个参数int类型
     * 要求:
     *    参数传递的是0,方法抛出数组的越界异常
     *    参数传递的是非0,方法抛出空指针异常
     */
    public static void show(int i){
        if(i==0){
            //方法抛出数组的越界异常
            int[]arr=new  int[1];
            arr[1]=1;
        }else {
            int[]arr=null;
            arr[1]=1;
        }
    }
}

06

/*
 * finally代码块
 *   try{
 *
 *   }catch(异常类 变量名){
 *
 *   }finally{
 *
 *   }
 *
 *   作用: 无论程序是否出现异常,finally代码块中的程序必须执行
 *   释放资源
 *
 */
public class ExceptionTest06 {
    public static void main(String[] args) {
        int[]arr={1,2,3,4,5};
        try {
            int element = getElement(arr, 5);
            System.out.println(element);
        }catch (Exception ex){
            System.out.println("异常被处理了");
        }finally {
            System.out.println("这里必须执行");
        }
    }
    /*
     * 创建方法: 传递数组和索引
     * 返回该索引上的元素
     */
    public static int getElement(int[]arr,int index){
        return arr[index];
    }
}

07

/*
 *   Throwable类定义了三个方法
 *       String toString(): 返回字符串,表示异常信息的简短描述
 *       String getMessage(): 返回字符串,表示异常信息的详细描述
 *       void printStackTrace(): 将异常信息,追踪到标准错误流
 */
public class ExceptionTest07 {
    public static void main(String[] args) {
        int []arr={1,2,3};
        try {
            int element = getElement(arr, 10);
            System.out.println(element);
        }
        //捕获到异常   Exception ex =  new ArrayIndexOutOfBoundsException();
        //多态性: 变量ex调用方法
        catch (Exception ex){
            System.out.println(ex);// 返回字符串,表示异常信息的简短描述  java.lang.ArrayIndexOutOfBoundsException: 10
            String message = ex.getMessage();
            System.out.println(message);// 返回字符串,表示异常信息的详细描述  10

            ex.printStackTrace();
        }

    }
    public static int getElement(int[]arr ,int index){
        /*
         * 数组的索引不存在
         * 产生异常的对象 new ArrayIndexOutOfBoundsException()
         * 对象会被抛出,方法的调用者
         */
        return arr[index];
    }
}

08

/*
 *  异常处理:
 *   关键字 throw, throws
 *   throw: 关键字: 只能写在方法内部, 后面必须是new出来的异常对象
 *   throws: 关键字: 只能写在方法的声明上,后面必须是异常类的类名
 */
public class ExceptionTest08 {
    public static void main(String[] args) {
        int[]arr={1,2,3};
        //调用的方法,抛出异常,调用者,处理异常 try catch
        try {
            getElement(arr,10);
        }catch (Exception ex){
            ex.printStackTrace();
        }
    }
    /*
     *  判断索引的合法性
     *  变量index,必须是合法的索引,否则不能返回
     *
     *  你是计算个税计算器  -10
     *
     *  方法的定义上,表现出来方法中有异常
     *  关键字 throws
     */
    public static int getElement(int[]arr,int index) throws Exception {
        if(index<0||index>arr.length-1){
            throw new Exception();
        }
        return arr[index];
    }
}

09


import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

/*
 *  异常分类:
 *    Exception 所有异常的父类 (继承Throwable)
 *     |-- RuntimeException 运行异常|-- 所有子类
 *
 *     |-- 非RuntimeException 编译异常
 *
 *   方法中抛出的异常是运行异常: 不能抓,修改源码
 *   方法中抛出的异常是编译异常: try catch 或者throws
 */
public class ExceptionTest09 {
    public static void main(String[] args) throws Exception {
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String str="2019-11-20";
        /*
         *  调用了抛出异常的方法
         *  抛出的异常是编译异常
         *  调用者必须处理,否则编译失败
         *  try catch  throws
         */
        Date date = simpleDateFormat.parse(str);
        System.out.println(date);

        /*
         * 方法抛出异常是运行异常
         * 方法中抛出的异常是运行异常,方法的声明上不需要写throws
         * 定义方法的这个人,不打算让调用者去抓这个异常
         * 一旦程序真的抛出运行异常 (初衷: 不要去抓,修改源码)
         */
        int i = Integer.parseInt("10a0");
        System.out.println(i+1);
    }
}

10

public class FuShuExcepetion extends Exception {
    /*
     * Exception类,带有String参数的构造方法
     * 赋值异常的消息,调用父类的构造方法,传递异常信息
     */
    public FuShuExcepetion(String message){
        super(message);
    }
}


/*
 * 自定义异常
 *  定义类继承Exception
 */
public class ExceptionTest10 {
    public static void main(String[] args) {

        try {
            int avg = getAvg(90, 90, -90);
            System.out.println(avg);
        }catch (FuShuExcepetion ex){
            ex.printStackTrace();
        }
    }

    /*
     *  创建方法,计算学生考试的平均分
     *  三个成绩,数学,语文,英语
     *  成绩不能是负数,如果是负数,不能计算
     *  告诉方法调用者成绩是负数,利用异常
     */

    public static int getAvg(int math,int chinese,int english)throws FuShuExcepetion{
        if(math<0){
            //手动抛出负数成绩异常
            throw new FuShuExcepetion("数学成绩是负数");
        }
        if(chinese<0){
            //手动抛出负数成绩异常
            throw new FuShuExcepetion("语文成绩是负数");
        }
        if(english<0){
            //手动抛出负数成绩异常
            throw new FuShuExcepetion("英语成绩是负数");
        }
        return (math+chinese+english)/3;
    }
}

11

class Fu{
    public void show(){

    }
}
class Zi extends Fu{
    public void show(){

    }
}
/*
 *  子类父类异常处理
 *  1: 如果父类的方法抛出了异常
 *    子类重写: 可以不抛出异常,也可以抛出异常
 *    但是: 子类抛出的异常,不能大于父类抛出的异常
 *    重写父类的方法,保证方法的声明和父类一致
 *
 *  2: 如果父类的方法没有异常抛出
 *   子类就不能抛出,子类方法中, 调用了抛出异常的方法,只能try catch
 *
 *  线程: 重写接口中的方法run()
 */
public class ExceptionTest11 {
    public static void main(String[] args) {
        Fu fu=new Zi();
        fu.show();
    }
}

--------------------------------------------------------

m7y7m7y7m7y7
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day13_API-异常.pdf
11-02
Java 中的 Math、BigInteger 和 BigDecimal 类 Java 语言中提供了多种数学类来帮助开发者进行数学运算，包括 Math、BigInteger 和 BigDecimal 类。这些类提供了丰富的数学方法，帮助开发者快速高效地进行数学运算。...
day05-Elasticsearch01day05-Elasticsearch01
10-25
在“day05-Elasticsearch01day05-Elasticsearch01”这个主题中，我们可以深入探讨Elasticsearch的基础概念、核心特性以及常见应用场景。 一、Elasticsearch基础 1. 数据模型：Elasticsearch基于Lucene构建，使用倒...
Big5中文字输出
abc13848089196的博客
09-01 260
目的把想要輸出的字型，寫到一個File裡面，再利用讀檔的方式，透過倚天字碼查表，然後轉換成一連串的101010101，設計成一個testbench使第二組能夠接受Step1：輸入測資(中文字)Step2：讀出輸入字的內碼(Big 5)Step3：以內碼尋找該字在stdfont.15內的位置Step4：將stdfont.15裡的資料取出成為bitmapStep5：將bitmap轉成vw...
day13-常用API&异常
at10090的博客
06-27 209
1.包装类 1.1基本类型包装类（记忆） 基本类型包装类的作用 ​ 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据 ​ 常用的操作之一：用于基本数据类型与字符串之间的转换 基本类型对应的包装类 基本数据类型 包装类 byte Byte short Short int Integer long Long float Float ...
使用 electron-builder 及 electron-updater 给项目配置自动更新
热门推荐
Wonder233的学习博客
06-04 2万+
说明： 本文的自动更新功能使用的项目为 electron-vue 脚手架搭建一个默认项目。 参考的文章如下： electron-vue 中文文档 electron-builder 文档 Windows 下支持自动更新的 Electron 应用脚手架 Electron 文档 Docs / API / autoUpdater encapsulated manual update via me...
Day15 常用API 异常机制
weixin_46209942的博客
01-17 465
1 . Biglnteger 1.1 概述 1. Integer 类作为 int的包装类,能存储的最大整型值为231-1,Long类也是有限的,最大为263-1.如果要表示再大的整数,不管时基本数据类型还是他们的包装类 都无能为力,更不用说进行运算了. 2. java.math包的BigInteger 可以表示不可变的任意精度的整数. 1.2 常用方法 public BigInteger abs(): 返回此 BigInteger 的绝对值 BigInteger add(BigInteger v
day09-常用API&异常
qq_74289024的博客
05-12 556
自定义异常概述当Java中提供的异常不能满足我们的需求时,我们可以自定义异常实现步骤定义异常类写继承关系提供空参构造提供带参构造代码实现异常类/*** 自定义异常*///1. 继承RuntimeException// 2. 重写构造器学生类return age;}else{//如果Java中提供的异常不能满足我们的需求,我们可以使用自定义的异常throw new AgeOutOfBoundsException("年龄超出了范围");@Override。
Java web day05
qq_44884264的博客
03-29 720
JDBC：用Java语言操作关系型数据库的一套API（应用程序接口） 一套规则，又叫做一套标准接口 java database connectivity java数据库连接 String sql = "select * from emp where empno=7369"; //列名标识符无效 try { //1.加载驱动 驱动 [类] jar包里 Class.forName("com.mysql.jd...
day14_日期类_异常
m0_58073753的博客
03-07 1901
日期类，异常，练习
Java API
山水子农
06-01 1953
Java语言的强大功能主要体现在Java语言完备丰富、功能强大的Java API上。本章介绍Java API的基本结构以及语言包和实用包中的常用类。 1、Java API 综述    Java语言的内核非常小，Java语言的强大功能主要体现在Java语言完备丰富、功能强大的Java API上。   Java API（Java Application Programming Interfa
JavaAPI02
weixin_45899964的博客
07-29 3330
APIDay02???? 日期操作 1.Date及常用API 表示当前系统时间 Date date=new Date()； package LittleRabbit.Time; import java.util.Date; public class DateDemo { public static void main(String[] args) { Date now = new Date(); /** * Date重写了toString
day04-常用API&异常
06-11
day04-常用API&异常
day04-常用API&异常1
08-04
在“day04-常用API&异常1”的学习中，我们将关注以下几个关键知识点： 1. **基本类型包装类** Java的8种基本数据类型（byte, short, int, long, float, double, char, boolean）都有对应的包装类，如Integer对应...
瑞吉外卖-全网最全笔记-Day05
eadzsdad的博客
04-24 6190
黑马教程-瑞吉外卖，基于流行的Spring Boot、mybatis plus等技术框架进行开发，带领学员体验真实项目开发流程、需求分析过程和代码实现过程。能够收获：锻炼需求分析能力、编码能力、bug调试能力，增长开发经验。阿里云验证码测试。
NET语言程序设计课件-第2章 Visual C#.NET语法基础.ppt
最新发布
08-08
Visual C# .NET是一门面向对象的程序设计语言，是当前流行的.NET系列的语言。 本课程以Visual Studio为程序设计环境，对C#进行了全面阐述。 本电子课件适用于课程讲解或者课程分析参考使用。
[毕业设计]PHP图书借阅与归还管理系统(源代码+论文).zip
08-08
[毕业设计]PHP图书借阅与归还管理系统(源代码+论文)
ssm_012_mysql宝康药房销售管理系统.zip
08-08
随着我国市场经济的蓬勃发展和人们对医药产品需求的迅速增加，医药销售行业正处于一个高速发展的时期。行业的快速发展必然导致竞争的加剧，面对药品销售业日益严酷的竟争现实，加强管理、提高工作效率和改善服务质量成了急待解决的问题。而解决这些问题的关键措施之一就是利用计算机等现代信息技术，建立实用、先进、高效的药房销售管理系统，引进创新的经营机制，实现药品销售过程的全面信息化管理，以适应企业生存和发展的新形势。因此，开发一个宝康药房销售管理系统是十分必要的。 根据需求，确定系统采用JSP技术，SSM框架，JAVA作为编程语言，MySQL作为数据库。整个系统要操作方便、易于维护、灵活实用。主要实现了频道维护、新闻维护、药品维护、订单维护、系统管理等功能。
excel基本操作.pptx
08-08
excel基本操作.pptx
Java Math, BigInteger, BigDecimal: 大整数与精确浮点运算及异常处理
在Java编程中，"day13_API-异常.pdf"文档主要探讨了Math类、BigInteger类和BigDecimal类在处理异常和进行高级数学运算时的应用。这些类在处理涉及数值计算，尤其是当涉及到超出基本数据类型范围（如int、double）时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值