小白学习Java第十二天

最新推荐文章于 2024-06-09 18:24:15 发布
最新推荐文章于 2024-06-09 18:24:15 发布
阅读量435 收藏 1
点赞数 1
分类专栏： Java小白 文章标签： java 学习 jvm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjxxxx_/article/details/126411830
版权

复习

1.String类

1.转换方法
getBytes() toCharArray()…
2.其他方法
trim() split()

2.字符串缓冲区对象

StringBuffer/StringBuilder
可变的字符序列。
append、insert、delete、replace、reverse、length()
字符串缓冲区对象和String对象的互转。

3.包装类

一共有8个，final类。
Integer：
构造方法：
new Integer(int)
new Integer(String)
方法：
intValue()
static parseInt(String)

    十进制与其他进制间的转换。
 自动装箱和拆箱：
    Integer in = 123;
    int  num = in;

与基本类型和String间的转换：

 包装类<--->基本类型  包装类<--->String   基本类型<--->String

课程

一. Math

1、两个常量
E：自然对数的底数，2.718
PI：圆周率
2、常用方法
abs(数字类型)，返回该参数的绝对值
ceil(double d)，返回d的向上取整
floor(double d)，返回d的向下取整
max(int a, int b)，返回a、b的较大值
min(int a, int )，返回a、b的较小值
pow(int a, int b)，返回a的b次幂
random()，返回0.000~0.999的随机数
round(double d)，返回d四舍五入的结果

import java.util.Random;

public class Demo1 {
    public static void main(String[] args) {
        //常量
        System.out.println(Math.PI);
        System.out.println(Math.E);

        //方法：
        //取绝对值  参数类型：int long float double   返回值类型：int long float double
        System.out.println(Math.abs(-8));
        //开立方根  参数类型：double  返回值类型：double
        System.out.println(Math.cbrt(27));
        //获取大于参数的最小整数   参数类型：double  返回值类型：double
        System.out.println(Math.ceil(3.4));
        //获取小于参数的最大整数   参数类型：double  返回值类型：double
        System.out.println(Math.floor(3.4));
        //获取两个数中的大值  参数类型：int long float double   返回值类型：int long float double
        System.out.println(Math.max(4,5));
        //获取两个数中的小值  参数类型：int long float double   返回值类型：int long float double
        System.out.println(Math.min(4,5));
        //计算参数1的参数2的次幂  参数类型：double  返回值类型：double
        System.out.println(Math.pow(2,3));
        //四舍五入  参数类型 ：double 、float   返回值类型：long  int
        System.out.println(Math.round(4.16));
        //开平方根  参数类型：double  返回值类型：double
        System.out.println(Math.sqrt(4));

        //获取随机数
        System.out.println((int)(Math.random()*10+1)); //double [0.0,1.0)

        //随机数生成器
        Random ran = new Random();
        System.out.println(ran.nextDouble()) ; //该方法与 math.random 方法结果是相同的，返回：double [0.0,1.0)
        System.out.println(ran.nextInt());  //返回 int范围内的某一个值
        System.out.println(ran.nextInt(5)); //返回 [0,5)区间内的一个整数
    }
}

/*
* java.lang.Math:
*   数学类，是一个final，类中封装了常规的数学计算。
*   类中的成员都是静态的，不需要创建对象。
* */

二. System类及其常用方法

1、用于描述系统资源的类型，System是一个和系统相关的类，里面提供了一些系统常用的方法，例如调用垃圾回收机制，给出系统时间，关闭虚拟机等。该类不用创建对象，因为构造方法私有, 直接使用静态变量和静态方法即可
2、常用字段(静态常量)：
System.in：标准输入流，默认关联到键盘上
举例 : Scanner sc = new Scanner(System.in);
System.out：标准输出流，默认关联到控制台上
举例 : System.out.println(数据);
System.err：标准错误输出流，默认关联到控制台上，用于打印错误信息，使用该流打印的内容是红色
举例 : 如果代码中发生异常, JVM即使用System.err将异常信息进行输出
3、常用方法全部都是static修饰：
(1) currentTimeMillis()：
返回当前时间的毫秒值，表示的是从1970年1月1日0时0分0秒开始到现在经历的毫秒值，1s = 1000ms。
应用：1、可以通过某些手段，将数字转换成时间对象、指定格式的字符串；2、可以通过计算两次的差值，来获取某段代码运行的时间

(2) static void exit(int status): 退出JVM虚拟机,参数0表示正常终止

import java.util.Properties;

public class Demo3 {
    public static void main(String[] args) {
        //属性
        System.out.println("标准输出流");
        System.err.println("标准错误输出流");

        //方法：
        System.exit(0);  //jvm退出，参数：通常写0，代表正常退出。非0数字代表异常退出。

        //获取当前系统时间毫秒值   1秒=1000毫秒
        //起始之间：1970年 1月1日 0:0:0
        long times = System.currentTimeMillis();
        System.out.println(times);


        //获取系统信息,  存储到属性集信息对象中。property
        Properties properties = System.getProperties();
        properties.list(System.out);
    }
}
/*
* System：
*   系统类，final类，java.lang包。
*   类中的成员都是 静态的，因此不需要创建对象，直接类名访问。
*
*  属性：
*    in: 标准的输入流(数据)，默认设备：键盘
*    out：标准的输出流(数据)： 默认设备：控制台窗口
*    err: 标准的错误输出流(数据)： 默认设备：控制台窗口，输出数据时位置不固定。
* */

三. 时间类

(一) 日期Date类型及其常用方法

  1. 概述: Date表示特定的瞬间,精确到毫秒.是java中提供的表示时间日期数据的对象,但是这个类,其中大部分的方法已经过时,由Calendar和DateFormat类代替.

  2. Date类构造方法:

    1. public Date(): 分配 Date 对象并初始化此对象,以表示分配它的时间(精确到毫秒)
    2. public Date(long date): 分配 Date 对象并初始化此对象,以表示自从标准基准时间(称为"历元(epoch)",即 1970 年 1 月 1 日 00:00:00 GMT)以来的指定毫秒数

  3. Date类常用方法

    1. long getTime():
      返回自1970 年1月1日 00:00:00 GMT 以来此 Date 对象表示的毫秒数
    2. void setTime(long time)
      设置此Date对象,以表示 1970 年1月1日 00:00:00 GMT 以后 time 毫秒的对应时间点
import java.util.Date;

public class Demo4 {
    public static void main(String[] args) {
        //创建日期对象
        Date  date = new Date();
        System.out.println(date.toString()); //Thu Aug 18 11:29:34 CST 2022  当前系统时间值

        Date date1 =  new Date(System.currentTimeMillis()); //参数：毫秒值，将毫秒值转为Date对象。
        System.out.println(date1);


        //方法：
        //获取系统时间毫秒值
        long time = new Date().getTime();
        System.out.println(time);

        //根据毫秒值设置date对象
        Date d = new Date();
        d.setTime(1660793674152L);
        System.out.println(d);
    }
}

/*
* 日期对象：
*  java.util.Date。
*  表示特定的瞬间，可以精确到毫秒。
* */

(二) SimpleDateFormat类及其常用方法

  1. 概述：简单的日期格式化类，提供了日期的格式化的方法

  2. SimpleDateFormat类常用构造方法

    1. SimpleDateFormat(): 用默认的模式和默认语言环境的日期格式创建对象
    2. SimpleDateFormat(String pattern)
      用给定的模式和默认语言环境的日期格式创建对象，
      一般pattern传递的是 “yyyy-MM-dd HH:mm:ss”
      例如：2021-03-02 16:48:22

  3. SimpleDateFormat类常用方法

    1. final String format(Date date): 将一个 Date 格式化为日期/时间字符串
    2. Date parse(String source) throws ParseException: 从给定字符串解析文本，以生成一个日期
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Demo5 {
    public static void main(String[] args) {
        Date date = new Date();
        DateFormat df = DateFormat.getInstance();//22-8-18 下午2:03
        DateFormat df = DateFormat.getDateInstance(); //2022-8-18
        DateFormat df = DateFormat.getDateTimeInstance(); //2022-8-18 14:02:59
        String time = df.format(date);
        System.out.println(time);

        //日期格式化  api有对应的表格
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
        String time = sdf.format(date); //日期对象转为文本格式
        System.out.println(time);

        //文本格式的字符串 ----日期对象
        String  str = "2020年08月18日 02:09:20";
        //注意：文本内容格式  与 模式的格式要匹配，否则出异常。
        try {
            Date d = sdf.parse(str);
            System.out.println(d);
        } catch (ParseException e) {
            System.out.println("文本格式不正确");
        }

        System.out.println(args[0]);
    }
}
/*
* 日期格式化对象：
*     Date默认给定的日期格式不方便阅读，因此可以自己指定想要的日期格式。
*     java.text.DateFormat
*       该类中提供了format方法，用于将日期进行格式化。
*       该类是一个抽象类，不可以直接new，类中提供了静态方法用于获取该类的实例对象：
*         getInstance()/getDateInstance()/getDateTimeInstance()...
*       该类有一个子类，SimpleDateFormat，可以指定日期格式。
*
*
* */

import java.util.Calendar;
import java.util.Date;

public class Demo6 {
    public static void main(String[] args) {
        //获取日历对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);

        //获取指定字段信息
        int year = c.get(Calendar.YEAR);
        int y = c.get(1);
        System.out.println(year+"...."+y);
        //注意：month的值是：0-11，因此需要手动+1.
        int month = c.get(Calendar.MONTH);
        System.out.println(month);

        int hour = c.get(Calendar.HOUR_OF_DAY); //小时，24小时制
        System.out.println(hour);

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

        //获取毫秒值
        long times = c.getTimeInMillis();
        System.out.println(times);

        //根据毫秒值，设置日历对象
        c.setTimeInMillis(times);
        System.out.println(c);

        System.out.println("------------------------------------");
        //日期对象  和 日历对象可以互转
        Date date = c.getTime();  //日历--->日期
        c.setTime(date); // 日期--->日历

    }
}


/*
* 日历对象：
*    Calendar：
*     java.util包中的一员。
*     该类是一个抽象类，不可以直接new，类中提供了 getInstance()方法，用于获取该类的实例对象。
* */

四.异常

(一)异常的概述

  1. 异常概述: 在java程序运行过程中，出现的不正常情况，出现的错误，称为异常。
  2. Java中的每一种异常都封装成一个类, 当异常发生时创建出异常对象，对象中包含了异常情况的原因、类型、描述以及位置。
  3. 异常也是一种处理异常情况的机制，可以进行跳转、捕获以及结束程序。

(二)异常的体系

1、Throwable：可抛出的，是异常体系的顶层父类，其他的异常或者错误都是Throwable的子类类型，只有Throwable的体系类型，才可以使用异常的处理机制

2、Error：错误，是Throwable的子类，用于描述那些无法捕获和处理的错误情况，属于非常严重的错误，StackOverflowError

3、Exception：异常，是Throwable的子类，用于描述那些可以捕获和处理的例外情况，属于不太严重的错误，ArrayIndexOutOfBoundsException

4、RuntimeException：运行时异常，是Exception的特殊的子类，在编译阶段不做检查的一个异常

5、异常体系结构：

Throwable
 	Error
 	Exception
 	 	RuntimeException : 运行时异常
        除RuntimeException 之外: 编译时期异常

(三)在jvm中默认处理异常的机制

1、在代码的某个位置，出现了和正常情况不同的情况，就将异常情况封装到一个异常对象中。

2、将异常对象抛给调用该方法的方法

3、某个方法接收到底层方法抛上来的异常，也没有办法自己处理，继续向上抛出，最终抛给主方法，主方法也没有办法处理，抛给调用自己的jvm虚拟机

4、jvm虚拟机是我们手动调用的，只能将异常对象的所有信息，通过错误流打印出来，结束jvm虚拟机

5、总结，jvm默认处理的方式：【一层一层向上抛，jvm接收到之后结束自己】

(四)手动处理异常的方式

1、有两大类处理异常的方式：
异常的声明：某个方法有编译时异常，编译就会无法通过，需要在异常所在的方法声明上，声明该方法可能出现的编译时异常
异常的处理：出现异常之后，可以通过某些格式来捕获和处理异常，可以让程序在出现异常之后，继续运行。可以定义自己处理异常的逻辑。

2、捕获处理异常的代码格式：
try…catch
try…catch…finally
try…finally（无法捕获处理异常）

(五)try…catch语句

1、格式：

try {
 	可能发生异常的代码
} catch(可能出现异常的类型 标识符) {
	这种异常出现之后的处理方式
}

2、try：关键字, 试一试
try语句块中，是可能会运行失败的代码，try语句是用于对异常进行检测

3、catch：关键字, 捕获
抓住try语句中出现的异常，并且定义异常处理的方式
小括号中声明可能出现的异常类型，标识符就是一个引用，指向了将来出现的异常对象
大括号中用于定义异常出现之后的处理方式：可以是记录日志、可以是反复运行、可能是把异常封装进新的异常，进行抛出

4、运行机制：

  1. 运行try语句中的代码
  2. 如果没有发生任何异常，那么不再运行catch块中的内容
  3. 如果发生了catch中声明的异常，那么就会被捕获到这个异常，执行catch块中的内容（try中如果发生了异常，try中，该语句后面的代码都无法执行了，直接跳到catch中）
  4. 如果发生了catch中没有声明的异常，那么就无法捕获该异常，该异常的处理就使用jvm的默认处理方式

(六)try…catch…catch…语句

1、在一段代码中，可能出现多种异常（虽然一次运行只能出现一个异常，但是出现哪个异常我们是不清楚的），所以要准备多种异常情况的处理机制。

2、格式：

try {
 	可能出现异常的代码
} catch (异常类型1  异常对象名1) {
	异常类型1出现之后的处理办法
} catch (异常类型2  异常对象名2) {
	异常类型2出现之后的处理办法
}
....
} catch (异常类型n 异常对象名n) {
	异常类型n出现之后的处理办法
}

3、执行流程：

  1. 执行try中的内容，如果没有异常，try…catch语句直接结束
  2. 如果有异常，那么就在发生异常的代码位置直接跳转到catch块中，try中后面的代码就不再继续运行了
  3. 继续匹配各个catch块中的异常类型，从上到下，一旦匹配到某个catch声明的异常类型，就直接执行该catch块的处理方式。处理完成之后，try…catch语句就直接结束了，不会再去匹配后面其他的catch块的异常类型

4、注意事项：
如果在各个catch块中，出现了子父类的异常类型，那么子类异常的catch块，必须在父类异常catch块的上面，因为从上到下匹配方式，如果父类的catch块在上面，下面的catch块就没有出现的意义了，无法到达的代码。

public class Demo7 {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt(args[0]); //NumberFormatException
            int b = Integer.parseInt(args[1]);//在idea设置vm options中设定数组值
            int c = a / b;
            System.out.println(c);
        }catch (ArrayIndexOutOfBoundsException e){ // e = ArrayIndexOutOfBoundsException
            System.out.println("越界异常了");
        }catch (NumberFormatException e){
            System.out.println("数字格式化异常");
        }catch (ArithmeticException e){
            System.out.println("除0了");
        }catch (Exception e){
            System.out.println("出异常了");
        }


        System.out.println("over");
    }


}

(七)try…catch…finally语句

1、格式：

try {
 	可能发生异常的代码
} catch (可能发生的异常类型  异常对象名称) {
 	当前异常类型的处理方式
}... finally {
	一定要执行的代码
}

2、finally：关键字, 一定要执行的代码

  1. 如果把某句代码放在try中，可能在这句话前面有异常，那么这句话就无法执行；如果把某句代码放在catch中，有可能try中没有异常，就无法执行这句话；如果把某句代码放在try…catch之后，可能有未捕获的异常，那么这句代码也无法执行。
  2. finally：也是一个代码块，在这个代码块中的代码，一定会执行，无论上面描述的哪种情况，都会执行。甚至在代码中有return语句，都会先执行finally中的代码。
  3. 作用：一般使用关闭资源
public class Demo8 {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt(args[0]); //NumberFormatException
            int b = Integer.parseInt(args[1]);
            int c = a / b;
            System.out.println(c);
        }catch (Exception e){ // e = ArrayIndexOutOfBoundsException
            System.out.println("出异常了");
//            return; //finally也执行
            System.exit(0); //finally 不执行 因为jvm直接停了，其他情况都执行
        }finally {
            //一定会执行的语句块(无论有无异常，都执行)，通常用作释放资源
            System.out.println("我执行了");
        }


       /*
        该结构出现的目的:就是为了使用finally
        try{

        }finally {

        }*/

        System.out.println("over");
    }


}

(八)try…finally

1、格式：

try {
 	可能发生异常的代码
} finally {
	一定要执行的代码
}

2、作用：

  1. 第三种格式无法捕获和处理异常，一旦发生任何异常，仍然会按照默认的处理方式，一层一层向上抛出，到达jvm，结束虚拟机
  2. 无论try中的语句是否发生异常，finally中的代码都一定有执行的机会
  3. 如果有两句代码，都需要有执行的机会，不希望第一句的成功与否影响到第二句的执行机会，那么就把这两句代码分别放在try和finally中

3、使用场景 : 如果代码中发生异常, 不处理, 交给JVM默认处理, 还有一定需要执行逻辑, 那么try…finally可以使用

(九)运行时异常和编译时期异常的区别

  1. 编译时期异常:
    a: Exception类和Exception除了RuntimeException以外的其他子类
    b: 出现就必须显示的处理，否则程序无法编译通过，程序也就无法运行; 当代码中发生编译时期异常, 提示自动进行处理
  2. 运行时异常:
    a: RuntimeException类和RuntimeException的子类
    b: 出现无需显示处理，也可以像编译时一样显示的处理，无论是否处理程序都可以编译通过。

(十)throw关键字

1、throw：抛出，用于抛出一个异常对象

2、throw关键字的使用场景 : 异常是一个对象，当程序运行到某种情况时，程序员认为这种情况和现实生活不符合，就把当前的对于情况的描述，封装到一个异常对象中，通过throw关键字将异常对象进行抛出。将异常抛给方法的调用者

3、throw关键字的语法结构:
throw new Exception或者Exception任意一个子类对象(“将异常发生详细信息描述清楚”);

4、作用：
创建一个异常对象，使用throw关键字抛出，实现了程序的结束或者跳转

5、说明：
(1) 如果抛出的是编译时异常，那么这个异常必须使用异常处理的方式处理，才能编译成功
(2) 如果抛出的是运行时异常，在编译阶段就相当于没有异常，可以不处理这个异常

6、 throw关键字使用注意事项:
(1) throw关键字使用在方法中
(2) throw每一次只能抛出一个异常

public class Demo10 {
    public static void main(String[] args) {
        try {
            int div = div(5, 0);
            System.out.println(div);
        } catch (Exception e) {
            System.out.println("出异常了");
        }
    }


    //封装方法，计算两个整数相除
    public  static  int  div(int a, int b)throws Exception{
        if(b == 0){
            throw new Exception("除数不能为0");
        }
        int c = a/ b;
        return c;
    }
}

/*
* throw：
*   用在方法内，主动抛出一个异常对象。
*   throw有return的作用，即方法结束，同时将异常对象返回给调用者。
*   抛出的异常对象可以进行处理：
*      1.try/catch
*      2.throws声明
* */

(十一)throws关键字

1、throws：抛出，用于声明异常类型

2、在某个方法中，有一些编译时异常，没有给出处理的方案，没有捕获这个异常，没有处理这个异常，就说明这个方法是一个有问题的方法。为了让调用者在调用时，可以考虑到处理这个异常，所必须在当前方法的声明上，声明这个异常。

3、声明格式：

修饰符 返回值类型 方法名称(参数列表) throws 异常类型1, 异常类型2,... {
 	可能出现异常的代码;
}

4、注意事项：
(1) 如果抛出的是一个运行时异常，那么就相当于没有抛出异常，这种异常也不需要在方法上声明；声明了一个运行时异常，也相当于没有做任何声明
(2) 如果抛出的是一个编译时异常，那么就必须进行声明或者捕获；如果声明了一个编译时异常，将来调用这个方法时，也相当于有一个声明的异常

public class Demo9 {
    public static void main(String[] args)  {
       try {
           int div = div(5, 1);
           System.out.println(div);
       }catch (Exception e){
           System.out.println("出异常了");
       }

        System.out.println("over");
    }

    //封装一个方法，用于计算两个整数的商
    /*public  static  int  div(int a, int b)throws ArithmeticException{
        int c = a / b;
        return c;
    }*/

    public  static  int  div(int a, int b)throws Exception,RuntimeException,NullPointerException{
        int c = a / b;
        return c;
    }
}

/*
* throws：
*    用在方法上，声明异常类型，可以声明多个异常类型，中间用逗号分隔即可。
*    本意：谁调用有throws的方法，谁处理该异常。
*    运行时异常：可以处理也可以不处理
*    编译时异常：必须处理。
*                1.try/catch捕获
*                2.继续向上声明
*
* */

(十二)throw和throws的比较

1、throw是对异常对象的抛出，throws是对异常类型的声明

2、throw是对异常对象实实在在的抛出，一旦使用了throw关键字，就一定有一个异常对象出现；throws是对可能出现的异常类型的声明，即使声明了一些异常类型，在这个方法中，也可以不出现任何异常。

3、throw后面只能跟一个异常对象；throws可以跟很多个异常类型

(十三)异常体系中的常用方法

1、发现在异常的继承体系中，所有的方法定义在了Throwable这个顶层父类中，子类中几乎没有什么特有方法

2、Throwable中的构造方法：
Throwable()：创建一个没有任何参数的异常对象
Throwable(String message)：创建一个带有指定消息的异常对象

3、常用成员方法：
getMessage()：获取异常的详细信息
toString()：获取异常对象的详细信息
printStackTrace()：打印异常的调用栈轨迹（有关异常的方法调用路径）, 对于异常信息追全面的输出方式, 本身返回值结果void, 但是在方法中已经有打印功能, 将异常进行输出,包括异常类型, 异常详细信息, 代码发生异常的行数

public class Demo11 {
    public static void main(String[] args) {
        try {
            int a = Integer.parseInt(args[0]);
            System.out.println(a);
        } catch (ArrayIndexOutOfBoundsException e) {
//            System.out.println(e.getMessage());//返回的异常原因
//            System.out.println(e.toString()); //返回的是异常名和原因
            e.printStackTrace(); //打印堆栈跟踪信息
                                 //行号  原因  异常名字
//            System.out.println(e.getCause());
        }

        System.out.println("over");
    }
}

(十四)异常的注意事项

  1. 运行时异常抛出可以不处理，既不捕获也不声明抛出; 编译时期异常, 必须进行异常处理,throws声明异常, 或者try…catch语法结构捕获处理异常
  2. 如果父类方法上抛出了多个编译时异常，子类覆盖(重写)父类的方法时，可以不抛出异常，或者抛出相同的异常，或者父类抛出异常的子类集合。
  3. 如果父类方法没有异常抛出，子类覆盖父类方法时，不能抛出编译时异常
public class Demo13 extends A {
    @Override
    public void method()throws RuntimeException{ }

    @Override
    public void show()throws  NullPointerException,ArrayIndexOutOfBoundsException{ }
}

class  A{
    void  method(){}

    void  show()throws Exception{}
}

(十五)自定义异常

1、jdk中提供了很多的异常类型，其中的绝大部分都没有自己特有的方法,都无法描述当前的异常情况，就需要我们自己定义异常类型，用在自己的项目的业务中。

2、自定义异常的步骤：

(1) 定义一个类，以Exception结尾，IllegleAgeException，表示这是一个非法年龄异常
(2) 让自己定义的这个类，继承一个Exception或者是RuntimeException
如果定义的是编译时异常，就使用Exception
如果定义的是运行时异常，就使用RuntimeException
(3) 构造方法不能被继承，需要手动添加

public class Demo12 {

    public static void main(String[] args) {
        try {
            int div = div(5, -1);
            System.out.println(div);
        } catch (FuShuNotDivException e) {
            System.out.println(e.toString());
        }

        System.out.println("over");
    }
    public  static  int  div(int a, int b)throws FuShuNotDivException{
        if(b <= 0){
            throw new FuShuNotDivException("0和负数都不能作为除数");
        }
        int c = a/ b;
        return c;
    }
}
/*
* 自定义异常的步骤：
*   1.定义类继承Exception或RuntimeException
*   2.调用父类的构造方法(可选)
* */

class FuShuNotDivException  extends Exception{
    public FuShuNotDivException(){
        super();
    }

    public FuShuNotDivException(String msg){
        super(msg);
    }
}
sjxxxx_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
学习Java的第十三天——综合案例贪吃蛇
11-20
第十三天 前面的十二天如果你看完了，那么今天你就可以试试这一款属于自己的小游戏啦 一步步写的，小白可以看哦。思维简单，eclipse开发，并且资源已经上传，下面就是详细步骤 1. 创建java项目 1.1点击file-new-java...
java核心技术（第十版）卷一
08-09
java核心技术第十版 卷二 https://pan.baidu.com/s/1GJPBYGFrktm-pQWYkaUGmQ
glsl noise algorithms ，各种噪音算法
lynon的专栏
01-02 3777
转载自：  https://www.baidu.com/link?url=Eh0ahdZmH1hKVbJNlsEc_TrIJl58kgwD2Mp7M72vzmpWvdu_h-eKyH0u5WLsUjiOCsoqpoWBobE6d2nTfe2dePfT3Ox3JQm7_D3SmPaQ6Sm&wd=&eqid=cf0bc2fb0000a885000000035a4ba92f http
小白学习java第一天
YY_monster的博客
07-01 255
1. 计算机概述 软件：数据与指令的集合 编程语言：人与机器的交互的工具 计算机语言 机器语言：01二进制 汇编语言：#！？等符号 高级语言：英文表述 2. 人机交互 分类 dos控制台 功能单一 可视化窗口 EditPlus eclipse idea dos控制台 cmd 3. 常见的dos命令 电脑操作 ctrl + c v s x z dos命令 cd: change directory cd 路径 （同一盘） cd
小白学习Java第二十二天
sjxxxx_的博客
09-01 102
第二十二天
小白JAVA学习日记（第二十一天）
shouhmzhl的博客
08-31 62
记录一下小白自学Java的第十天
m0_74640928的博客
10-25 135
编写Java程序 从键盘上输?10个数 赋值给?个长度为10的数组 利?冒泡排序法为数组排序
Java小白学习二十九——面向过程&面向对象
错过人间飞鸿的博客
01-30 68
面向过程&面向对象
小白JAVA学习日记（第六天）
shouhmzhl的博客
07-21 90
干！就完事了！ （131 - 151） 提醒：Eclipse的版本 要和 JDK的版本对应！！（made）之前安装了jdk16.0，结果使用教程自带的Eclipse就无法打开软件，且一直报错：an error has occurred see the log null. 网上有各种解决办法，什么管理员权限打开，什么删除log文件里的什么代码....都解决不了问题。 所以直接安装对应版本的Eclipse就可以了，JDK的话建议不要重新安装..我重新安装后，导致java和javac的版本不对应，连cmd
小白JAVA学习日记（第四天）
shouhmzhl的博客
07-18 76
干就完事了！ 2021.7.18 （91-113） 注意：导包如果不知道包的功能包含什么，可以查询API。 如果输入的类型与定义变量的类型不匹配，程序会报错且自动退出 第二题答案： 第三题答案： 提醒： case：中还可以嵌套if-else语句，例如用于计算区分闰年与平年的天数，在三月的case中加入 JAVA的循环结构只有三种： 题目：输入两个正整数m和n，求其最大公约数和最小公倍数。 比如：12和20的最大公约数是4，最小公倍数...
小白怎么学Java？给Java新手的一些建议
weixin_49794051的博客
12-29 582
写这篇文章的目的是想总结一下自己这么多年来使用java的一些心得体会，主要是和一些java基础知识点相关的，所以也希望能分享给刚刚入门的Java程序员和打算入Java开发这个行当的准新手们，希望可以给大家一些经验，能让大家更好学习和使用Java。 这次介绍的主要内容是和J2SE相关的部分，另外，会在以后再介绍些J2EE相关的、和Java中各个框架相关的内容。 经过这么多年的Java开发，以及结合平时面试Java开发者的一些经验，我觉得对于J2SE方面主要就是要掌握以下的一些内容。 1. JVM相关(包括了
Java小白学习开篇计划
weixin_46325006的博客
10-18 274
第28章 算法优化体验课 - 骑士周游问题(P905 - P910)第07章 面向对象编程（基础部分）(P192 - P263)第08章 面向对象编程（中级部分）(P264 - P361)第10章 面向对象编程（高级部分）(P374 - P424)第02章 Java概述(P007 - P034)第16章 坦克大战1(P569 - P579)第18章 坦克大战2(P600 - P610)第20章 坦克大战3(P645 - P661)第27章 正则表达式(P878 - P904)
Java基础（2）.pdf
07-24
Java学习笔记分为3部分，这是第二部分，对Java基础进行讲解，生动形象，简单易懂，适合零基础的小白，中间配有程序截图，能短时间（几天内）快速对Java基础进行了解
基于java web 的图书管理系统
06-12
第4章 详细设计 12 4.1开发环境 12 4.2 功能模块实现 12 4.2.1登录模块 12 4.2.2 用户注册模块 13 4.2.3 图书管理模块 14 4.2.4 账户管理模块 15 4.2.5 查询模块 17 4.2.6 借阅管理模块 19 第5章 测试 20 5.1 登录...
数学建模与数学实验课件14讲含源程序_第12讲 计算机模拟.zip
04-15
【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。【附加价值】：项目具有较高的学习借鉴价值，也可直接拿来修改复刻。对于有一定基础或...
自制植物大战僵尸：HTML5与JavaScript实现的简单游戏
m0_73367097的博客
06-08 1908
自制植物大战僵尸
简单的项目部署脚本（转载）
u010230019的博客
06-09 604
有些项目团队喜欢使用docker启动java服务,那么我们同样可以将上述脚本稍做改造,来实现基于shell+docker的简单项目部署能力。可以将核心节点的错误或者失败内容通过webhook发送到对应的告警平台,比如钉钉、飞书机器人等。把~/.ssh/id_rsa.pub内容添加到远程仓库的ssh秘钥中。执行start.sh脚本打包部署。start.sh脚本内容。
Java——简单图书管理系统
m0_74100417的博客
06-09 1234
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
修改菜品——后端Java
weixin_53717695的博客
06-09 410
修改菜品——后端Java
小白java如何学习
最新发布
06-13
学习Java对于初学者来说，是一个系统且有计划的过程。以下是小白学习Java的一些建议： 1. **基础知识了解**：开始之前，了解计算机科学的基础概念，如数据类型、变量、控制结构（如循环和条件语句）等。这些都是Java语言的基础。 2. **选择教材或课程**：推荐使用官方文档《Java Language Specification》以及像《Head First Java》这样的入门书籍，或者在线教程，比如Codecademy、Udemy或Coursera的Java课程。 3. **安装环境**：安装Java Development Kit (JDK) 和集成开发环境(IDE)，比如Eclipse、IntelliJ IDEA 或者最新流行的JetBrains全家桶（包括PyCharm、WebStorm等）。 4. **语法学习**：从Java语言的基本语法开始，理解类、对象、构造函数、方法、访问修饰符等概念。 5. **实践编写代码**：通过编写简单的Hello World程序，逐步实现小项目，比如计算器、猜数字游戏等，提升实战能力。 6. **数据结构与算法**：Java的学习不能忽视算法，理解并掌握基本的数据结构如数组、列表、栈和队列，以及常用算法，这有助于提高代码效率。 7. **面向对象编程**：理解面向对象（OOP）的概念，包括封装、继承、多态等，这是Java的核心。 8. **异常处理**：Java对错误和异常处理有严谨的规定，学会如何使用try-catch-finally来处理程序中的异常。 9. **框架学习**：学习Spring、Hibernate等企业级框架，了解它们如何简化开发和提高代码质量。 10. **阅读开源项目**：参与开源社区，阅读他人的代码，可以让你更好地理解和应用所学知识。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值