Java（十五）包与权限/异常体系

包与权限

 包

包：其实在JAVA当中就是一系列的文件夹而已。
    比如说：com.open.wenjian   规范：包名必须小写 且包名与包名之间用.来分隔
   这里就是存在 com文件夹
                               open文件夹
                                      wenjian文件夹
   最后的 wenjian文件夹存放的是.java 文件。

包到底有什么用？最要的用法就是用于分类我的代码
    将来我们在做大型项目的时候 我们的Java代码会很多 把它们放到一个文件夹下 管理上比较混乱于是将这些代码分开存储。
    Java类：主类/测试类  实体类 工具类...
       包名 service 存放业务代码
       包名 entity  存放实体类代码
       包名util    存放工具类代码
    业务逻辑代码与底层逻辑代码 在区分开存放

示例：

包的创建：

具体代码：
包 com.dao；数据业务层包

package com.dao;
//数据业务层包
import com.data.UsersData;
import com.entity.User;

//DBConnect就是在连接我们的数据库
public final class DBConnect {
	public static User[] users;
	
	private DBConnect() {
		
	}
	static {
		System.out.println(">>>连接数据库中...");
		System.out.println(">>>连接数据库成功！");
		users = UsersData.usersData;
	}
}

package com.dao;

import java.util.Arrays;

import com.entity.User;

//底层逻辑代码
//UserDao相当于将登录/注册/修改密码功能统一在UserDao里
//相当于对User的操作基本集中在此处

public class UserDao {

	public boolean query(User user) {
		for (int i = 0; i < DBConnect.users.length; i++) {
			if (DBConnect.users[i].equals(user)) {
				return true;
			}
		}
		return false;
	}

	public boolean add(User user) {
		DBConnect.users=Arrays.copyOf(DBConnect.users, DBConnect.users.length+1);
		DBConnect.users[DBConnect.users.length-1] = user;
		return true;
	}

	public void change(User newUser) {

	}

}

包com.data;数据包：

package com.data;
//数据包
import com.entity.User;


//UsersData存放的是一些User的用户 模拟数据库的
public final class UsersData {
	public static User[] usersData = new User[5];

	static {
		for (int i = 0; i < usersData.length; i++) {
			usersData[i] = new User("user" + i, "password" + i);
		}
	}

	private UsersData() {

	}

}

包 com.entity;实体包

package com.entity;
//实体包
//实体类 User 主要用户描述用户：账户 密码
public class User {
	private String account; // 账户
	private String password;// 密码

	public User() {
		super();
	}

	public User(String account, String password) {
		super();
		this.account = account;
		this.password = password;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		User other = (User) obj;
		if (account == null) {
			if (other.account != null)
				return false;
		} else if (!account.equals(other.account))
			return false;
		if (password == null) {
			if (other.password != null)
				return false;
		} else if (!password.equals(other.password))
			return false;
		return true;
	}

	public String getAccount() {
		return account;
	}

	public void setAccount(String account) {
		this.account = account;
	}

	public String getPassword() {
		return password;
	}

	public void setPassword(String password) {
		this.password = password;
	}
}

包 com.service;业务逻辑包

package com.service;
//业务逻辑包
import com.dao.UserDao;
import com.entity.User;

//主要负责用户登录的业务逻辑代码
public class UserLogin {
	UserDao userDao = new UserDao();

	public void userLogin(User user) {
		boolean isExist = userDao.query(user);
		if (isExist){
			System.out.println(">>>用户已存在，允许登录!");
		}else{
			System.out.println(">>>用户不存在，不许登录!");
		}
	}
}

package com.service;
//业务逻辑包
import com.dao.UserDao;
import com.entity.User;

public class UserRegist {
	UserDao userDao = new UserDao();

	public void userRegist(User user) {
		if(userDao.add(user)){
			System.out.println(">>>添加用户成功！");
		}
	}
}

包 com.main;测试
 

package com.main;
//测试
import java.util.Scanner;

import com.entity.User;
import com.service.UserLogin;
import com.service.UserRegist;
//测试类
public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		System.out.print("请输入账户:");
		String account = scanner.nextLine();
		System.out.print("请输入密码：");
		String password = scanner.nextLine();
		User user = new User(account, password);
		UserLogin userLogin = new UserLogin();
		userLogin.userLogin(user);
		
		UserRegist userRegist = new UserRegist();
		userRegist.userRegist(user);
		
		userLogin = new UserLogin();
		userLogin.userLogin(user);
	}
}

权限：

 

Java中的权限：

•          公共 public
•         保护 protected
•         默认 啥也不写
•         私有 private

 权限使用范围：

                         public     protected     默认     private
    本类中              √             √                √             √
    本包中              √             √                √
    其他包中继承    √            √
    其他包中           √       
    public       只要是在当前项目中 都可以访问。
    private      只能在本类中访问。
    默认         只能在本包中访问(无论继承)。
    protected 本包中可以访问(无论继承);其他包中只能继承访问。

代码示例：
  b包 art01.包与权限;

package part01.包与权限;

public class DemoA {
	public void showPublic() {

	}
        //受保护的权限
	protected void showProtected() {

	}
        //默认权限
	void showDefault() {

	}
        //私有权限
	private void showPrivate() {

	}
        //公开权限
	public void test() {
		showPublic();
		showPrivate();
		showDefault();
		showPrivate();
	}
}

package part01.包与权限;
//子类继承父类
public class DemoB extends DemoA{
	public void test() {
		showPublic();
		showProtected();
		showDefault();
	}
}

package part01.包与权限;
//测试
public class QuanXianDemo01 {
	public static void main(String[] args) {
		DemoA da = new DemoA();
		da.showPublic();
		da.showProtected();
		da.showDefault();
	}
}

package part01.包与权限;
//测试
public class QuanXianDemo01 {
	public static void main(String[] args) {
		DemoA da = new DemoA();
		da.showPublic();
		da.showProtected();
		da.showDefault();
	}
}

在另一个包中：com.权限测试;

package com.权限测试;

import part01.包与权限.DemoA;

public class DemoC extends DemoA{
	public void test() {
		showPublic();
		showProtected();
	}
}

package com.权限测试;

import part01.包与权限.DemoA;

public class QuanXianDemo03 {
	public static void main(String[] args) {
		DemoA da =new DemoA();
		da.showPublic();
	}
}

异常体系

异常：指的就是程序在编译或运行的过程中 出现的一些错误。
例如：小明上课路上感冒了 吃药    不影响上课
    小明上课路上车祸了 去医院    影响上课了
万事万物接对象：问题也是对象；我们用面向对象的思想去考虑问题。
怎么去描述问题？ 描述 问题的名称，问题的描述/原因，问题的发生的位置。

既然有了异常体系，那么势必在这个体系内要有一个最终父类
    “有问题就解决问题，问题解决不了 就解决提出问题的人”  “提出一个问题”
    但凡是问题 都要被提出/抛出 我们不能讲问题当成是一个正常的返回值来处理-解决问题(声明，捕获)
    在Java中，异常体系的最终父类是

Throwable 只有当对象是此类（或其子类之一）的实例时，才能通过 Java 虚拟机或者 Java throw 语句抛出
        Error   : 严重性的问题 一般而言是由Java虚拟机直接抛出
                    主要是在内存上的一些问题 我们后期不会自主的去抛出这个异常，对于内存而言，我们是不能直接控制的， 所以我们也不是很清楚什么时候会发生内存错误！
        Exception    : 一般性的问题 可以由Java虚拟机直接抛出 或者throw抛出。
            编译时异常：Exception及其其他子类，是那些可能在 Java 程序在正常编译期间抛出的异常的父类。
            运行时异常：RuntimeException，是那些可能在 Java 虚拟机正常运行期间抛出的异常的父类。

编译时异常：在程序编译期间就能够发现的问题，问题可能会发生，也可能不会发生，   预防之后出错。
                      预防方式：
                            声明：就是告诉调用者 我可能会有问题 如果真的发生了 调用者来决定怎么去处理
                            捕获：就是当前自身去解决问题,并尝试阻止程序中断
            
  运行时异常：在程序运行期间才能发现的问题，如果这个问题一旦发生，那么程序就直接中断。一旦出错就来不及了 直接中断。
   运行时异常需不需要声明或者捕获？可以的 但是没必要 看具体需求，但是一般不会声明 声不声都一样 最终程序报错且中断，一般会捕获 至少保证程序继续运行。 

什么叫做由Java虚拟机直接抛出，throw抛出？
        JVM抛出的问题 要么是Erorr严重性的问题（不可控的） 要么是Exception问题（你知道 也可控 但是你不想写）。
        throw抛出的 一般都是可控的问题（预先知道的可能会出现的问题）。
  Java中异常够用吗？
        现实生活中，问题可能是方方面面的，很多，JAVA异常显然是不够吗的，于是就有自定义异常。

代码示例：

package part02.异常体系;

import java.util.ArrayList;

public class ThrowableDemo01 {
	static int i=0;
	public static void main(String[] args) {
		int[] arr = new int[10];
		System.out.println(show(arr,9));
//		test01();	//StackOverflowError	栈溢出异常
		test02();	//OutOfMemoryError		堆溢出异常
	}

	private static void test02() {
		//动态的数组(自动扩容)
		ArrayList<Block> list =new ArrayList<>();
		while (true) {
			list.add(new Block());
		}
	}

	private static void test01() {
		i++;
		System.out.println(i);
		test01();
	}


	public static int show(int[] arr, int index) {
		//对于JVM而言 是这么做的
		if (arr == null) {
			throw new NullPointerException();	//RuntimeException
		}
		if (index < 0 || index >= arr.length) {
			throw new ArrayIndexOutOfBoundsException();	//RuntimeException
		}
		System.out.println("呵呵~~~~~");
		return arr[index];
	}
}
class Block {
	byte[] b = new byte[1024*1024*100];	//100mb的数组
}

package part02.异常体系;

public class ThrowableDemo02 {
	//JVM老板 main经理 sleep你
	public static void main(String[] args) {
		/*
		System.out.println(10/0);// ArithmeticException: / by zero
		疑虑：这个文件真的存在吗？不存在怎么办？
		readFile("C:\\User\\HENG\\haha.java");
		*/
		try {
			sleep(24);
		} catch (SleepTimeCannotLessThanZero e) {
			e.printStackTrace();
		}
		System.out.println("呵呵~");
	}

	private static boolean sleep(int time) throws SleepTimeCannotLessThanZero { // [0,72]合理的值
		
		try{
			System.out.println(10/0);// throw ArithmeticException();
		} catch(ArithmeticException e) {
			e.printStackTrace();
		}
		
		if (time < 0) {
			throw new SleepTimeCannotLessThanZero("睡眠时间不能小于0小时");
		}
		if (time > 72) {
			try {
				//尝试运行的代码
				throw new SleepTimeCannotBiggerThanSeventyTwo("睡眠时间不能大于72小时");
			} catch(SleepTimeCannotBiggerThanSeventyTwo e) {//= new SleepTimeCannotBiggerThanSeventyTwo();
				//尝试挽救的代码
				e.printStackTrace();
				time=0;
			}
		}
		System.out.println("小明睡了" + time + "小时");
		return true;
	}
}
//如果一个函数当中出现了问题 那么一般就不会再有一个正常的返回值(如果你非要用特殊值去返回的)
//JVM能够抛出的都是已经存在的异常体系中的对象
//JVM中并没有对自定义异常发生时条件的判断（除非修改源码）
//如果对于我们的自定义异常的话 只能手动抛出

package part02.异常体系;
//睡眠时间不能小于0
/*
 * Throwable中
 * 		问题的原因 String detailMessage 可以由子类传入
 * 		问题的地点 自己实现了
 * 		问题的名称 只能由子类名称来决定
 * Exception而言 
 * 	问题出现的地点 已经实现了
 *  问题出现的原因 可以由调用者来指定
 *  问题出现的名称 就是你自定义类的名称
 * */
public class SleepTimeCannotLessThanZero extends Exception{
	public SleepTimeCannotLessThanZero(String message) {
		super(message);
	}
}

package part02.异常体系;
//睡眠时间不能大于72小时
public class SleepTimeCannotBiggerThanSeventyTwo extends Exception{
	public SleepTimeCannotBiggerThanSeventyTwo(String message) {
		super(message);
	}
}