项目重构02 Scala中继承Java类,Spring依赖注入,返回视图等等

1、首先是Java基类控制器

package cn.edu.jxnu.base.controller;

import java.io.IOException;
import java.util.Date;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.propertyeditors.StringTrimmerEditor;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.web.bind.annotation.InitBinder;

import cn.edu.jxnu.base.common.DateEditor;

/**
 * 主控制类
 * 
 * @author 梦境迷离
 * @time 2018年4月10日 下午5:12:23.
 * @version V1.0
 */
public class BaseController {
	private Logger log = LoggerFactory.getLogger(getClass());
	@Autowired
	protected HttpServletRequest request;

	@Autowired
	protected HttpServletResponse response;

	// 由@InitBinder表示的方法,可以对WebDataBinder对象进行初始化。WebDataBinder是DataBinder的子类,用于完成由表单到JavaBean属性的绑定。
	// @InitBinder方法不能有返回值,它必须名为void。
	// @InitBinder方法的参数通常是WebDataBinder,@InitBinder可以对WebDataBinder进行初始化。
	/**
	 * 由InitBinder表示的方法,可以对WebDataBinder对象进行初始化。WebDataBinder是DataBinder的子类,
	 * 用于完成由表单到JavaBean属性的绑定。 InitBinder方法不能有返回值,它必须名为void。
	 * InitBinder方法的参数通常是WebDataBinder,@InitBinder可以对WebDataBinder进行初始化。
	 * 
	 * @time 2018年4月10日 下午5:12:31.</br>
	 * @version V1.0</br>
	 * @param webDataBinder</br>
	 */
	@InitBinder
	protected void initBinder(WebDataBinder webDataBinder) {
		/**
		 * 一个用于trim 的 String类型的属性编辑器 如默认删除两边的空格,charsToDelete属性:可以设置为其他字符
		 * emptyAsNull属性:将一个空字符串转化为null值的选项。
		 */
		webDataBinder.registerCustomEditor(String.class, new StringTrimmerEditor(true));
		webDataBinder.registerCustomEditor(Date.class, new DateEditor(true));
	}

	/**
	 * 带参重定向
	 *
	 * @param path
	 * @return String
	 */
	protected String redirect(String path) {
		return "redirect:" + path;
	}

	/**
	 * 不带参重定向
	 *
	 * @param response
	 * @param path
	 * @return String
	 */
	protected String redirect(HttpServletResponse response, String path) {
		try {
			response.sendRedirect(path);
		} catch (IOException e) {
			e.printStackTrace();
		}
		return null;
	}

	/**
	 * 获取分页请求 并排序
	 * 
	 * @return PageRequest
	 */
	protected PageRequest getPageRequest() {
		int page = 1;
		int size = 10;
		Sort sort = null;
		try {
			String sortName = request.getParameter("sortName");
			String sortOrder = request.getParameter("sortOrder");
			if (StringUtils.isNoneBlank(sortName) && StringUtils.isNoneBlank(sortOrder)) {
				if (sortOrder.equalsIgnoreCase("desc")) {
					sort = new Sort(Direction.DESC, sortName);
				} else {
					sort = new Sort(Direction.ASC, sortName);
				}
			}

			page = Integer.parseInt(request.getParameter("pageNumber")) - 1;
			size = Integer.parseInt(request.getParameter("pageSize"));
			log.info("页数:" + page);
			log.info("容量:" + size);
		} catch (Exception e) {
			e.printStackTrace();
		}
		PageRequest pageRequest = new PageRequest(page, size, sort);
		return pageRequest;
	}

	/**
	 * 获取分页请求 带排序
	 * 
	 * @param sort
	 *            排序条件
	 * @return PageRequest
	 */
	protected PageRequest getPageRequest(Sort sort) {
		int page = 0;
		int size = 10;
		try {
			String sortName = request.getParameter("sortName");
			String sortOrder = request.getParameter("sortOrder");
			if (StringUtils.isNoneBlank(sortName) && StringUtils.isNoneBlank(sortOrder)) {
				if (sortOrder.equalsIgnoreCase("desc")) {
					sort.and(new Sort(Direction.DESC, sortName));
				} else {
					sort.and(new Sort(Direction.ASC, sortName));
				}
			}
			page = Integer.parseInt(request.getParameter("pageNumber")) - 1;
			size = Integer.parseInt(request.getParameter("pageSize"));
		} catch (Exception e) {
			e.printStackTrace();
		}
		PageRequest pageRequest = new PageRequest(page, size, sort);
		return pageRequest;
	}

}

2、Java方式继承基类

package cn.edu.jxnu.base.controller.admin;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.commons.lang3.StringUtils;
import org.apache.shiro.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;

import cn.edu.jxnu.base.common.Constats;
import cn.edu.jxnu.base.common.JsonResult;
import cn.edu.jxnu.base.controller.BaseController;
import cn.edu.jxnu.base.entity.BorrowBook;
import cn.edu.jxnu.base.entity.User;
import cn.edu.jxnu.base.service.IBorrowBookService;
import cn.edu.jxnu.base.service.IUserService;
import cn.edu.jxnu.base.service.specification.SimpleSpecificationBuilder;
import cn.edu.jxnu.base.service.specification.SpecificationOperator.Operator;
import lombok.extern.slf4j.Slf4j;

/**
 * 主页控制层,公共控制层,不需要权限
 * 
 * @author 梦境迷离
 * @time 2018年4月10日 下午5:14:11.
 * @version V1.0
 */
@Controller
@Slf4j
public class AdminIndexController extends BaseController {

	@Autowired
	private IUserService userService;
	@Autowired
	private IBorrowBookService borrowBookService;

	/**
	 * 登陆
	 * 
	 * @time 2018年4月10日 下午5:14:23.
	 * @version V1.0
	 * @return String
	 */
	@RequestMapping(value = { "/admin/", "/admin/index" })
	public String index() {
		log.info("登录界面");
		return "admin/index";
	}

	/**
	 * 首页查询
	 * 
	 * @time 2018年4月10日 下午5:14:38.
	 * @version V1.0
	 * @return String
	 */
	@RequestMapping(value = { "/admin/welcome" })
	public String welcome() {

		return "admin/welcome";
	}

	/**
	 * 用户个人信息页面
	 * 
	 * @time 2018年4月10日 下午5:15:22.
	 * @version V1.0
	 * @param map
	 * @param response
	 * @return String
	 * @throws TimeoutException
	 */
	@RequestMapping(value = { "/admin/info" })
	public String info(ModelMap map, HttpServletResponse response, Integer id) throws TimeoutException {
		log.info("用户id:" + id);
		User u = (User) SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + id);
		if (u != null) {
			/**
			 * 没有过期
			 */
			map.put("user", u);
		} else {
			try {
				/**
				 * 已经过期
				 */
				throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录");
			} catch (Exception e) {
				map.put("message", e.getMessage());
			} finally {
				/**
				 * 重定向到登录页面
				 */
				redirect(response, "/admin/login");
			}
		}
		return "admin/info";
	}

	/**
	 * 用户已借阅书籍页面
	 * 
	 * @time 2018年4月10日 下午5:15:43.
	 * @version V1.0
	 * @return String
	 */
	@RequestMapping(value = { "/admin/borrow" })
	public String borrow() {
		// 给页面传入必须的已借书籍
		return "admin/borrow";
	}

	/**
	 * 注册,不能拦截
	 * 
	 * @time 2018年4月10日 下午5:16:03.
	 * @version V1.0
	 * @param map
	 * @return String
	 */
	@RequestMapping(value = { "/assets/regist" })
	public String regist(ModelMap map) {
		/**
		 * 携带一个map,用于添加注册表单数据
		 */
		return "admin/regist/form";
	}

	/**
	 * 登录页面的注册专用
	 * 
	 * @time 2018年4月10日 下午5:16:27.
	 * @version V1.0
	 * @param user
	 * @param map
	 * @return JsonResult
	 */
	@RequestMapping(value = { "/assets/edit" }, method = RequestMethod.POST)
	@ResponseBody
	public JsonResult registAdd(User user, ModelMap map) {
		try {
			log.info("regist:" + user.toString());
			userService.saveOrUpdate(user);
		} catch (Exception e) {
			return JsonResult.failure(e.getMessage());
		}
		return JsonResult.success("注册成功,3秒后自动回到登录页面");
	}

	/**
	 * 验证用户名【学号】是否已经被注册,委托给用户控制层
	 * 
	 * @time 2018年4月10日 下午5:16:41.
	 * @version V1.0
	 * @param userCode
	 * @param request
	 * @param response
	 * @throws ServletException
	 * @throws IOException
	 */
	@RequestMapping(value = { "/assets/isAvailable" }, method = RequestMethod.GET)
	public void isAvailableUse(String userCode, HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		log.info("前台验证账户可用");
		request.getRequestDispatcher("/admin/user/isAvailable/" + userCode).forward(request, response);
	}

	/**
	 * 所有人均可修改的个人信息
	 * 
	 * @time 2018年4月10日 下午5:16:55.
	 * @version V1.0
	 * @param user
	 * @param map
	 * @return JsonResult
	 * @throws ServletException
	 * @throws IOException
	 */
	@ResponseBody
	@RequestMapping(value = { "/assets/update" }, method = RequestMethod.POST)
	public JsonResult allCanUpdate(User user, ModelMap map) throws ServletException, IOException {
		log.info("user:/assets/update:" + user.toString());
		try {
			User u = (User) SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + user.getId());
			if (u == null) {
				// 已经过期
				try {
					throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录");
				} catch (TimeoutException e) {
					map.put("message", e.getMessage());
				} finally {
					// 重定向到登录页面
					redirect(response, "/admin/logout");
				}
			}
			userService.saveOrUpdate(user);
			// 更新session
			SecurityUtils.getSubject().getSession().setAttribute(Constats.CURRENTUSER + user.getId(), user);
		} catch (Exception e) {
			return JsonResult.failure(e.getMessage());
		}

		return JsonResult.success();
	}

	/**
	 * 查询用户已借阅的图书 每个人均可操作,不需要授权。超期不可自主归还
	 * 
	 * @time 2018年4月10日 下午5:17:45.
	 * @version V1.0
	 * @param map
	 * @param uCode
	 *            操作人
	 * @return Page 类型 BorrowBook
	 */
	@RequestMapping(value = { "/assets/borrowList" })
	@ResponseBody
	public Page<BorrowBook> borrowList(ModelMap map, @RequestParam(value = "uCode") String uCode) {
		User u = userService.findByUserCode(uCode);
		SimpleSpecificationBuilder<BorrowBook> builder = new SimpleSpecificationBuilder<BorrowBook>();
		String bookName = request.getParameter("inputBookName");
		String bookAuthor = request.getParameter("inputAuthor");
		String bookPress = request.getParameter("inputPublication");
		if (StringUtils.isNotBlank(bookName)) {
			builder.add("bookName", Operator.likeAll.name(), bookName);
		}
		if (StringUtils.isNotBlank(bookAuthor)) {
			builder.add("bookAuthor", Operator.likeAll.name(), bookAuthor);

		}
		if (StringUtils.isNotBlank(bookPress)) {
			builder.add("bookPress", Operator.likeAll.name(), bookPress);
		}
		User user = (User) SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + u.getId());
		if (user.getId() != null) {
			builder.add("userId", Operator.eq.name(), user.getId());
		} else {
			// 已经过期
			try {
				throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录");
			} catch (TimeoutException e) {
				map.put("message", e.getMessage());
			} finally {
				// 重定向到登录页面
				redirect(response, "/admin/logout");
			}
		}
		// 得到已借阅的书籍
		Page<BorrowBook> page = borrowBookService.findAll(builder.generateSpecification(), getPageRequest());
		return page;
	}

}

3、Scala方式继承

package cn.edu.jxnu.base.controller.admin

import cn.edu.jxnu.base.controller.BaseController
import org.springframework.beans.factory.annotation.Autowired
import cn.edu.jxnu.base.service.IUserService
import cn.edu.jxnu.base.service.IBorrowBookService
import org.springframework.web.bind.annotation.RequestMapping
import org.springframework.ui.Model
import org.springframework.web.servlet.ModelAndView
import org.springframework.stereotype.Controller
import org.springframework.ui.ModelMap
import javax.servlet.http.HttpServletResponse
import lombok.extern.slf4j.Slf4j
import org.apache.shiro.SecurityUtils
import cn.edu.jxnu.base.common.Constats
import java.util.concurrent.TimeoutException
import cn.edu.jxnu.base.entity.User
import cn.edu.jxnu.base.common.JsonResult
import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.ResponseBody
import org.springframework.web.bind.annotation.GetMapping
import javax.servlet.http.HttpServletRequest
import org.springframework.web.bind.annotation.RequestParam
import org.springframework.data.domain.Page
import cn.edu.jxnu.base.entity.BorrowBook
import cn.edu.jxnu.base.service.specification.SimpleSpecificationBuilder
import org.apache.commons.lang3.StringUtils
import cn.edu.jxnu.base.service.specification.SpecificationOperator.Operator
import org.springframework.beans.factory.annotation.Required

/**
 * @author 梦境迷离.
 * @time 2018年5月15日
 * @version v2.0
 */
@Controller
class AdminIndexScala @Autowired() (val userService: IUserService, val borrowBookService: IBorrowBookService)
    extends BaseController {

    /**
     * 以下没有显示声明返回类型,所以默认返回最后的元素数据类型
     */
    //登陆
    @RequestMapping(value = { Array("/admin/", "/admin/index") })
    def index(model: Model) = {
        "admin/index"
    }

    //首页
    @RequestMapping(value = { Array("/admin/welcome") })
    def welcome() = {
        "admin/welcome"
    }

    //用户个人信息
    @RequestMapping(value = { Array("/admin/info") })
    def info(map: ModelMap, response: HttpServletResponse, @RequestParam(value    = "id", required = false) id: Int) = {

        println("用户id:" + id)
        val u = SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + id)
        if (u != null) {
            map.put("user", u)
        } else {
            try {
                throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录")
            } catch {
                case e: Exception => map.put("message", e.getMessage())
            } finally {
                redirect(response, "/admin/login")
            }
        }
        "admin/info"
    }

    //书籍借阅页面
    @RequestMapping(value = { Array("/admin/borrow") })
    def borrow() = {
        "admin/borrow"
    }

    //注册,不能拦截
    @RequestMapping(value = { Array("/assets/regist") })
    def regist(map: ModelMap) = {
        "admin/regist/form"
    }

    //登录页面的注册专用
    @ResponseBody
    @PostMapping(value = { Array("/assets/edit") })
    def registAdd(user: User, map: ModelMap): JsonResult = {
        try {

            println("regist:" + user.toString())
            userService.saveOrUpdate(user)
        } catch {
            case e: Exception => return JsonResult.failure(e.getMessage())
        }
        return JsonResult.success("注册成功,3秒后自动回到登录页面")
    }

    //验证用户名【学号】是否已经被注册,委托给用户控制层
    @GetMapping(value = { Array("/assets/isAvailable") })
    def isAvailableUse(userCode: String, request: HttpServletRequest, response: HttpServletResponse) = {
        println("前台验证账户可用")
        request.getRequestDispatcher("/admin/user/isAvailable/" + userCode).forward(request, response)
    }

    //所有人均可修改的个人信息
    @ResponseBody
    @PostMapping(value = { Array("/assets/update") })
    def allCanUpdate(user: User, map: ModelMap): JsonResult = {
        println("user:/assets/update:" + user.toString())
        try {
            val u = SecurityUtils.getSubject().getSession().getAttribute(Constats.CURRENTUSER + user.getId())
            if (u == null) {
                // 已经过期
                try {
                    throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录")
                } catch {
                    case e: TimeoutException => map.put("message", e.getMessage())
                } finally {
                    // 重定向到登录页面
                    Thread.sleep(1000)
                    redirect(response, "/admin/logout")
                }
            }
            userService.saveOrUpdate(user)
            // 更新session
            SecurityUtils.getSubject().getSession().setAttribute(Constats.CURRENTUSER + user.getId(), user)
        } catch {
            case e: Exception => return JsonResult.failure(e.getMessage())
        }

        JsonResult.success("修改成功,下次登陆生效")
    }

    //查询用户已借阅的图书 每个人均可操作,不需要授权。超期不可自主归还
    @ResponseBody
    @RequestMapping(value = { Array("/assets/borrowList") })
    def borrowList(map: ModelMap, @RequestParam(value = "uCode") uCode: String): Page[BorrowBook] = {
        val u = userService.findByUserCode(uCode)
        val builder = new SimpleSpecificationBuilder[BorrowBook]()
        val bookName = request.getParameter("inputBookName")
        val bookAuthor = request.getParameter("inputAuthor")
        val bookPress = request.getParameter("inputPublication")
        if (StringUtils.isNotBlank(bookName)) {
            builder.add("bookName", Operator.likeAll.name(), bookName)
        }
        if (StringUtils.isNotBlank(bookAuthor)) {
            builder.add("bookAuthor", Operator.likeAll.name(), bookAuthor)

        }
        if (StringUtils.isNotBlank(bookPress)) {
            builder.add("bookPress", Operator.likeAll.name(), bookPress)
        }
        val user: User = SecurityUtils.getSubject().getSession()
            .getAttribute(Constats.CURRENTUSER + u.getId()).asInstanceOf[User]
        if (user.getId() != null) {
            builder.add("userId", Operator.eq.name(), user.getId())
        } else {
            try {
                throw new TimeoutException("因超时无法获取您的个人信息,即将退出登录")
            } catch {
                case e: TimeoutException => map.put("message", e.getMessage())
            } finally {
                redirect(response, "/admin/logout")
            }
        }
        val page = borrowBookService.findAll(builder.generateSpecification(), getPageRequest())
        return page
    }
}

刚刚从Java转Scala需要注意的点还是很多的,总结目前遇到的

1、采用主构造注入SpringBean,bean定义val【常量】

2、继承与实现均使用extends【实际没有实现一说,接口可以使用with继承多个,叫混合更符合】

3、类等等允许有构造方法,甚至值类型也可以有一个参数的构造,构造参数一旦被使用,就自动升格为类的字段/属性

4、Scala默认public,private比Java更严格,不许嵌套类的父类访问嵌套类

5、def定义方法/过程,无返回值叫Unit是可以省略的,同时=也可以省略,叫过程

6、return与分号可以省略

7、集合默认是不可变集合

8、异常使用模式匹配 case

9、泛型使用 [] 而不是<>

10、Scala中一切操作均函数,甚至是 ++ +=这种,这++不是i++这种的,Scala是不存在++i 、i++、 --i、 i--

11、Scala没有基本类型,对数值可以进行方法调用,如+= 常见的 & %

Scala = 2.11.8

1JAVA SE 1.1深入JAVA API 1.1.1Lang包 1.1.1.1String和StringBuffer 位于java.lang包,这个包使用时不用导入 String一旦初始化就不可以改变,而stringbuffer则可以。它用于封装内容可变的字符串。它可以使用tostring()转换成string字符串。 String x=”a”+4+”c”编译时等效于String x=new StringBuffer().append(“a”).append(4).append(“c”).toString(); 字符串常量是一种特殊的匿名对象,String s1=”hello”;String s2=”hello”;则s1==s2;因为他们指向同一个匿名对象。 如果String s1=new String(“hello”);String s2=new String(“hello”);则s1!=s2; /*逐行读取键盘输入,直到输入为“bye”时,结束程序 注:对于回车换行,在windows下面,有'\r'和'\n'两个,而unix下面只有'\n',但是写程序的时候都要把他区分开*/ public class readline { public static void main(String args[]) { String strInfo=null; int pos=0; byte[] buf=new byte[1024];//定义一个数组,存放换行前的各个字符 int ch=0; //存放读入的字符 system.out.println(“Please input a string:”); while(true) { try { ch=System.in.read(); //该方法每次读入一个字节的内容到ch变量。 } catch(Exception e) { } switch(ch) { case '\r': //回车时,不进行处理 break; case '\n': //换行时,将数组总的内容放进字符串 strInfo=new String(buf,0,pos); //该方法将数组从第0个开始,到第pos个结束存入字符串。 if(strInfo.equals("bye")) //如果该字符串内容为bye,则退出程序。 { return; } else //如果不为bye,则输出,并且竟pos置为0,准备下次存入。 { System.out.println(strInfo); pos=0; break; } default: buf[pos++]=(byte)ch; //如果不是回车,换行,则将读取的数据存入数组。 } } } } String的常用成员方法 1、构造方法: String(byte[] byte,int offset,int length);这个在上面已经用到。 2、equalsIgnoreCase:忽略大小写的比较,上例如果您输入的是BYE,则不会退出,因为大小写不同,但是如果使用这个方法,则会退出。 3、indexOf(int ch);返回字符ch在字符串首次出现的位置 4、substring(int benginIndex); 5、substring(int beginIndex,int endIndex); 返回字符串的子字符串,4返回从benginindex位置开始到结束的子字符串,5返回beginindex和endindex-1之间的子字符串。 基本数据型包装的作用是:将基本的数据型包装成对象。因为有些方法不可以直接处理基本数据型,只能处理对象,例如vector的add方法,参数就只能是对象。这时就需要使用他们的包装将他们包装成对象。 例:在屏幕上打印出一个*组成的矩形,矩形的宽度和高度通过启动程序时传递给main()方法的参数指定。 public class testInteger { public static void main(String[] args) //main()的参数是string型的数组,用来做为长,宽时,要转换成整型。 { int w=new Integer(args[0]).intValue(); int h=Integer.parseInt(args[1]); //int h=Integer.valueOf(args[1]).intValue(); //以上为三种将字符串转换成整形的方法。 for(int i=0;i<h;i++) { StringBuffer sb=new StringBuffer(); //使用stringbuffer,是因为它是可追加的。 for(int j=0;j<w;j++) { sb.append('*'); } System.out.println(sb.toString()); //在打印之前,要将stringbuffer转化为string型。 } } } 比较下面两段代码的执行效率: (1)String sb=new String(); For(int j=0;j<w;j++) { Sb=sb+’*’; } (2) StringBuffer sb=new StringBuffer(); For(int j=0;j<w;j++) { Sb.append(‘*’); } (1)和(2)在运行结果上相同,但效率相差很多。 (1)在每一次循环,都要先将string型转换为stringbuffer型,然后将‘*’追加进去,然后再调用tostring()方法,转换为string型,效率很低。 (2)在没次循环,都只是调用原来的那个stringbuffer对象,没有创建新的对象,所以效率比较高。 1.1.1.2System与Runtime 由于java不支持全局函数和全局变量,所以java设计者将一些与系统相关的重要函数和变量放在system。 我们不能直接创建runtime的实例,只能通过runtime.getruntime()静态方法来获得。 编程实例:在java程序启动一个windows记事本程序的运行实例,并在该运行实例打开该运行程序的源文件,启动的记事本程序5秒后关闭。 public class Property { public static void main(String[] args) { Process p=null; //java虚拟机启动的进程。 try { p=Runtime.getRuntime().exec("notepad.exe Property.java"); //启动记事本并且打开源文件。 Thread.sleep(5000); //持续5秒 p.destroy(); //关闭该进程 } catch(Exception ex) { ex.printStackTrace(); } } } 1.1.1.3Java语言两种异常的差别 Java提供了两主要的异常:runtime exception和checked exception。所有的checked exception是从java.lang.Exception衍生出来的,而runtime exception则是从java.lang.RuntimeException或java.lang.Error衍生出来的。    它们的不同之处表现在两方面:机制上和逻辑上。    一、机制上    它们在机制上的不同表现在两点:1.如何定义方法;2. 如何处理抛出的异常。请看下面CheckedException的定义:    public class CheckedException extends Exception    {    public CheckedException() {}    public CheckedException( String message )    {    super( message );    }    }    以及一个使用exception的例子:    public class ExceptionalClass    {    public void method1()    throws CheckedException    {     // ... throw new CheckedException( “...出错了“ );    }    public void method2( String arg )    {     if( arg == null )     {      throw new NullPointerException( “method2的参数arg是null!” );     }    }    public void method3() throws CheckedException    {     method1();    }    }    你可能已经注意到了,两个方法method1()和method2()都会抛出exception,可是只有method1()做了声明。另外,method3()本身并不会抛出exception,可是它却声明会抛出CheckedException。在向你解释之前,让我们先来看看这个的main()方法:    public static void main( String[] args )    {    ExceptionalClass example = new ExceptionalClass();    try    {    example.method1();    example.method3();    }    catch( CheckedException ex ) { } example.method2( null );    }    在main()方法,如果要调用method1(),你必须把这个调用放在try/catch程序块当,因为它会抛出Checked exception。    相比之下,当你调用method2()时,则不需要把它放在try/catch程序块当,因为它会抛出的exception不是checked exception,而是runtime exception。会抛出runtime exception的方法在定义时不必声明它会抛出exception。    现在,让我们再来看看method3()。它调用了method1()却没有把这个调用放在try/catch程序块当。它是通过声明它会抛出method1()会抛出的exception来避免这样做的。它没有捕获这个exception,而是把它传递下去。实际上main()方法也可以这样做,通过声明它会抛出Checked exception来避免使用try/catch程序块(当然我们反对这种做法)。    小结一下:    * Runtime exceptions:    在定义方法时不需要声明会抛出runtime exception;    在调用这个方法时不需要捕获这个runtime exception;    runtime exception是从java.lang.RuntimeException或java.lang.Error衍生出来的。    * Checked exceptions:    定义方法时必须声明所有可能会抛出的checked exception;    在调用这个方法时,必须捕获它的checked exception,不然就得把它的exception传递下去;    checked exception是从java.lang.Exception衍生出来的。    二、逻辑上    从逻辑的角度来说,checked exceptions和runtime exception是有不同的使用目的的。checked exception用来指示一种调用方能够直接处理的异常情况。而runtime exception则用来指示一种调用方本身无法处理或恢复的程序错误。    checked exception迫使你捕获它并处理这种异常情况。以java.net.URL的构建器(constructor)为例,它的每一个构建器都会抛出MalformedURLException。MalformedURLException就是一种checked exception。设想一下,你有一个简单的程序,用来提示用户输入一个URL,然后通过这个URL去下载一个网页。如果用户输入的URL有错误,构建器就会抛出一个exception。既然这个exception是checked exception,你的程序就可以捕获它并正确处理:比如说提示用户重新输入。 
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值