黑马程序员 Java基础 面向对象：内部类 异常 包 jar包

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

一、内部类当描述事物时，事物的内部还有事物，该事物用内部类来描述。
因为内部事务在使用外部事物的内容。




内部类的访问规则：
1：内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this
2：外部类要访问内部类，必须建立内部类对象。


访问格式：
1：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象。
格式
外部类名.内部类名  变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

2：当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。


在外部其他类中，如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

在外部其他类中，如何直接访问static内部类的静态成员呢？

Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的。


例子：内部类在成员位置访问

//外部类class outerc{private int x=3;//内部类class Inner{int x=4;void function(){int x=6;System.out.println("inner:"+this.x);}}//在外部类的方法中建立内部类的对象对其访问   就可以访问内部类void method(){//System.out.println(x);Inner in=new Inner();in.function();}}public class neibuleiDemo {public static void main(String[] args){//outerc out=new outerc();//建立外部类对象//out.method();//调用外部类方法访问内部类方法//直接访问内部类中的成员    内部类不被私有修饰时可以outerc.Inner in=new outerc().new Inner();in.function();}}

内部类定义在局部时
1：不可以被成员修饰符修饰
2：可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。


例子：局部内部类 

//外部类class outerc{private int x=3;   void method(){//局部内部类调用局部变量需要用 final 修饰final int y=6;//局部内部类class Inner{int i=4;void function(){System.out.println("x:"+x+"y:"+y+"i:"+i);}}new Inner().function();}}public class neibuleiDemo {public static void main(String[] args){new outerc().method();              }}

匿名内部类:
1：匿名内部类其实就是内部类的简写格式。
2：定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
3：匿名内部类的格式：  new 父类或者接口(){定义子类的内容}
4：其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5：匿名内部类中定义的方法最好不要超过3个。


例子：

//抽象类abstract class AbsDemo{abstract void show();}//外部类class Outer{public void function(){//匿名内部类new AbsDemo(){int num = 9;void show(){System.out.println("num==="+num);}}.show();}}public class neibuleiDemo {public static void main(String[] args){new Outer().function();             }}

二、异常
就是程序在运行时出现不正常情况。


体系:
异常体系：
Throwable
|--Error
|--Exception
|--RuntimeException




异常由来：
问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。


对于问题的划分：
两种：一种是严重的问题，一种非严重的问题。


对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。
无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。






异常的处理语句：

try{需要被检测的代码；}catch(异常类 变量){处理异常的代码；(处理方式)}finally{一定会执行的语句；}

有三个结合格式：
1:

try{}catch (){}

2:

try{}finally{}

3:

try{}catch (){}finally{}

异常的好处：
1：将问题进行封装。
2：将正常流程代码和问题处理代码相分离，方便于阅读。




异常的处理原则：
1:处理方式有两种：try 或者 throws。
2:调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。
3:多个catch，父类的catch放到最下面。
4:catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。也不要不写。
5:当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。


对捕获到的异常对象进行常见方法操作。
String getMessage()：获取异常信息。


例子：

class Demo{//在功能上通过throws的关键字声明了该功能有可能会出现问题。int div(int a,int b)throws Exception{return a/b;}}class  ExceptionDemo{public static void main(String[] args) {Demo d = new Demo();try{int x = d.div(4,1);System.out.println("x="+x);}catch (Exception e)//Exception e = new ArithmeticException();{System.out.println("除零啦");System.out.println(e.getMessage());//  / by zero;System.out.println(e.toString());// 异常名称 ： 异常信息。//异常名称，异常信息，异常出现的位置。//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。//打印异常的堆栈的跟踪信息。e.printStackTrace();}System.out.println("over");}}

在函数上声明异常。
便于提高安全性，让调用出进行处理。不处理编译失败。


对多异常的处理。


1:声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2:对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。




建立在进行catch处理时，catch中一定要定义具体处理方式。
不要简单定义一句 e.printStackTrace(),
也不要简单的就书写一条输出语句。


例子：

class Demo{//在功能上通过throws的关键字声明了该功能有可能会出现问题。int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException{int[] arr = new int[a];System.out.println(arr[4]);return a/b;}}class  ExceptionDemo{public static void main(String[] args){Demo d = new Demo();try{int x = d.div(5,0);System.out.println("x="+x);}catch (ArithmeticException e){System.out.println(e.toString());System.out.println("被零除了!!");}catch (ArrayIndexOutOfBoundsException e){System.out.println(e.toString());System.out.println("角标越界啦！！");}System.out.println("over");}}

因为项目中会出现特有的问题，而这些问题并未被java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题。进行自定义的异常封装。


自定义异常：
必须是自定义类继承Exception。




继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。


只有这个体系中的类和对象才可以被throws和throw操作。


throws和throw的区别:
1:throws使用在函数上,throw使用在函数内。
2:throws后面跟的异常类,可以跟多个用逗号隔开,throw后跟的是异常对象。

class FuShuException extends Exception {private int value;FuShuException(){super();}FuShuException(String msg,int value){super(msg);this.value = value;}public int getValue(){return value;}}class Demo{int div(int a,int b)throws FuShuException{if(b<0)throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。return a/b;}}class  ExceptionDemo{public static void main(String[] args) {Demo d = new Demo();try{int x = d.div(4,-9);System.out.println("x="+x);}catch (FuShuException e){System.out.println(e.toString());System.out.println("错误的负数是："+e.getValue());}System.out.println("over");}}

RuntimeException异常：


Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常，如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过，如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。




自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。




对于异常分两种：
1，编译时被检测的异常。

2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)




例子：

//自定义异常类class FuShuException extends Exception{FuShuException(String msg){super(msg);}}class Demo{int div(int a,int b)throws FuShuException{if(b<0)throw new FuShuException("除数为负数");return a/b;}}class  ExceptionDemo{public static void main(String[] args) {Demo d = new Demo();try{int x = d.div(4,-1);System.out.println("x="+x);}catch (FuShuException e){System.out.println(e.toString());return;}finally{//finally中存放的是一定会被执行的代码。System.out.println("finally");}System.out.println("over");}}

异常在子父类覆盖中的体现；
1:子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。
2:如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3:如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。




例子：

/*Exception |--AException|--BException|--CException*///a异常继承于Exceptionclass AException extends Exception{}//b异常继承于aclass BException extends AException{}//c异常继承于Exceptionclass CException extends Exception{}class Fu{void show()throws AException{}}class Test{void function(Fu f){try{f.show();}catch (AException e){}}}class Zi extends Fu{//这里只能抛a异常或者a的子类void show()throws AException{try{}catch (CException e)//c异常只能try处理{}}}class  {public static void main(String[] args) {Test t = new Test();t.function(new Zi());}}

三、包 package
java中的包就相当于系统中的文件夹。
当我们需要将各个类分门别类的存放的时候，或者含有不同功能的相同类名的时候，需要用到包（package）。包可以将相关的类放在一起，并可以将两个或多个相同文件名的文件放在不同包中。


包的作用：
1：对类文件进行分类管理。
2：给类提供多层命名空间。
规则
1：写在程序文件的第一行。
2：类名的全称的是  包名.类名。
3：包也是一种封装形式。


格式：
package pack;


包与包之间的访问：


1：被访问的包中的类权限必须是public的。
2：类中的成员权限：public或者protected
3：protected是为其他包中的子类提供的一种权限


注意：
1：包与包间进行访问，被访问的包中的类以及类中的成员，需要public修饰。
2：不同包中的子类还可直接访问父类中被protected权限修饰的成员。包与包间可使用的权限有两种：public和protected。
3：其中protected只用于覆盖。

包的导入：
1:为了简化类名的书写，使用import导入
如： import com.limbang.test.*;  是将com包下的limbang包下的test包下的所有类导入进来。
注：如果需要limbang下还有类需要导入，则还需在导入，
如： import com.limbang.*;
注意事项：
1：两个包中有相同类名文件，当再统一类中创建对象时，需要加上包名.类名创建。
2：建议定义包名不要重复，可以使用URL来定义，因为URL是唯一的。
如：www.limbang.com---->package com.limbang.Demo以及com.limbang.Test
3：建议，不要写通配符 * ，需要用到包中的哪个类，就导入哪个类。


例子：

package com.limbang.test;    public class FatherDemo {      //父类受保护方法      protected void show(){          System.out.println("protected father");      }      //父类公有方法      public void fuc(){          System.out.println("public father");      }  } 

package com.limbang.test.array;  public class SonDemo extends com.limbang.test.FatherDemo{      public void showSon(){          //自定义方法          System.out.println("son show");          //调用父类方法          show();      }  }

package com.limbang.test.object;    import com.limbang.test.FatherDemo;  import com.limbang.test.array.SonDemo;    public class PackageDemo {        public static void main(String[] args) {          //创建子父类对象          FatherDemo f = new FatherDemo();          SonDemo s = new SonDemo();          //类PackageDemo可访问其他类公有方法          f.fuc();//public father          //访问其他类受保护方法，不可          //f.show();//报错          s.fuc();//public father          //子类可访问父类受保护方法          s.showSon();/*son show                     protected father*/      }  }  

四、Jar包


Java的压缩包的好处：
1：方便项目的携带。
2：方便于使用，只要在classpath设置jar路径即可。
3：数据库驱动，SSH框架等都是以jar包体现的。


Jar包的操作：通过jar.exe工具对jar的操作


创建jar包 格式：jar  -cvf  mypack.jar  packa packb


查看jar包 格式：jar  -tvf  mypack.jar   [>定向文件]


解压缩 格式：jar  -xvf  mypack.jar


自定义jar包的清单文件 格式： jar –cvfm  mypack.jar  mf.txt  packa packb

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com