Java 的异常与包

Java基础系列

一： 知识回顾：

面向接口编程：
  Object 
  -------
   降低耦合度。
   接口是最低标准。
   多重继承。
   方法可以覆盖
   属性无法覆盖

二： java的异常：

2.1 异常：

异常的体系：
 - Throwable 
   - Error
     - 通常出现重大问题如： 运行的类不存在或者内存溢出等。
     - 不编写针对代码对其处理
   - Exception 
     - 在运行时运行出现的一起情况，可以通过try catch finally 
- Exception 和 Error 的子类名都是以父类名作为后缀。
Throwable 中的方法：
- getMessage()
  - 获取异常信息，返回字符串
- toString()
  - 获取异常类名和异常信息，返回字符串
 - printStackTrace()
  - 获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void 
 - printStackTrace(PrintStream s)
  - 通常用该方法将异常内容保存在日志文件中，以便于查阅。
 异常：
  -----
     Exception.
     java.lang.NullPointerException
     .... ArryIndexOutOfBoundsException.
     ClassCastException,
     runtimeExcetpion // 运行时异常不需要在方法的定义中进行声明
 java.lang.Object
      --- java.lang.Throwable
              ---java.lang.Error // 硬伤
              --- java.lang.Exception // 异常
  Exception
  ------
  通过 try-catch-finally 语句解决
    try{
      需要检测的代码；
    }
    catch(异常类 变量){
     异常处理代码；
    }
    finally{
        一定会执行的代码；
    } 
  finally 代码块只有一种情况不会被执行，就是在执行了System.exit(0)
  可以有多个catch语句，catch 的顺序需要注意。
  子类异常需要先行catch，否则不可达，编译也无法通过。
 方法重写时，不能什么抛出新的异常类型。只能是原有异常类型体系（异常子类）。
Throwable
----------------------
  可以抛出的
  是所有异常和错误的超类
  throw      // 抛出异常对象的指令
  throws     // 在方法中声明抛出异常的关键字
  throws 和throw 
  ---------------------
  - throws 用于标识函数暴露出的异常。
  - throw 用于抛出异常对象。
  - throws 与throw 的区别
    - throws 用在函数上，后面跟异常类名
    - throw 用在函数内，后面跟异常对象。

package com.learnjava.day07;
public class ExceptionDemo01 {
       public static void main(String[] args) {
         Exception e = new Exception();
         Exception e2 = new Exception("出错了");
        // System.out.println(arr.length);
         // 打印异常信息
        // System.out.println(e2.getMessage());
        // System.out.println(e2.getStackTrace());
         // 打印栈跟踪信息
        // e2.printStackTrace();
        // System.out.println(1/0);
         test();
    }
public static void test() {
    try {
        throw new Exception("出错了");
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }
    finally {
        System.out.println("搞定了");
    }
}
}

package com.learnjava.day07;
public class ExceptionDemo02 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
           int [] arr = null; // {1,2,3,4,5};
           outArr(arr);
    }
    public static void outArr(int [] arr) {
        try {
            for (int i = 0 ; i < arr.length ; i++) {
                System.out.println(arr[i]+ " ");
            }
        } catch (Exception e) {
            System.out.println("数组有问题。。。。");
        }
    }
}

package com.learnjava.day07;
public class ExceptionDemo03 {
    public static void main(String[] args) throws AgeTooSmailExpection, AgeTooBigExpection  {
        // TODO Auto-generated method stub      
             Person p = new Person();
             p.setAge(100);
             System.out.println(p.getAge());
    }
}
class Person{
   private int age ;
public int getAge() {
    return age;
}
public void setAge(int age) throws AgeTooSmailExpection, AgeTooBigExpection {
     if(age < 0) {
         throw  new AgeTooSmailExpection("年龄太小，不合法");
     }
     if(age > 200) {
         throw  new AgeTooBigExpection("年龄太大，不合法");
     }
    this.age = age;
}
}
@SuppressWarnings("serial")
class AgeTooSmailExpection extends Exception{
    public AgeTooSmailExpection() {
    }
    public AgeTooSmailExpection(String msg) {
        super(msg);
    }
}
@SuppressWarnings("serial")
class AgeTooBigExpection extends Exception {
      public AgeTooBigExpection() {
      } 
       public AgeTooBigExpection(String msg) {
          super(msg);
      } 
}

package com.learnjava.day07;
public class ExceptionDemo03 {
    public static void main(String[] args)  {
        // TODO Auto-generated method stub      
             Person p = new Person();
             try {
                p.setAge(-100);
            } catch (Exception e) {
                // TODO Auto-generated catch block
            System.out.println(e.getMessage());
            }
             System.out.println(p.getAge());
    }
}
class Person{
   private int age ;
public int getAge() {
    return age;
}
public void setAge(int age) throws AgeTooSmailExpection, AgeTooBigExpection {
     if(age < 0) {
         throw  new AgeTooSmailExpection("年龄太小，不合法");
     }
     if(age > 200) {
         throw  new AgeTooBigExpection("年龄太大，不合法");
     }
    this.age = age;
}
}
@SuppressWarnings("serial")
class AgeTooSmailExpection extends Exception{
    public AgeTooSmailExpection() {
    }
    public AgeTooSmailExpection(String msg) {
        super(msg);
    }
}
@SuppressWarnings("serial")
class AgeTooBigExpection extends Exception {
      public AgeTooBigExpection() {
      } 
       public AgeTooBigExpection(String msg) {
          super(msg);
      } 
}

2.2 异常的处理细节　

1. RuntimeException 以及其子类如果在函数中被throw 抛出，可以不用在函数上声明。
2.一个方法被覆盖时，覆盖他的方法必须抛出相同的异常或异常的子类
３.如果父类抛出多个异常，那么重写（覆盖）方法必须抛出那些异常的一个子集，不能抛出新的异常。
4.介绍异常在分层设计时的层内封装。
5.例程。

package com.learnjava.day07;
public class ExceptionDemo03 {
    public static void main(String[] args)  {
        // TODO Auto-generated method stub      
             Person p = new Person();
             try {
                p.setAge(-100);
            } catch (Exception e) {
                // TODO Auto-generated catch block
            System.out.println(e.getMessage());
            }
             System.out.println(p.getAge());
    }
}
class Person{
   private int age ;
public int getAge() {
    return age;
}
class student extends Person {
    public void setAge(int age) throws AgeTooSmailExpection, AgeTooBigExpection {
        if (age < 6 || age > 15) {
            throw new InvalidAgeException("年龄超出小学的年龄。。。");
        }
        super.setAge(age);
        System.out.println("设置年龄over。。。。");
    }
}
public void setAge(int age) throws AgeTooSmailExpection, AgeTooBigExpection {
     if(age < 0) {
         throw  new AgeTooSmailExpection("年龄太小，不合法");
     }
     if(age > 200) {
         throw  new AgeTooBigExpection("年龄太大，不合法");
     }
    this.age = age;
}
}
@SuppressWarnings("serial")
class AgeTooSmailExpection extends Exception{
    public AgeTooSmailExpection() {
    }
    public AgeTooSmailExpection(String msg) {
        super(msg);
    }
}
@SuppressWarnings("serial")
class AgeTooBigExpection extends Exception {
      public AgeTooBigExpection() {
      } 
       public AgeTooBigExpection(String msg) {
          super(msg);
      } 
}
@SuppressWarnings("serial")
// 自定义异常
class InvalidAgeException extends AgeTooSmailExpection{
    private String info ;
    public InvalidAgeException(String info) {
        this.info = info;
    }
    public void outInfo() {
        System.out.println(info);
    }
}

三：java 的包

3.1 包的管理

1. 对类文件进行分类管理
2. 对类提供多层命名空间
3. 写在程序文件的第一行
4. 类名的全称的是包名.类名。
5. 包也是一种封装形式。
package ---
---------
包：　
类似于文件夹，组织管理的结构。
www.sina.com
www.baidu.com
com.sina.weibo.
com.sina.weixin.
完整的类名：
　包名　＋ . + 类名：
　如: com.learnjava.day07.PackageDemo
　mkdir classes 
　javac -d classes PackageDemo.java 
　// -d 指定存放classes 文件的位置。
　java -cp classes com.learnjava.day07.PackageDemo

package com.learnjava.day06;
public class Package01 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
          System.out.println("hello package06");
    }
    public static void sayHello(String msg) {
             System.out.println(msg);
    }
}

package com.learnjava.day07;
import com.learnjava.day06.Package01;
public class PackageDemo {
     public static void main(String[] args) {
               Package01.sayHello("how are you!!!!"); 
             System.out.println("hello world");         
            }
}

javac -d classes Package01.java
javac -cp classes -d classes packageDemo01.java
java -cp classes com.learnjava.day07.PackageDemo01

3.2 包的之间的访问

1. 被访问的保重类权限必须是public.
2. 类中的成员权限:public 或者 protected 
3. protected 是为其他包中的子类提供一种权限
4. 例程
　权限 （可见性）：
　－－－－－
　 public     //公有的
　 protected  //受保护的
　 default　　//默认的
　 private 　　//私有的
　 
5. 关系：
   同类 > 同包 > 子类 > 不同包
6.import 导入：
   - 简化类名：
   - 一个程序文件中只有一个package  也可以有多个import 
   - 用来导包中的类，不导入包中的包。
   - 通常写 import mypacke.Demo;
     而不写import mypacke.*; 
 6. jar 
    - java archieve,java归档，打包
    - jar war ear har
    - 对Java文件进行归档。
       - jar cvf xxx.jar -C foo/ .  // 将fool 全部打包。
     // 归档时，指定入口点：
     - jar cvfe xx.jar com.learnstudy.e.EE -C foo/ .
    // 归档时，指定入口点，会在清挡文件中添加Main-class  属性。
    jar cvfe xx.jar com.learnjava.
    - 通过jar 文件执行程序
    java -cp xxx.jar com.learnstady.e.EE
    java -jar xxx.jar

package com.learnjava.day07;
public class PackageDemo01 {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
         A a = new A();
         a.sayHello("say hello");
         B b = new B();
         b.bayHello("hahaha");
    }
}
class A  {
    protected void sayHello(String msg) {
        System.out.println(msg);
    }
}
class B extends A {
    protected void bayHello(String msg) {
        System.out.println(msg);
    }
}