精华内容
下载资源
问答
  • 例如:现在如果设置的年龄超过了 300 岁,那么将产生一个 AgeException, 然而这样的异常 Java 本身不会提供,所以此时用户可以根据自己的需要定义自己的异常,定义异常只需要继承 Exception (强制性处理)...

    1 自定义异常类

       在 Java 中已经提供了大量的异常类,但是这些异常类有时候也很难满足开发者的要求。例如:现在如果设置的年龄超过了 300 岁,那么将产生一个 AgeException, 然而这样的异常 Java 本身不会提供,所以此时用户可以根据自己的需要定义自己的异常类,定义异常类只需要继承 Exception 类(强制性处理)或者是 RuntimeException 类(选择性处理)即可。

    实例 1 代码:

    package self.learn.exception;
    
    public class MyException extends Exception { // 自定义异常类,继承 Exception
    	public MyException(String msg) {         // 构造方法接收异常信息
    		super(msg);                          // 调用父类中的构造方法
    	}
    }
    
    package self.learn.exception;
    
    public class DefaultException {
    	public static void main(String[] args) {
    		try {
    			throw new MyException("自定义异常。");   // 抛出异常
    		} catch (Exception e) {                   // 异常处理
    			System.out.println(e);
    		}
    	}
    }
    

    运行结果截图:

    在这里插入图片描述

    2 断言(assert)

       在 JDK1.4 之后,Java 中增加了断言的功能。断言就是肯定某一个结果返回的值是正确的,如果最终此结果的返回值是错误,则通过断言检查肯定会提示错误信息。断言的定义格式如下:

    assert boolean 表达式;
    assert boolean 表达式: 详细信息
    

       如果上面的 boolean 表达式的结果为 true,则什么错误信息都不会提示,如果为 false,则会提示错误信息;如果没有声明详细的信息描述,则系统会使用默认的错误信息提示方式。

    实例 2 代码:

    package self.learn.exception;
    
    public class AssertDemo {
    
    	public static void main(String[] args) {
    		int x[] = {1,2,3};
    		assert x.length == 0;     // 此处断言数组长度为0,可定是错误的
    	}
    }
    

    断言编译格式:(-enableassertions —>可以简写为 “-ea”)

    javac AssertDemo.java
    java -ea AssertDemo
    

    程序出现错误如下:

    运行结果截图:

    在这里插入图片描述
       上面出现的是断言错误,因为数组 x 的长度不可能是 0,但此时的信息是系统默认的错误信息,如果想要显示自己的错误信息,可以使用另外一种断言声明格式。

    实例 3 代码:

    package self.learn.exception;
    
    public class AssertDemo {
    
    	public static void main(String[] args) {
    		int x[] = {1,2,3};
    		assert x.length == 0:"数组长度不为 0";    // 此处断言数组长度为0,可定是错误的
    	}
    }
    

    运行结果截图:

    在这里插入图片描述

    断言的使用:
    (1)虽然断言返回的是 boolean 值,但是其并不能作为条件判断语句出现。
    (2)断言虽然有检查运行结果的功能,但是一般开发中并不提倡使用断言。

    展开全文
  • 自定义异常断言

    2018-06-11 23:26:01
    自定义异常(理解)java本身所提供基础的异常处理操作支持,并且提供了一些比较常见的异常类型,但是在很多情况下有一些异常是不会提供的package YICHENG;class DieException extends Exception{ public ...
    自定义异常类(理解)
    java本身所提供基础的异常处理操作支持,并且提供了一些比较常见的异常类型,但是在很多情况下有一些异常是不会提供的
    package YICHENG;
    class DieException extends Exception{
    public DieException(String msg) {
    super(msg);
    }
    }
    public class Throwg {


    public static void main(String[] args) {
    // TODO Auto-generated method stub
    try {
    for(int x=1;x<30;x++) {
    System.out.println("吃了:"+x+"餐");
    if(x>3) {
    throw new DieException("快完了");
    }
    }
    }catch(Exception e){
    System.out.println("作死");
    e.printStackTrace();
    }
    }
    }


    断言:assert(了解)
    断言指的是程序执行到某行语句的时候,一定是预期的结果,断言有正确的,也有错误的
    范例:
    public class Throwg1 {
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    int x=10;
    //现在假设中间经过了十行代码,都修改了X的内容
    assert x==100:"断言错误信息:x的内容不是100,而是"+x;
    System.out.println("x="+x);
    }
    }
    默认情况下断言是不会启用的,如果要想让断言使用,则必须在执行的时候增加“-ea”的参数






    总结:;
    1.清楚异常的处理流程,关键是,每当一个异常产生时都会生产一个异常类的实例化对象;
    2.清楚Throwable与Error和Exception的区别
    3.异常处理的标准结构:try,catch,finally,throw,throws的作用
    4.RuntimeException的子类异常可以选择性进行处理
    5.异常最常用的格式
    (1)给出的代码模型
    (2)直接写try.catch
    展开全文
  • 自定义异常(理解) java本身所提供基础的异常处理操作支持,并且提供了一些比较常见的异常类型,但是在很多情况下有一些异常是不会提供的 package YICHENG; class DieException extends Exception{ public ...

    自定义异常类(理解)
    java本身所提供基础的异常处理操作支持,并且提供了一些比较常见的异常类型,但是在很多情况下有一些异常是不会提供的
    package YICHENG;
    class DieException extends Exception{
    public DieException(String msg) {
    super(msg);
    }
    }
    public class Throwg {


    public static void main(String[] args) {
    // TODO Auto-generated method stub
    try {
    for(int x=1;x<30;x++) {
    System.out.println("吃了:"+x+"餐");
    if(x>3) {
    throw new DieException("快完了");
    }
    }
    }catch(Exception e){
    System.out.println("作死");
    e.printStackTrace();
    }
    }
    }


    断言:assert(了解)
    断言指的是程序执行到某行语句的时候,一定是预期的结果,断言有正确的,也有错误的
    范例:
    public class Throwg1 {
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    int x=10;
    //现在假设中间经过了十行代码,都修改了X的内容
    assert x==100:"断言错误信息:x的内容不是100,而是"+x;
    System.out.println("x="+x);
    }
    }
    默认情况下断言是不会启用的,如果要想让断言使用,则必须在执行的时候增加“-ea”的参数






    总结:;
    1.清楚异常的处理流程,关键是,每当一个异常产生时都会生产一个异常类的实例化对象;
    2.清楚Throwable与Error和Exception的区别
    3.异常处理的标准结构:try,catch,finally,throw,throws的作用
    4.RuntimeException的子类异常可以选择性进行处理
    5.异常最常用的格式
    (1)给出的代码模型
    (2)直接写try.catch

    展开全文
  • 自定义异常精品培训培训人xx本章学习目标了解异常的产生原理掌握异常处理语句的基本格式掌握throwthrows关键字的作用可以自定义异常了解Exception与RuntimeException的区别了解断言的作用自定义异常Java本身已经...
  • 三、自定义断言类处理if-throw块 1.定义返回给前端的返回体 2.定义异常 3.定义断言 4.定义枚举 5.异常控制器 四、实战演示 一、背景 我们平时在开发任务的时候,经常会碰到如果不满足某种条件则需要...

    目录

    一、背景

    二、断言

    三、自定义断言类处理if-throw块

    1.定义返回给前端的返回体

    2.定义异常类

    3.定义断言类

    4.定义枚举类

    5.异常控制器

    四、实际演示


    一、背景

    我们平时在开发任务的时候,经常会碰到如果不满足某种条件则需要告诉客户端问题所在,而如果条件很多,则需要N个if条件来判断是否满足,不满足则抛出异常,经常会形成下面这种现象:

    public class XXXX {
        public Object demoMethod(Map<String, Object> param) {
            // 如果某个条件为空则抛出某种异常,算是最常见的一种
            if (param.get("demo1") == null) {
                throw new Exception1();
            }
            // 如果获取的某个对象和方法中的某个对象不相等时抛出异常,也算是常见的
            Object obj = new Object();
            if (obj!=null && !obj.equals(param.get("demo2"))) {
                throw new Exception2();
            }
            // 下面如果是个方法链,则忽略N个这种的if异常判断抛出
            ...
            return null;
        }
    }

    实际开发实例:

    @Controller
    @RequestMapping(path = "/")
    public class TestController {
        @GetMapping(path = "/assert.json")
        @ResponseBody
        public ResponseDto testAssert(@RequestParam(required = false) 
                String text){
            // 判断异常
            if (text == null) {
                throw new Exception1();
            }
        
            // 其它类型的异常
            ResponseDto responseDto = ResponseDto.forSuccess();
            if (!responseDto.isOk) {
                throw new Exception2();
            }
        
            return responseDto;
        }
    }

    这就很有趣了,明明这些大致逻辑都是一致的,无非是一个boolean判断是否满足,不满足则抛出异常提醒前端,却占用了如此多的代码行数。

    二、断言

    如果是Spring项目,看过他们的源码经常能看见一个类:Assert,这个类是spring-core包中的一个断言类,其使用方法经常如下:

    public class XXXX {
        public Object demoMethod(Map<String, Object> param) {
            Assert.isNull(param, "param is null.");
            ...
            return null;
        }
    }

    其作用相当于:

    public class XXXX {
        public Object demoMethod(Map<String, Object> param) {
            if (param == null) {
                throw new IllegalArgumentException("param is null.");
            }
            ...
            return null;
        }
    }

    仅使用一个代码行便完成了三行代码的逻辑,使代码更加的精简。其实实现原理也很简单,无非是把公共的逻辑部分抽象出来,形成一个方法而已,Assert的isNull方法源码如下:

    public abstract class Assert {
        public static void isNull(@Nullable Object object, String message) {
           if (object != null) {
              throw new IllegalArgumentException(message);
           }
        }
    }

    可以看到这里面封装了一个我们平时再熟悉不过的代码块:if-throw。但是Spring的断言类Assert用起来还是很僵硬,因为这里面固定写死了抛出的异常类型就是IllegalArgumentException,并且第三方的工具类阿如果我们自己想要增加一些自定义的方法逻辑也无法增加。因此,基于此一个自定义的处理if-throw块的需求应运而生。

    三、自定义断言类处理if-throw块

    1.定义返回给前端的返回体

    假设返回给前端的返回体如下:

    public class ResponseDto<T> {
        public static final String SUCCESS = "0";
        public static final String FAIL = "1";
    
        private String resultCode;
    
        private String errorCode;
    
        private String errorDesc;
    
        private String innerErrorDesc;
    
        private T data;
    
        /**
         * 是否返回正确,正确为true
         *
         * @return
         */
        public boolean isOk() {
            return SUCCESS.endsWith(resultCode);
        }
    
        public static <T> ResponseDto<T> forSuccess() {
            ResponseDto<T> responseDto = new ResponseDto<>();
            responseDto.setResultCode(SUCCESS);
            return responseDto;
        }
    
        public static <T> ResponseDto<T> forFail() {
            ResponseDto<T> responseDto = new ResponseDto<>();
            responseDto.setResultCode(FAIL);
            return responseDto;
        }
        
        public static <T> ResponseDto<T> forFail(String errorCode, 
                String errorDesc) {
            ResponseDto<T> responseDto = new ResponseDto<>();
            responseDto.setResultCode(FAIL);
            responseDto.setErrorCode(errorCode);
            responseDto.setErrorDesc(errorDesc);
            return responseDto;
        }
        
        // 这里其它的forSuccess和forFail方法忽略,按需求和使用方便度编写
    
    }

    2.定义异常类

    首先先定义一个异常类,这个自定义异常类继承自RuntimeException,因为直接继承Excecption抛出的时候会要求捕获,而RuntimeException则不需要。

    public class BusinessException extends RuntimeException {
        private static final String BUSINESS_EXCEPTION_MESSAGE = 
                "CustomException";
    
        private ErrorCode errorCode;
        
        public BusinessException() {
            super(BUSINESS_EXCEPTION_MESSAGE);
        }
        
        public BusinessException(ErrorCode errorCode, Throwable t) {
            super(BUSINESS_EXCEPTION_MESSAGE, t);
            this.errorCode = errorCode;
        }
        
        public BusinessException(ErrorCode errorCode) {
            super(BUSINESS_EXCEPTION_MESSAGE);
            this.errorCode = errorCode;
        }
    }

    3.定义断言类

    接着依葫芦画瓢定义一个简单的断言类,并且新增一些我们自定义的断言方法:

    public class CustomAssert{
        /**
         * 创建新的异常
         *
         * @return
         */
        BusinessException newException();
        
        /**
         * 根据抛出异常类和ErrorCode创建新的异常
         *
         * @param t
         * @return
         */
        BusinessException newException(Throwable t);
        
        /**
         * 对象为空则抛出异常
         *
         * @param object
         */
        default void assertNotNull(Object object) {
            if (ObjectUtils.isEmpty(object)) {
                throw newException();
            }
        }
        
        /**
         * 对象为空则抛出异常
         *
         * @param object
         * @param t
         */
        default void assertNotNull(Object object, Throwable t) {
            if (ObjectUtils.isEmpty(object)) {
                throw newException(t);
            }
        }
        
        /**
         * 对象不为空则抛出异常
         *
         * @param object
         */
        default void assertNull(Object object) {
            if (!ObjectUtils.isEmpty(object)) {
                throw newException();
            }
        }
        
        /**
         * 对象不为空则抛出异常
         *
         * @param object
         * @param t
         */
        default void assertNull(Object object, Throwable t) {
            if (!ObjectUtils.isEmpty(object)) {
                throw newException(t);
            }
        }
        
        /**
         * lambda函数判断为true则抛出异常
         *
         * @param supplier
         */
        default void assertTrueLambda(Supplier<Boolean> supplier) {
            if (supplier.get()) {
                throw newException();
            }
        }
        
        /**
         * lambda函数判断为true则抛出异常
         *
         * @param supplier
         * @param t
         */
        default void assertTrueLambda(Supplier<Boolean> supplier, Throwable t){
            if (supplier.get()) {
                throw newException(t);
            }
        }
        
        /**
         * lambda函数判断为true则抛出异常
         *
         * @param supplier
         */
        default void assertFalseLambda(Supplier<Boolean> supplier) {
            if (!supplier.get()) {
                throw newException();
            }
        }
        
        /**
         * lambda函数判断为true则抛出异常
         *
         * @param supplier
         * @param t
         */
        default void assertFalseLambda(Supplier<Boolean> supplier,
                Throwable t) {
            if (!supplier.get()) {
                throw newException(t);
            }
        }
    }

    其中ObjectUtils是自己实现的,可以判断Integer、Long、String、Collection和Map的公共工具类,也可以自己添加一些函数方法,使用lambda实现更加复杂的条件判断。

    4.定义枚举类

    这个枚举类的用处便是用来管理不同的异常消息,毕竟一个系统肯定不止一种类型的异常消息:

    public enum ErrorCode implements CashboxAssert {
    
        /**
         * 未知错误
         */
        UNKNOWN("DM-9999", "系统异常", "系统异常"),
    
        /**
         * 异常测试
         */
        TEST("DM-9998", "测试异常", "测试异常"),
    
        /**
         * 参数异常
         */
        NULL_PARAM("DM-9997", "参数异常", "参数异常");
    
        private String errorCode;
    
        private String errorDesc;
    
        private String innerErrorDesc;
    
        ErrorCode() {
        }
    
        ErrorCode(String errorCode, String errorDesc, String innerErrorDesc) {
            this.errorCode = errorCode;
            this.errorDesc = errorDesc;
            this.innerErrorDesc = innerErrorDesc;
        }
    
        /**
         * 获取对应异常类
         *
         * @return
         */
        public BusinessException getBusinessException() {
            return new BusinessException(this);
        }
    
        @Override
        public BusinessException newException() {
            return new BusinessException(this);
        }
    
        @Override
        public BusinessException newException(Throwable t) {
            throw new BusinessException(this, t);
        }
    }

    5.异常控制器

    接着定义一个异常控制器,来处理从controller中进入的请求所有异常:

    @ControllerAdvice
    public class ExceptionAdvice {
        private static final Logger LOGGER = LoggerFactory
                .getLogger(ExceptionAdvice.class);
                
        /**
         * 处理系统异常
         *
         * @param e
         * @return
         */
        @ExceptionHandler(Throwable.class)
        @ResponseBody
        public Object handleException(Throwable e) {
            log.error("系统异常:", e);
            return printLogInfo(ErrorCode.UNKNOWN);
        }
        
        /**
         * 处理自定义异常
         *
         * @param e
         * @return
         */
        @ExceptionHandler(BusinessException.class)
        @ResponseBody
        public Object handleBusinessException(BusinessException e) {
            if (e.getCause() != null && 
                    !((e.getCause() instanceof BusinessException))) {
                log.error("系统异常:", e);
            }
            return printLogInfo(e.getErrorCode());
        }
        
        /**
         * 打印异常日志
         *
         * @param errorCode
         * @return
         */
        private ResponseDto printLogInfo(ErrorCode errorCode) {
            ResponseDto responseDto = ResponseDto.forFail(
                    errorCode.getErrorCode(), errorCode.getErrorDesc(), 
                    errorCode.getInnerErrorDesc());
            log.error("系统异常-response[{}]", 
                    JSONObject.toJSONString(responseDto));
            responseDto.setInnerErrorDesc(null);
            return responseDto;
        }
    
    }

    这样定义之后自定义BusinessException和其子类将会进入handleBusinessException方法,而系统级别的其它异常将会进入handleException方法。当如如果异常类型足够多,也可以多写几个方法来处理各种类型的异常,而不需使用if-else来进行类型的判断。

    四、实际演示

    当配置完上述几个类之后,处理if-throw块处理将会变得异常简单,示例如下:

    @Controller
    @RequestMapping(path = "/")
    public class TestController {
        @GetMapping(path = "/assert.json")
        @ResponseBody
        public ResponseDto testAssert(@RequestParam(required = false) 
                String text){
            // 控制判断异常
            ErrorCode.NULL_PARAM.assertNotNull(text);
        
            ResponseDto responseDto = ResponseDto.forSuccess();
        
            // 其它类型的异常
            ErrorCode.TEST.assertFalseLambda(responseDto::isOk);
        
            return responseDto;
        }
    }

    是不是相比于最开始的使用if-throw块而言代码简洁清爽了很多?这里展示的只是普通的异常处理,如果需要集成disconf等框架使得错误描述可配,则直接在异常控制器那里使用errorCode匹配动态的配置内容即可。

    最后的最后,上面所说的这种处理方式核心思想无非是一个:代码复用性,程序中既然可能存在成千上万的逻辑相同方法块,那么就尽量提取方法块中公共的部分,将一些可变的逻辑变成可变的参数或者函数方法来替代。

     

     

    展开全文
  • 导读 Java异常,是一种代码错误处理技术。...自定义异常:必须要使用extends关键字去继承一个Exception断言技术:一般用于程序的测试技术。 JDK8主要新特性介绍(目的在于编程的时候可以使用新的特
  • Java语言最强大的支持在于异常处理。异常是指中断程序执行的指令流。 例子:产生异常 public class Yichang { public static void main(String[] args) { System.out.println(10/0); System.out.println(...
  • 自定义异常 1. Throwable体系: Error:严重错误Error,无法通过处理的错误,只能事先避免,好比绝症。 Exception:表示异常,异常产生后程序员可以通过代码的方式纠正,使程序继续运行,是必须要处理的。好比感冒...
  • JAVA异常处理

    2020-01-26 10:40:48
    自学JAVAJAVA异常处理捕获异常并再次抛出新的异常时,应该持有原始异常信息自定义异常断言自定义异常类断言使用日志JDK loggingCommons LoggingLog4j使用SLF4J和Logback插入链接与图片如何插入一段漂亮的代码片...
  • 1.3.2 自定义异常 1.3.3 catch和throw同时使用 1.3.4 异常链 1.4 捕获异常 1.4.1 使用try…catch捕获异常 1.4.2 多异常捕获 1.5 异常的处理 1.6 资源回收 1.6.1 使用finally回收资源 1.6.2 自动关闭资...
  • 工程师培训资料 标题Java培训系列课程- 异常处理流程精品培训 培训人xx 本章学习目标 了解异常的产生原理 掌握异常处理语句的基本格式 掌握throwthrows关键字的作用 可以自定义异常 了解Exception与RuntimeException...
  • 一:异常的基本概念二:异常的基本处理格式三:异常的继承结构四:Java的异常处理机制五:throws和throw关键字的作用六:Exception和RunntimeException的区别七:自定义异常八:断言的作用和应用1,为什么需要异常...
  • 文章目录1 认识异常对程序的影响2 处理异常3 处理多个异常4 异常处理流程5 throws关键字6 throw关键字7 异常处理模型8 RuntimeException9 自定义异常10 assert断言 1 认识异常对程序的影响 2 处理异常 3 处理多个...
  • Assert(断言) 替换 throw exceptionAssert善解人意的Enum定义统一异常处理器异常处理器说明handleServletExceptionhandleBindExceptionhandleValidExceptionhandleBusinessException、...Control
  • Java异常的捕获及处理---小总结

    万次阅读 多人点赞 2017-06-06 15:30:52
    一:异常的基本概念二:异常的基本处理格式三:异常的继承结构四:Java的异常处理机制五:throws和throw关键字的作用六:Exception和RunntimeException的区别七:自定义异常八:断言的作用和应用1,为什么需要异常...
  • 本课内容Java异常的概念和处理机制Java异常的分类异常的捕获处理和抛出使用用户自定义异常断言Java异常Java程序运行过程中所发生的异常事件可分为两错误(Error:JVM系统内部错误资源耗尽等严重情况违例(Exception: ...
  • 1. 2.3.4.5.6.7.8.9.10.return 语句不要出现在finally 中11.12.可以自定义异常,只需要继承Exception即可13.断言
  • 目录前言一 :Java快速入门二 :Java面向对象编程三 :Java异常处理错误处理Java的异常捕获异常抛出异常自定义异常断言和日志使用断言使用JDKLogging使用CommonsLogging使用Log4j四 :Java反射与泛型反射Class访问...
  • 异常、断言与日志

    2017-10-22 21:34:00
    1.对于异常情况,Java使用一种称为异常处理(exception handing)的错误捕获机制处理。 在Java中,如果某个方法不能够采用正常的途径完成它的任务,就可以通过另外一个路径退出方法。在这种情况下,方法并不返回任何...
  • Java面向对象开发89 ~ 96:【第04个代码模型】异常的捕获与处理89:观察异常带来的问题90:异常处理格式`try···catch``try···catch···finally`91:throws关键字92:throw关键字93:异常处理模型94:...
  • Java学习笔记---异常

    2020-03-22 23:20:09
    Java学习笔记---异常异常的捕获和处理基本介绍为什么需要异常处理使用异常处理(1)对异常进行捕捉(try、catch、finally)(2)抛出多个异常异常的继承结构和分类异常分类throws与throw关键字自定义异常断言常见...
  • 廖雪峰 Java 教程.doc

    2020-02-25 11:06:56
    Java核心 字符串和编码 StringBuilder StringJoiner 包装类型 JavaBean 枚举 BigInteger BigDecimal 常用工具 异常处理 Java的异常 捕获异常 抛出异常 自定义异常 使用断言 使用JDK Logging ...
  • JAVA中的异常

    2020-05-19 16:29:06
    目录异常异常的捕获throws throw自定义异常继承中的异常断言 异常 Exception:一般表示的是程序中出现的问题,可以直接使用try…catch处理 Error:一般指的是JVM错误,程序中无法处理 Exception在程序中是...
  • 在日常的 Java 编程中,笔者发现很多的初级开发人员都不能正确合理的来处理异常问题。...如何正确自定义 Java 异常? 适合人群:Java 编程 当前内容版权归码字科技所有并授权显示,盗版必究。阅读原文
  • Java——异常与捕获

    2018-11-30 14:07:35
    目录 1.异常的影响 2.异常的处理 2.1 异常信息输出 ...7.自定义异常 异常——导致程序中断执行的一种指令流 为了保证程序在出现异常之后可以正常执行完毕,就需要进行异常处理。 Error描述了J...
  • Java2核心技术第7版全两卷.pdf中文高清

    千次下载 热门讨论 2012-09-14 14:22:28
    第7版在保留以前版本风格的基础上,涵盖java 2开发平台标准版j2se 5.0的基础知识,主要内容包括面向对象程序设计、反射与代理、接口与内部、事件监听器模型、使用swing ui工具箱进行图形用户界面设计、异常处理、...
  •  第13章 Java类集  视频讲解:3小时50分钟  第14章 枚举  视频讲解:55分钟  第15章 Java反射机制  视频讲解:2小时i24分钟  第16章 Annotation  视频讲解:1小时19分钟  第17章 Java数据库编程  视频讲解...
  • java面试题

    2018-04-27 19:55:38
    答:jsp前段动态页面,servlet是纯java类 jsp被编译之后会转换为servlet执行 java基本数据类型有哪些?String是不是基本数据类型,他们有何区别? 答:基本数据类型8种:int、short、byte、long、float、double、...
  • 10.3.4 内部及匿名在事件处理中的应用 10.4 常用组件的使用 10.4.1 标签、按钮与动作事件 10.4.2 文本框、文本区域与文本事件 10.4.3 单、复选按钮,列表与选择事件 10.4.4 调整事件与滚动条 10.4.5 鼠标、键盘...

空空如也

空空如也

1 2 3 4
收藏数 62
精华内容 24
关键字:

自定义断言处理java类

java 订阅