面向对象内部类与异常

 

//内部类（内置类/嵌套类）  就是类里面的类。

内部类的访问规则：

1、内部类可以直接访问外部类中的成员，包括私有。外部类要访问内部类，必须要建立内部类对象。

 

调用非静态方法必须要现有对象。

 

外部类直接访问内部类中的成员：因为有可能有别的同类名。所以必须要有限制修饰。

         格式：outer.inner in=new outer（）.new inner（）；

 

在类中，方法访问变量的顺序是，先局部变量，再成员变量。

 

内部类的方法中如何访问外部类中的变量，在前面加修饰 outer。this。x

直接加this。x就只能访问到内部类的成员变量。

 

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，

格式：“外部类名。this”。其实如果内部没有重新定义，就可以直接访问外部的是因为前面省略了“outer.”。

访问格式：当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部类对象。

格式：外部类名.内部类名变量名=外部类对象，内部类对象；

outer.inner in=new outer（）.new inner（）；

当内部类在成员位置上，就可以被成员修饰符所修饰，比如私有，private，将内部类在外部类中进行封装。static，内部类就具备了static的特性。

当内部类被静态修饰后，只能直接访问外部类中的静态成员了。出现了访问局限。静态内部类。不出现特有数据，全都是公有数据。

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

可以通过new outer. inner。function（）；

在外部其他类中，如何直接访问静态内部类的静态成员呢？outer. inner。function（）；

 

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

 

不作重点掌握。

 

静态方法访问静态成员是一定可以的。

 

静态成员是比非静态成员先加载的。

 

 

//内部类的定义原则：

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

属性  行动 功能等。

属性和行为一多了就要进行对象封装。找到了这个对象就可以找到功能和属性了。

 

当一类事物直接访问外部事物的内容时，直接把这个类定义在外部类中，这样的代码设计是最优的。当一个类需要访问另一个类中的成员中，直接写到那个类中，再对这个内部类进行封装，对外提供方法既可以。

 

//匿名内部类

 

只有当内部类处于成员位置才能被静态和私有修饰，一般是不会被公有修饰的。

内部类可以定义在任意位置上，成员或者局部。但是访问规则没有变。但是不能被静态所修饰了。静态只能修饰成员的。局部的内部类里面也不能定义静态成员。

 

非静态，没有对象，就不会执行。

先加载类，才能加载对象，因为对象是依赖类而建立的。

 

内部类定义在局部时：

1、不可以被成员修饰符修饰；可以直接访问外部类中的成员，因为还持有外部类当中的引用，但是不可以访问他所在的局部中的变量，只能访问被final修饰的局部变量。

 

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

往往简写都是有前提，有其好处和弊端的。

2、定义匿名内部类的前提，内部类必须继承一个类或者实现接口。

 

一个内部类可以直接继承一个外部其他类。

对象带着对象体，也是一个对象。

 

3、匿名内部类的格式：new 父类或者接口（）｛定义子类的内容｝。

4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。匿名对象对方法只能调用一次。

 

写匿名对象就是为了简化书写，覆盖方法。

 

匿名内部类有好处有弊端，

无法转换类型，无法调用自己的方法，无法进行强转动作，如果父类的方法非常多，不允许使用匿名内部类，因为阅读性非常多。

一般写匿名内部类里面的方法不会超过三个。两个或者一个这样调用方法比较方便。

5、匿名内部类中定义的方法最好不要超过3个。太多阅读性非常差。一般不在内部类写太复杂，因为他是为了简化而存在，太复杂了匿名内部类就没有意义了。

 

小练习：test.function().method();

 

什么时候用到匿名内部类呢？

 

当使用的方法参数类型是一个接口类型时，而且该接口内的方法不超过3个，我们可以定义一个匿名内部类来进行操作。

 

这个里面又是多态的继承问题，搞不清楚。

 

 

//异常机制

 

程序出现了不正常现象时，程序就会停止运行并结束，不再执行下面的运算。

 

异常就是程序在运行时出现了不正常的情况，

 

异常的由来：

我们写程序是为了描述现实生活的事物，肯定是包含一些问题，问题也是现实生活中的事物，也可以通过java的类的形式进行描述，并封装成对象，java就把对与问题的描述封装成的对象成为不正常情况，就叫异常。其实就是java对不正常情况进行描述后的对象体现。

 

有描述，就可以封装成对象。

 

一个问题的产生既会有问题的原因，还会有现象以及一些其他信息，这个问题里面有很多的内容，封装成对象后，就可以通过对象内部定义的功能进行操作，这就是对象封装，把问题封装成对象就叫做异常。

 

万物皆对象，异常就是用面向对象的思想把问题进行描述并进行对象的封装而来的。。

 

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

对与严重的问题，java通过Error进行描述。对于Error一般我们不编写针对性的代码对其进行处理。

对于非严重的问题，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。

 

内存溢出，超出虚拟机制定内存的范围。

 

无论Error或者Exception都具有一些共性的内容，比如，不正常的情况的信息，引发原因。

可以向上抽取，抽取完之后就可以形成一个基本的体系，抽取出来的父类就叫做throwable。下面就有上面两类子类。

 

使用体系时要看父类定义，建立子类对象。

 

java在为了让代码具有阅读性，就用父类作为子类取名的后缀，这样就更容易阅读，我们在编程中，也可以这么来体现。

 

java内部有默认的异常处理机制。如果没有被处理，jvm就启动默认处理机制，这种机制会让程序停止执行。等等。

 

2、//异常的处理：

java提供了特有的语句进行处理：格式是固定的（一共是三部分。）

try

｛

         需要被检测的代码；（用来检测容易出错的代码块）（检测的功能）

｝

catch（异常类 变量）

｛

         处理异常的代码;(处理方式)

｝

finally

（

         一定会执行的语句；

4000
）

由三部分代码快组成。

 

3、对捕获到的异常对象进行常见方法操作，

String get message（）获取异常的信息。

tostring 表示异常名称，异常信息。

printstacktrace 异常名称，异常信息，异常出现的位置。

 

其实jvm默认的异常处理机制就是在调用printstacktrace方法打印异常在堆栈中的跟踪信息。

 

4、在函数后面用throws 关键字后面输入Exception，表示在功能上通过throws的关键字声明了该功能有可能会出现问题。——这是一种声明。

 

其实我们一般不往外抛，是有情况的。

 

碰到可能有问题的方法是，就要预先给出问题的处理方式。

 

 

//对多异常的处理：

定义功能的时候，有可能会发生不只一个问题，那么我们要在函数上要声明的问题就不止一个问题了。

 

一般声明的特点就是你声明的越具体，我就处理的越具体，我们一般不会采用这种用exception来做声明的对象的。你声明了多个具体，我就处理多个具体。

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

 

 

1、声明异常时，建议声明更为具体的异常，这样处理的可以更具体。你抛个父类，我不知道发生什么事情，只知发生事情了，不能采取针对性的处理方式。

 函数当中，只要有异常发生，这个函数就停止结束了，不再进行下面的运算了。

 catch里面要有与之匹

配的处理。

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

建议在进行catch处理时，catch中一定要定义具体的处理方式。不要简单的定义一句

e.printstacktrace(),也不要简单的就书写一条输出语句。

异常日志文件。

 

//自定义异常

         对本项目当中的特有问题也进行对象封装。

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

 

需求：在本程序中，对于除数为负数，也视为是错误的，是无法进行运算的。那么就需要对这个问题进行自定义的描述。

 

当在函数内部出现了throw抛出异常对象，那么就必须给出对应的处理动作，要么在内部进行try catch处理，要么在函数上声明让调用者处理。

一般情况下，函数内出现异常，函数上需要声明。

 

发现打印的结果中只有异常的名称，却没有异常的信息，因为自定义的异常并未定义信息。

 

如何定义异常信息呢？

因为父类中已经把异常信息的操作已经都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句，那么就可以直接通过getmessage方法获取自定义的异常信息了

 

自定义异常：

必须是自定义类继承exception。

因为异常体系有一个特点，即异常类和异常对象都可以被抛出。他们都具备可抛性，这个可抛性是throwable这个体系中的独有特点。只有这个体系中的类和对象才可以被throws和throw操作。

 

throw与throws的区别

throws使用在函数上，throw使用在函数内，

throws后面的跟的异常类，可以跟多个，用逗号隔开。throw后跟的是异常对象。

 

 

//RuntimeException

Exception中有一个特殊的子类异常RuntimeException运行时异常。

如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过；

 

之所以不用在函数声明，是因为不需要让调用者处理。

当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

 

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

 

对于异常通常分两种：

1、  编译时被检测的异常，

2、编译时不被检测的异常，（运行时异常，RuntimeException以及其子类）