面向对象总结3

内部类：

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

当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中，直接建立内部类对象，格式：

             外部类名.内部类名 变量名=外部类对象.内部类对象

              Outer.Inner  in=new Outer（）.new Inner（）；

当内部类在成员位置上，就可以被成员修饰符所修饰，如private（将内部类在外部类中进行封装）static（只能访问外部类中的static成员，出现了访问局限）

在外部其他类中，访问static内部类的非静态成员：new  Outer.Inner（）.function（）；

在外部其他类中，直接访问static内部类的静态成员：Outer.Inner.function（）；

注意：当内部类中定义了静态成员，内部类必须是静态的；

             当外部类中的静态方法访问内部类时，内部类也必须是static的。

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

匿名内部类：就是内部类的简写格式

       前提：必须继承一个类或者实现接口。

匿名内部类的格式：new父类或者接口（）{定义子类的内容}

其实匿名内部类就是一个匿名子类对象，而且这个对象有点胖，或者理解为有内容的对象。

匿名内部类中定义的方法最好不要超过3个；

异常：就是程序在运行时出现不正常情况是对问题的描述，将问题进行对象的封装。

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

对于问题的划分：对于严重的，java通过Error类进行描述，一般不编写针对性的代码对其进行处理；对于非严重的，java通过Exception类进行描述，可以使用针对性的处理方式进行处理。

异常处理语句：

try

{

       需要被检测的代码；

}

catch（异常类 变量）

{

       处理异常的代码（处理方式）；

}

finally

{

       一定会执行的代码；

}

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

对多异常的处理：

1、  声明异常时，建议声明更为具体的异常，这样处理可以更具体

2、  对方声明几个异常，就对应有几个catch块，不要定义多余的catch块，如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

throws和throw的区别：

throws使用在函数上，后面跟的异常类，可以跟多个，用逗号隔开；throw使用在函数内，后面跟的是异常对象。

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

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

异常的练习：

/*

毕老师用电脑上课。

开始思考上课中出现的问题。

比如问题是

       电脑蓝屏。

       电脑冒烟。

 

要对问题进行描述，封装成对象。

可是当冒烟发生后，出现讲课进度无法继续。

出现了讲师的问题：课时计划无法完成。

*/

class Teacher

{

       private String name;

       private Computer cmpt;

       Teacher(String name)

       {

              this.name=name;

              cmpt=new Computer();

       }

       public void prelect()throws NoplanException

      

       {

              try

              {

                            cmpt.run();

              }

              catch(LanPingException e)

              {

                     cmpt.reset();

              }

              catch(MaoYanException e)

              {

                     test();

                     throw new NoplanException("课时无法继续"+e.getMessage());

                    

              }

      

              System.out.println("老师讲课");

       }

       public void test()

       {

              System.out.println("做练习");

       }

}

class LanPingException extends Exception

{

       LanPingException(String message)

       {

              super(message);

       }

      

}

class MaoYanException extends Exception

{

       MaoYanException(String message)

       {

                     super(message);

       }

 

}

class NoplanException extends Exception

{

       NoplanException(String message)

       {

              super(message);

       }

}

class Computer

{

       private int state=3;//通过状态值判定电脑的情况

       public void run()throws LanPingException,MaoYanException

       {

              if(state==2)

                     throw new LanPingException("蓝屏了");

              if(state==3)

                     throw new MaoYanException("冒烟了");

              System.out.println("电脑运行");

       }

       public void reset()

       {

              state=1;

              System.out.println("电脑重启");

       }

}

class ExceptionTest

{

       public static void main(String[] args)

       {

              Teacher t=new Teacher("毕老师");

              try

              {

                     t.prelect();

              }

              catch(NoplanException e)

              {

                     System.out.println(e.toString());

                     System.out.println("换老师或者放假");

              }

       }

}

当state=3时，运行结果

第10天：面向对象

finally中存放的是一定会执行的代码，通常用于关闭资源。

异常在子父类覆盖中的体现：

1、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。

2、如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。

3、如果父类或者接口在方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常；如果子类方法发生了异常，就必须进行try处理，绝对不能抛。

 

异常的好处：

1、  将问题进行封装

2、  将正常流程代码和问题代码相分离，方便与阅读。

包（package）：对类文件进行分类管理，给类提供多层命名空间，写在程序文件的第一行，类名的    全称是 包名.类名，包也是一种封装形式。

包与包之间的访问：被访问的包中的类以及类中的成员，需要public修饰；不同包中的子类可以直接访问父类中被protected权限修饰的成员；包与包之间可以使用的权限只有两种：public和protected

import导入的是包中的类，建议：不要使用通配符“*”，需要用到包中的哪个类，就导入包中的哪个类。

建议定义包名不要重复，可以使用url来完成定义，url是唯一的。

jar包：java的压缩包

1、  方便项目的携带

2、  方便于使用，，只要在classpath设置jar路径即可

3、  数据库驱动，ssh框架等都是以jar包体现的。