java_自定义异常、打包、自定义模块模式、

/*
内部类

内部类类别：

成员内部类: 在一个类的成员位置定义另外一个类，那么另外 一个 类就称作为成员内部类。    成员内部类的访问方式：        方式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是用于方法 声明上声明抛出异常类型的。

*/
/*
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("正常显示好友列表..");    }}

/*

异常体系：
——–| Throwable 所有错误或者异常的父类
————–| Error（错误）
————–| Exception(异常) 异常一般都通过代码处理

——————| 运行时异常: 如果一个方法内部抛出了一个运行时异常，那么方法上 可以声明也可以不 声明，调用者可以以处理也可以不处理。
——————| 编译时异常(非运行时异常、受检异常): 如果一个方法内部抛出了一个编译时异常对象，那么方法上就必须要声明，而且调用者也必须要处理。

运行时异常： RuntimeException以及RuntimeException子类 都是属于运行时异常。

编译时异常： 除了运行时异常就是编译异常。

疑问： 为什么java编译器会如此严格要求编译时异常，对运行时异常如此宽松？

运行时异常都是可以通过程序员良好的编程习惯去避免，所以java编译器就没有严格要求处理运行时异常。

*/

import java.security.acl.*;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);        }    }}

/*
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块的代码执行了..");        }    }}

/*
打jar包: 需要使用到jdk的开发工具（jar.exe）.

jar的用法：

使用格式：

jar cvf jar文件的名字  class文件或者是文件夹 

打jar包要注意的事项：
1. 一个程序打完了jar之后 必须要在清单文件上指定入口类： 格式 Main-Class: 包名.类名
2. jar包双击运行仅对于图形化界面的程序起作用，对控制台的程序不起作用。

jar文件的作用：
1. 方便用户快速运行一个项目。
2. 提供工具类以jar包的形式给别人使用。

如果使用jar包里面的类必须要先设置classpath路径。

jre = jvm+ 核心类库

*/

package qq;import javax.swing.*;class Demo9 {    public static void main(String[] args)     {        System.out.println("QQ程序..");        JFrame frame = new JFrame("QQ程序");        frame.setSize(400,500);        frame.setVisible(true); //设置窗口可见。        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);    }}

/*
模板模式 ：解决某类事情的步骤有些是固定的，有些是会发生变化的，那么这时候我们可以
为这类事情提供一个模板代码，从而提高效率 。

需求；编写一个计算程序运行时间 的模板。

模板模式的步骤：
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++;        }    }}

/*
11.目前有数组” 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;    }}