面对对象5【内部类】【异常Exception】【throw和throws】【包package】【import】【jar包】

最新推荐文章于 2021-12-02 14:33:42 发布

it_shine

最新推荐文章于 2021-12-02 14:33:42 发布

阅读量1.3k

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/mayor125/article/details/39088375

版权

Java 专栏收录该内容

48 篇文章 0 订阅

订阅专栏

一、内部类

1、什么是内部类？

将一个类定义在另一个类的里面，对里面那个类就称为内部类(或者称为内置类、嵌套类)。

2、内部类的定义格式：

修饰符 class外部类名

{

//外部类成员

修饰符 class内部类名

{

//内部类成员

}

3、内部类的访问规则：

①、内部类可以直接访问外部类中的成员，包括私有的。

为什么内部类能直接访问外部类成员？

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

②、外部类要访问内部类，必须建立内部类对象。

代码示例：

class Outer  //外部类
{
       private int x = 3;  //外部类成员变量。
       class Inner    //内部类
       {
              int x = 4;  //内部类成员变量。
              void function()
              {
                     int x = 6;  //内部类局部变量。
                     System.out.println("inner："+x);   //x=6 方法内部有，就在方法内部找
                     System.out.println("inner："+this.x);   //x=4 访问内部类成员变量，用this
                     System.out.println("inner："+Outer.this.x);   //x=3 内部类访问外部类成员，前面默认省略了“外部类名.this.”
              }
       }
       void method()
       {
             Inner in = newInner();  //外部类访问内部类，需要建立内部类对象。
             in.function();
       }
}

4、访问格式和特点：

①、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其它类中直接建立内部类对象。

格式：

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

示例：Outer.Innerin = new Outer().new Inner();

②、当内部类在成员位置上时，就可以被成员修饰符所修饰。

比如private：将内部类在外部类中进行封装。

static：内部类就具备了static的特性。

5、静态内部类

当内部类被static修饰后，只能直接访问外部类中的静态成员，出现了访问局限性。

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

建立内部类的对象进行访问。

例如：new Outer.Inner().function();

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

直接用静态内部类的类名进行访问。

例如：Outer.Inner.function();

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

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

6、为什么要定义内部类？

类是用来描述现实生活中的事物的，当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事物在使用外部事物中的内容。

7、什么时候定义内部类？

当一个类想要直接访问另一个类的成员的时候，那么就将这个类写到另一个类的里面去，并封装起来不对外暴露，而只对外提供方法来访问这个内部类的事物。

8、匿名内部类：没有名字的内部类。

①、匿名内部类其实就是内部类的简写格式。

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

③、匿名内部类的格式：new父类或者接口(){定义子类的内容}

示例：

newAbsDemo()
 {
        void show()
        {
               System.out.println("show run");
        }
}

④、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

⑤、匿名内部类中定义的方法最好不要超过3个。因为阅读性比较差，并且调用起来很麻烦。

面试题：

没有继承一个类，也没有实现接口，如何通过匿名内部类来调用一个方法？通过代码的形式解答。

class InnerTest
{
       public static void main(String[] args)
       {
              newObject()  //Java中所有的类都有一个Object父类。建立一个Object类的子类的匿名内部类。
              {
                     public void function()
                     {
                            System.out.println(“functionrun”);
                     }
              }.function();
       }
}

二、异常

1、什么是异常？

就是程序在运行时出现的不正常情况。(是导致程序中断运行的一种指令流)

2、异常由来：问题也是现实生活中一个具体的事物，也可以通过Java的类的形式对问题进行描述，并封装成对象。

其实就是Java对不正常情况进行描述后的对象体现。

3、Java异常体系：

无论Error或者Exception都有一些共性内容。

Throwable

|--Error

|--Exception

|--RuntimeException

4、异常体系的特点：

异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字所操作。

只有异常体系具备这个特点。

5、Java对问题的划分：

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

严重：Java通过Error类进行描述。

对于Error一般不编写针对性的代码对其进行处理。（程序中无法处理）

非严重：Java通过Exception类进行描述。

对于Exception可以使用针对性的处理方式进行处理。（可以通过try...catch进行处理）

6、Java的异常处理语句格式：

try

{

需要被检测的代码;

}

catch(异常类异常对象)

{

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

}

finally

{

一定会执行的语句;

}

7、异常处理机制的好处：

①、易于使用、可自定义异常类、处理抛出的异常同时又不会降低程序运行的速度。

②、可以提高程序的稳定性和效率。

③、将问题进行封装。

④、将正常流程代码和问题处理代码相分离，方便于阅读。

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

String getMessage()：获取异常的信息。

String toString()：返回异常信息，格式是：异常名称：异常信息

void printStackTrace()：返回最完整的异常信息。包括异常名称、异常信息、异常出现的位置。

注：其实JVM默认的异常处理机制，就是在调用printStackTrace方法，打印异常的堆栈的跟踪信息。

9、Java异常处理机制的步骤：

第一步：一旦产生异常，则首先会产生一个异常类的实例化对象。

第二步：在try语句中对此异常对象进行捕捉。

第三步：产生的异常对象与catch语句中的异常类型进行匹配，如果匹配成功，则执行catch语句中的代码。

注：一般在开发中，不管出现任何异常，都可以用Exception异常类进行接收处理。

10、throws和throw关键字：

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

②、throws使用格式：public返回值类型方法名称(参数列表...) throws 异常类{}

代码示例：

class Demo
{
       int div(int a,int b) throws Exception   //在功能上通过throws的关键字声明了该功能有可能会出现问题。
       {
              return a/b;
       }
}

③、主方法做为程序的起点，也可以使用throws进行抛出异常，只不过是抛给JVM进行处理。

④、throw关键字：手动的抛出一个异常，抛出时直接抛出异常类的实例化对象即可。

⑤、throw使用格式：

throw new 异常类();

或

throw new 异常类(“异常信息”);

⑥、throw使用注意事项：

当在函数内部出现了throw抛出异常对象，那么就必须要给出对应的处理动作。

要么在内部try catch处理。
要么在函数上声明让调用者处理。（抛出异常）
当throw单独存在时，下面不要定义语句，因为执行不到。

注意：RuntimeException除外。也就是说，函数内如果抛出的是RuntimeException，函数上可以不用声明。

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

记住一点：catch是用于处理异常的。如果没有catch就代表异常没有被处理过，如果异常是检测时异常，那么就必须声明。

⑦、throws和throw的区别：

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

throw使用在函数内。后面跟的是异常对象。

11、（多）异常处理原则：

①、处理方式有两种：try或者throws。

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

③、对方声明几个异常，就对应有几个catch块，不要定义多余的catch块。

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

④、当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

代码示例：

class Demo
{
       int div(int a,int b) throws ArithmeticException,ArrayIndexOutOfBoundsException    //声明更为具体的异常，方便具体处理。
       {
              int[] arr = new int[a];
              System.out.println(arr[4]);
 
              return a/b;
       }
}
 
class ExceptionDemo2
{
       public static void main(String[] args)
       {
              Demo d = new Demo();
              try
              {
                     int x = d.div(4,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("角标越界！！！");
              }
              catch (Exception e)     //当异常出现继承关系，父类异常catch放在最下面。放最上面会编译会报错：错误: 已捕获到异常错误xxxException
              {
                     System.out.println("haha:"+e.toString());
              }
              System.out.println("over");
       }
}

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

12、异常处理语句：3种结合方式

①、try{ ... }catch (){ ... }

②、try{ ... }catch (){ ... }finally{ ... }

③、try{ ... }finally{ ... }

13、自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。

①、什么时候需要自定义异常？

在现实开发当中可能会出现特有的问题，而这些问题并未被Java所描述并封装对象。所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题，进行自定义的异常封装。

②、创建自定义异常的条件：必须要使自定义类继承Exception或者RuntimeException。

③、为什么自定义异常类要继承Exception？（异常体系的特点）

a、为了让自定义类具备可抛性。

b、让该类具备操作异常的共性方法。

④、怎样自定义异常信息？

当要自定义异常的信息时，可以使用父类已经定义好的功能。将异常信息传递给父类的构造函数。

自定义异常代码示例：

class FuShuException extends Exception  //自定义异常类。继承Exception类
{
       private int value;
       FuShuException(String msg,int value) //
       {
        /*
        如何定义异常信息呢？
        因为父类中已经把异常信息的操作都完成了。
        所以子类只要在构造时，将异常信息传递给父类，通过super语句。
        那么就可以直接通过getMessage方法获取自定义异常信息了。
        */
              super(msg);     //直接通过super语句将异常信息传递给父类。
              this.value = value;
       }
       public int getValue()     //定义返回异常数值的方法。
       {
              return value;
       }
}
 
class Demo
{
       int div(int a,int b) throws FuShuException
       {
              if(b<0)
                     throw newFuShuException("出现了除数是负数的情况----- / by Fushu",b);  //手动通过throw关键字抛出一个自定义异常对象以及自定义异常信息。
              return a/b;
       }
}
 
class ExceptionDemo3
{
       public static void main(String[] args)
       {
              Demo d = new Demo();
              try
              {
                     int x = d.div(4,-8);        
                     System.out.println("x="+x);                
              }
              catch (FuShuException e)   //捕获抛出的自定义异常
              {
                     System.out.println(e.toString());   //打印异常信息。
                     System.out.println("错误的负数是："+e.getValue());  //处理异常，并通过获取数值的方法输出错误的数值。
              }
              System.out.println("over");
       }
}

14、RuntimeException

①、运行时异常：Exception中的一个非常特殊的子类异常RuntimeException。

②、RuntimeException的特点：

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

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

③、为什么在函数上声明该异常编译可以通过？

是因为不需要让调用者处理。当异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。

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

④、异常的分类：

对于异常分两种：

a、编译时被检测的异常。

该异常在编译时，如果没有处理(既没有抛也没有try)，编译失败。

该异常被标识，代表这可以被处理。

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

在编译时，不需要处理，编译器不检查。

该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

15、finally代码块

finally代码块：无论程序是否产生异常，一定会执行到的代码。

注意：finally只有一种情况不会执行。当执行到System.exit(0);的时候，finally不会执行。

finally代码块的作用：通常用于关闭资源。因为资源用完必须被释放。

注意：finally代码块是可以省略的。如果省略了finally部分，则在catch处理部分运行结束后，程序会继续执行try catch之后的代码。

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

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

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

③、如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。

如果子类方法发生了异常，就必须要进行try处理，绝对不能抛。

代码示例：

class AExceptionextends Exception { }

class BExceptionextends AException { }

class CExceptionextends Exception { }

异常继承关系如下：

Exception

|--AException

|--BException

|--CException

class Fu
{
       void show() throws AException   //父类方法抛出了异常AException
       {}
}
 
class Test
{
       void function(Fu f)  //Fu f = new Zi();
       {
              try
              {
                     f.show();              
              }
              catch (AException e)
              {}
       }
}
 
class Zi extendsFu
{
       void show() throws BException  //子类覆盖的方法则只能抛出父类的异常，或者父类异常的子类。
       {}
}
 
class ExceptionDemo7
{
       public static void main(String[] args)
       {
              Test t = new Test();
              t.function(new Zi());
       }
}

三、包(package)

1、包的概念：实际上就是一个文件夹。

在Java中，在定义多个类或者接口的时候，为了避免名称重复而采用的一种措施。

2、实际作用：

对类文件进行分类管理。（可以将java的源文件和类文件相分离）

给类提供多层命名空间。

3、包的定义格式：

package 包名.子包名; //例如：packagepacka.packb.packc;

注意：

①、包的定义应该放在源文件程序代码的第一行。

②、包名中的所有字母都应该小写。（命名规范）

③、当在源文件中定义了包之后，则完整的类名应该是：包名.类名

④、当定义了包之后，在编译时，需要加上参数才可以编译成功

格式是：javac -d文件夹目录源文件名.java

示例：

javac -d . PackageDemo.java

-d：表示生成的目录，生成的目录以package的定义为准。

.：表示在当前目录所在的文件夹中生成。

4、包与包之间的访问：

①、包与包之间进行访问，被访问的包中的类以及类中的成员，需要被public修饰。

②、不同包中的子类还可以访问父类中被protected修饰的成员。

5、Java的访问权限

Java中一共存在4中访问控制权限：public、protected、default(默认)、private

public：属于公共访问权限。使用了此权限的类或者成员可以在所有类或者包中被访问。

protected：属于受保护的访问权限。使用了此权限的成员只能被本包或者不同包中的子类访问。

default：默认的访问权限。当没有使用任何其它的访问权限时，默认就是此权限。

private：属于私有访问权限。用于修饰类中的成员，只能在本类中进行访问。

6、包的权限

包与包之间可以使用的权限只有两种：public 、 protected

使用范围	public	protected	default	private
同一个类中	√	√	√	√
同一个包中	√	√	√
不同包中的子类	√	√
不同包中的类	√

7、import（导入）

①、import的作用：为了简化类名的书写，便于使用不同包中的类。

②、import的使用格式：

import 包名称.子包名称.类名称; //手动导入具体的类。

③、当导入的包中有多个类的时候，为了避免逐个的导入这些类，可以使用一个通配符*代替。

import 包名称.子包名称.*; //由JVM自动加载所需要的类。

注意：如果在程序中同时导入了两个包中的同名类，则在使用时必须明确的写出完整的“包名.类名”，否则编译就会报错。

建议：

①、开发中，建议尽量不要写通配符*，需要用到包中的哪个类，就导入哪个类。否则如果将不需要用的类也加载进内存的话，会比较消耗内存资源。

②、建立包名不要重复，可以使用URL来完成包名的定义，因为URL是唯一的。

例如：package cn.itcast.demo

package cn.itcast.test

8、jar命令：

①、功能：将文件或者文件夹打包成一个后缀名为.jar的压缩包。

②、jar.exe这个工具在JDK目录的bin目录下，在dos命令行下输入jar命令就可以看到该工具的用法和详细的参数信息。

Jar命令的常用参数：

-c 创建新的归档文件

-t 列出归档目录

-v 在标准输出中生成详细输出

-f 指定归档文件名

③、创建jar包的格式：

jar -参数目标文件源文件/文件夹1源文件/文件夹2 ...

示例1：创建一个jar包。

jar -cvf haha.jar packa packb JarDemo.javaDemo.class

最终生成一个名为haha.jar的压缩文件。类似Windows中的.rar或者.zip文件。

示例2：列出一个jar包里面的文件以及文件夹信息。

jar -tf haha.jar

④、怎么使用一个已有的jar包里面的文件？

只要通过设置classpath的方式在系统中注册好次jar文件所在路径就可以直接使用jar包里面的文件了。

示例：

set classpath=E:\java2014\day10\haha.jar （假如该jar包里面的pack目录下有一个JarDemo.class的文件）

运行：java pack.JarDemo

it_shine

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面对对象5【内部类】【异常Exception】【throw和throws】【包package】【import】【jar包】

一、内部类1、什么是内部类？将一个类定义在另一个类的里面，对里面那个类就称为内部类(或者称为内置类、嵌套类)。2、内部类的定义格式：修饰符 class外部类名{//外部类成员修饰符 class内部类名{//内部类成员}}3、内部类的访问规则：①、内部类可以直接访问外部类中的成员，包括私有的。为什么内部类能直接访问外部类成员？
复制链接

扫一扫