第11天 自定义异常、权限修饰符、jar包、清除重复元素

1.
回顾上次课的内容


内部类

内部类类别：
成员内部类: 在一个类的成员位置定义另外一个类，那么另外 一个 类就称作为成员内部类。
成员内部类的访问方式：
方式1： 在外部类内提供一个方法创建内部类的对象进行访问。
方式2： 在其他类创建内部类的对象进行访问。 创建的格式： 外部类.内部类  变量名 = new 外部类().new 内部类();
注意：如果是静态内部类在其他类的创建对象方式：  外部类.内部类 变量名=  new 外部类.内部类();
成员内部类要注意的事项：
1. 成员内部类可以直接访问外部类成员。
2. 如果成员内部类与外部类存在同名的成员，在内部类中默认是访问内部类 的成员。
成员通过“外部类.this.成员”指定访问外部类的成员。
3. 如果成员内部类出现了静态的成员，那么该成员内部类也必须使用static修饰。
4. 如果成员内部类是私有的，那么创建内部类的对象就只能在外部类提供方法创建。

 局部内部类  ： 在一个类的方法内部定义另外一个类,  另外一个类就称作为局部内部类。
局部内部类要注意： 如果局部内部类访问了局部变量，那么该变量需要使用fianl修饰。 （原因： 因为生命周期不一致，所以内部类访问局部变量其实是一个复制品。）
匿名内部类 : 没有类名的类。
匿名内部类的好处： 简化书写。
匿名内部类的使用前提： 必须存在继承或者实现关系。
匿名内部类的格式：
new 父类(父接口){
匿名内部类的成员;
};

 异常：

异常的体系：

---------|Throwable 

--------------|  Error （错误）  错误一般是由于jvm或者是硬件引发的问题，所以我们一般都不会通过代码去处理。

--------------| Exception (异常) 异常我们一般都会通过代码去处理的。

异常的处理方式
方式一：捕获处理
捕获处理的格式
try{
可能发生异常的代码
}catch(捕获的异常类型  变量名){
处理异常的代码
}
捕获处理要注意的细节：
1. 如果一个try块中出现了异常的代码，经过处理之后，那么try-catch块外面的代码可以正常执行。
2. 如果一个try块中出现了异常的代码，那么在try块中出现异常的代码后面 的语句无法执行。
3. 一个try块后面可以跟多个catch块，也就是一个try块可以捕获多种异常的类型，但是捕获的
异常类型必须从小到大进行捕获。
方式二：抛出处理(throw throws)
抛出处理要注意的细节：
1. 如果一个方法内部抛出了一个编译时异常对象，那么该方法必须要声明抛出。
2. 如果调用了一个声明抛出编译时异常的方法，那么调用者必须要处理。
3. 如果一个方法抛出了一个异常对象，那么该方法也会马上停止（一个方法遇到了throw关键字，那么该方法就会马上停止）
4. 在一种情况下只能抛出一种异常对象。

throw 关键字是用于方法体之内抛出异常对象 的，throws是用于方法 声明上声明抛出异常类型的。

package com.xp.exception;
/*
sun提供了很多的异常类给我们用于描述程序中各种的不正常情况，但是sun 给我
提供异常类还不足以描述我们现实生活中所有不正常情况，那么这时候我们就需要
自定义异常类。
需求: 模拟feiQ上线的时候,如果没有插上网线，那么就抛出一个没有插上网线的异常，
如果已经插上了网上，那么就正常显示好友列表。
自定义异常类的步骤： 自定义一个类继承Exception即可。
*/
//自定义了一个没有网线的异常类了。
class NoIpException extends Exception{
public NoIpException(String message){
super(message); //调用了Exception一个参数的构造函数。
}
}
class Demo2
{
public static void main(String[] args)
{
String ip = "192.168.10.100";
ip = null;
try{
feiQ(ip); // 如果调用了一个声明抛出异常类型的方法，那么调用者必须要处理。
}catch(NoIpException e){
e.printStackTrace();
System.out.println("马上插上网线！");
}
}
public static void feiQ(String ip) throws NoIpException{
if(ip==null){
throw new NoIpException("没有插网线啊，小白！");
}
System.out.println("正常显示好友列表..");
}
}

2.自定义异常实例

package com.xp.exception;
/*
需求：模拟你去吃木桶饭，如果带钱少于了10块，那么就抛出一个没有带够钱的异常对象，
如果带够了，那么就可以吃上香喷喷的地沟油木桶饭.
*/
//定义没钱的异常
class NoMoneyException extends Exception {
public NoMoneyException(String message) {
super(message);
}
}
class Demo3 {
public static void main(String[] args) {
// System.out.println("Hello World!");
try {
eat(9);

} catch (NoMoneyException e) {
e.printStackTrace();
System.out.println("跟我洗碗一个月！！");
}
}
public static void eat(int money) throws NoMoneyException {
if (money < 10) {
throw new NoMoneyException("吃霸王餐");
}
System.out.println("吃上了香喷喷的地沟油木桶饭!!");
}
}

3.运行时异常、编译时异常

package com.xp.exception;
/*
异常体系：
--------| Throwable  所有错误或者异常的父类
--------------| Error（错误）
--------------| Exception(异常) 异常一般都通过代码处理
------------------| 运行时异常: 如果一个方法内部抛出了一个运行时异常，那么方法上 可以声明也可以不 声明，调用者可以以处理也可以不处理。
------------------| 编译时异常(非运行时异常、受检异常):  如果一个方法内部抛出了一个编译时异常对象，那么方法上就必须要声明，而且调用者也必须要处理。
运行时异常： RuntimeException以及RuntimeException子类 都是属于运行时异常。
编译时异常： 除了运行时异常就是编译异常。
疑问： 为什么java编译器会如此严格要求编译时异常，对运行时异常如此宽松？
运行时异常都是可以通过程序员良好的编程习惯去避免，所以java编译器就没有严格要求处理运行时异常。
*/
class Demo4
{
public static void main(String[] args) throws InterruptedException
{
int[] arr = null;
div(4,0,arr);
Object o = new Object();
o.wait();
}
public static void div(int a , int b ,int[] arr) {
if(b==0){
return;
}
int c = a/b;
System.out.println("c = "+c);
if(arr!=null){
System.out.println("数组的长度： "+arr.length);
}
}
}

4.finally块

package com.xp.exception;
/*
finally 块；
finally块的 使用前提是必须要存在try块才能使用。
finally块的代码在任何情况下都会执行的，除了jvm退出的情况。
finally非常适合做资源释放的工作，这样子可以保证资源文件在任何情况下都 会被释放。
try块的三种组合方式：
第一种： 比较适用于有异常要处理，但是没有资源要释放的。
try{
可能发生异常的代码
}catch(捕获的异常类型 变量名){
处理异常的代码
}
第二种：比较适用于既有异常要处理又要释放资源的代码。
try{
可能发生异常的代码
}catch(捕获的异常类型 变量名){
处理异常的代码
}finally{
释放资源的代码;
}
第三种： 比较适用于内部抛出的是运行时异常，并且有资源要被释放。
try{
可能发生异常的代码
}finally{
释放资源的代码;
}
*/
class Demo5
{
public static void main(String[] args)
{
//System.out.println("Hello World!");
div(4,0);
}
public static void div(int a, int b){
try{
if(b==0){
System.exit(0);//退出jvm
}
int c = a/b;
System.out.println("c="+ c);

}catch(Exception e){
System.out.println("出了除数为0的异常...");
throw e;
}finally{
System.out.println("finall块的代码执行了..");
}
}
}
package com.xp.exception;
/*
fianlly释放资源的代码
*/
import java.io.*;
class Demo6
{
public static void main(String[] args)
{
FileReader fileReader = null;
try{
//找到目标文件
File file = new File("f:\\a.txt");
//建立程序与文件的数据通道
fileReader = new FileReader(file);
//读取文件
char[] buf = new char[1024];
int length = 0;
length = fileReader.read(buf);
System.out.println("读取到的内容："+ new String(buf,0,length));
}catch(IOException e){
System.out.println("读取资源文件失败....");
}finally{
try{
//关闭资源
fileReader.close();
System.out.println("释放资源文件成功....");
}catch(IOException e){
System.out.println("释放资源文件失败....");
}
}
}
}

5.导包语句

问题：当定义了多个类的时候，可能会发生类名的重复问题。

在java中采用包机制处理开发者定义的类名冲突问题。

怎么使用java的包机制呢？

1. 使用package 关键字。

2. package 包名。

/*

有了包之后类与类之间的访问：

问题： 有了包之后类与类之间的访问每次都必须 要写上包名！烦！！！！

解决方案： sum提供导包语句让我们解决该问题。

导包语句作用：简化书写。 (误区：把一个类导入到内存中)

导包语句的格式：

         import 包名.类名;   （导入xxx包中某个类）

包的作用

1.  防止类文件冲突。

2.  使源文件与类文件分离，便已软件最终发布。

导包语句要注意的细节：

    1. 一个java文件中可以出现多句导包语句。

    2. "*"是 导包语句的通配符。可以匹配任何 的类名。

    3. import aa.*; 是不会作用于aa包下面的子包的。

4．一个java类只能定义在一个包中。

5.包语句肯定是描述类的第一条语句。

推荐使用：import 包名.类名;  因为使用*通配符会导致结构不清晰。

什么时候使用import语句:

   1. 相互访问的两个类不是在同一个包下面，这时候就需要使用到导包语句。

   2. java.lang 是默认导入 的，不需要我们自己导入。

*/

package aa;
public class Demo3
{
/*
static{
System.out.println("这个是Dmeo3的静态代码块...");
}
*/
public void print(){
System.out.println("这个是Dmeo3的print方法...");
}
}

1.



1. javacPackDemo1.java编译没有问题。

2. javaPackDemo1 运行出错。



错误原因分析：
在当前目录下找不到有pack目录，更加找不到pack目录下面的PackageDemo1.java文件。

解决办法： 

1. 自己在当前目录下新建一个pack目录。

2. 执行Java pagk.PackageDemo1命令。(包其实就是文件夹).

存在的问题：使用包机制的话，我们是否每次都要自己创建一个文件夹呢？

解决：
在编译的时候则可以指定类文件存放的文件夹了。
javac -d . PackageDemo1.java    -d 后面跟着就是包名，指定包存放的路径。

注意细节：

1. 如果想使用一个包中的许多类时，这时不需要多条的导入语句，使用 “*”号通配符代表所有的类。

2. 使用*时不能导入包中的子类包的class文件。

3. import语句可以是多条.

6.权限修饰符

权限修饰符： 权限修饰符就是控制被修饰的成员的范围可见性。
访问修饰符是用来控制类、属性、方法的可见性的关键字称之为访问修饰符。





1.  (修饰类成员)类成员

1.  成员使用private修饰只在本类中使用。

2.  如果一个成员没有使用任何修饰符，就是default，该成员可以被包中的其

3.  他类访问。

4.  protected成员被protected修饰可以被包中其他类访问，并且位于不同

5.  包中的子类也可以访问。

6.  public修饰的成员可以被所有类访问。

2.  (修饰类)类

1.  类只有两种public和默认(成员内部类可以使用private))

2.  父类不可以是private和protected，子类无法继承

3.  public类可以被所有类访问

4.  默认类只能被同一个包中的类访问

7.jar包

1：jar就是打包文件
jar文件时一种打包文件java active File,与zip兼容，称之为jar包
开发了很多类，需要将类提供给别人使用，通常以jar包形式提供.当项目写完之后，需要及将class字节码文件打包部署给客户。如何打包？可以使用jar命令.
2：jar命令
Ø  1：jar工具存放于jdk的bin目录中(jar.exe)
Ø  2：jar工具：主要用于对class文件进行打包(压缩)
Ø  3：dos中输入jar查看帮助
3：案例使用jar命令

将day10中的cn文件打包为名字为test.jar文件(cn 文件是使用javac-d 编译带包的class文件夹)
jar cvf test.jarcn
详细命令:
Ø  1：jar cf test.jar cn 在当前目录生成test.jar 文件，没有显示执行过程
Ø  2：jar cvf test.jar cn 显示打包中的详细信息
Ø  3：jar tf test.jar  显示jar文件中包含的所有目录和文件名
Ø  4：jar tvf test.jar 显示jar文件中包含的所有目录和文件名大小，创建时间详
u 细信息
Ø  5：jar xf test.jar  解压test.jar到当前目录，不显示信息
Ø  6：jar xvf test.jar 解压test.jar到当前目录，显示详细信息
Ø  7：可以使用WinRaR进行jar解压
Ø  8；将两个类文件归档到一个名为test2.jar 的归档文件中：
Ø  jarcvf test2.jar Demo3.class Demo4.class
Ø  9：重定向
Ø  1：tvf可以查看jar文件内容，jar文件大，包含内容多，dos看不全。
Ø  2：查看jdk中的rt.jar 文件 jartvf rt.jar
Ø  3：jar tvf rt.jar>d:\rt.txt

8.模板模式

/*
模板模式 ：解决某类事情的步骤有些是固定的，有些是会发生变化的，那么这时候我们可以
为这类事情提供一个模板代码，从而提高效率 。
需求；编写一个计算程序运行时间 的模板。
模板模式的步骤：
1. 先写出解决该类事情其中 的一件的解决方案。
2. 分析代码，把会发生变化的代码抽取出来独立成一个方法。把该方法描述成一个抽象的方法。
3. 使用final修饰模板方法，防止别人 重写你的模板方法。
*/
abstract class MyRuntime{

public final void getTime(){
long startTime = System.currentTimeMillis();	//记录开始的时间
code();
long endTime = System.currentTimeMillis();  //记录结束的时间.
System.out.println("运行时间 ："+ (endTime-startTime));
}

public abstract void code();
}
class Demo11 extends MyRuntime
{
public static void main(String[] args)
{
Demo11 d = new Demo11();
d.getTime();
}
//code方法内部就写要计算运行时间 的代码；
public  void code(){
int i = 0;
while(i<100){
System.out.println("i="+i);
i++;
}

}
}

9.清除重复元素

目前有数组” int[] arr=  {11,2, 4, 2, 10, 11}，

定义一个函数清除该数组的重复元素，返回的数组存储了那些非重复的元素而且数组不准浪费长度。

分析：

   1. 确定新数组的长度。  原数组的长度-重复元素个数

import java.util.*;
class Demo12 {
public static void main(String[] args)
{
int[] arr =  {11,2, 4, 2, 10, 11};
arr = clearRepeat(arr);
System.out.println("清除重复元素的数组："+ Arrays.toString(arr));
public static int[] clearRepeat(int[] arr){
//先计算出重复元素的格式:
int count = 0; //记录重复元素的个数
for(int i = 0 ; i < arr.length-1 ; i++){
for(int j = i+1 ; j<arr.length ; j++){
if(arr[i]==arr[j]){
count++;
break;
}
}
}
//新数组 的长度
int newLength = arr.length - count;
//创建一个新的数组
int[] newArr = new int[newLength];

int index = 0 ; 	//新数组的索引值
//遍历旧数组
for(int i = 0  ; i< arr.length ; i++){
int temp = arr[i];  //旧数组中的元素
boolean flag = false;  //默认不是重复元素
//拿着旧数组 的元素 与新数组的每个元素比较一次。
for(int j = 0 ; j< newArr.length ; j++){
if(temp==newArr[j]){
flag = true;
break;
}
}

if(flag == false){
newArr[index++] = temp;
}
}
return newArr;
}
}