Java学习笔记（内部类、异常）

最新推荐文章于 2023-01-31 14:25:28 发布
最新推荐文章于 2023-01-31 14:25:28 发布
阅读量436 收藏
点赞数
分类专栏： Java基础学习 文章标签： java 异常 内部类 学习笔记 基础
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/g234872714f/article/details/50001889
版权

13 内部类

13.1内部类

定义：将一个类定义在另一个类中，内部的类称为内部类。

特点：

  • 内部类可以直接访问外部类中的成员，包括私有成员；
  • 外部类要访问内部类中的成员必须要建立内部类的对象；
  • 内部类定义在成员位置上，可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

例1：

/*
 * 内部类的访问规则：
 * 1、内部类可以直接访问外部类中的成员，包括私有。
 * 之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式：外部类名.this
 * 2、外部类要访问内部类，必须建立内部类对象。
 */
class Outer{
    private int x=3;

    class Inner{
        int x = 4;
        void function(){
            int x = 6;
            System.out.println("Inner:"+Outer.this.x);
        }
    }

    void method(){
        Inner in = new Inner();
        in.function();
    }
}

public class InnerClassDemo {

    public static void main(String[] args) {
        //直接访问内部类中的成员
        Outer.Inner in = new Outer().new Inner();
        in.function();
    }
}

输出结果：Inner:3

  • 当内部类被static修饰后，只能直接访问外部类中的static成员；

  • 在外部其他类中，如何直接访问static内部类的非静态成员？
    new Outer.Inner().function();

  • 在外部其他类中，如何直接访问static内部类的静态成员？
    Outer.Inner.function();
    ps:当内部类中定义了静态变量，该内部类必须是static的；
    当外部类中的静态方法访问内部类时，内部类也必须是static的。

例2

class Outer{
    private static int x=3;

    static class Inner{
        void show(){
            System.out.println("show:"+x);
        }
    }
}

public class InnerClassDemo {

    public static void main(String[] args) {
        //如果内部类是静态的，相当于一个外部类
        Outer.Inner in = new Outer.Inner();
        in.show();
    }
}

输出结果：show:3

内部类定义在局部时，不可以被成员修饰符修饰；
可以直接访问外部类中的成员，因为还持有外部类中的引用；

13.2 匿名内部类

匿名内部类：

  1. 匿名内部类是内部类的简写格式；
  2. 定义匿名内部类的前提：内部类必须是继承一个类或者实现接口；
  3. 匿名内部类的格式：new 父类或者接口（）（定义子类的内容）；
  4. 匿名内部类就是一个匿名子类对象。可理解为带内容的对象。

例1：

    abstract class Inner{
        abstract void show();
    }

    class Outer{
        int x=3;
         void method(){
            new Inner(){
                void show(){
                    System.out.println("show:"+x);
                }
            }.show();
        }
    }

    public class InnerClassDemo {

        public static void main(String[] args) {
            new Outer().method();
        }
    }

运行结果：show:3

例2：

    interface Inner{
        void show1();
        void show2();
    }

    class Outer{
        public void method(){
            Inner in = new Inner(){
                 public void show1(){
                    System.out.println("show1:");
                }
                public void show2(){
                    System.out.println("show2:");
                }
            };
            in.show1();
            in.show2();
        }
    }

    public class InnerClassDemo {

        public static void main(String[] args) {
            new Outer().method();
        }
    }

运行结果：show1:
show2:

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

例3

interface Inner{
    void method();
}

class Outer{
    static Inner function(){
        return new Inner(){
             public void method(){
                    System.out.println("show1:");
            }
        };
    }
}

public class InnerClassDemo {

    public static void main(String[] args) {
        //Outer.function():Outer类中有一个静态的方法function。
        //.method():function方法运算后的结果为一个对象，而且是一个Inner类型对象
        //因为只有是Inner类型的对象，才可以调用method方法。
        Outer.function().method();
        //相当于下方语句
        //Inner in=Outer.function();
        //in.method();
    }
}

14 异常

异常：程序运行时出现的不正常情况；

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

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

异常划分：
Throwable
|-Error
|-Exception
|-RuntimeException

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

14.1 异常的处理

java提供了特有的语句进行处理

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

处理过程：

  1. try中检测异常会将异常对象传递给catch,catch捕获到异常进行处理；
  2. finally内通常用来关闭资源。例如：数据库资源，IO资源等；
  3. finally代码块只有一种情况不会被执行，就是之前执行System.exit(0)。

例1

class Demo{
    int div(int a,int b){
        return a/b;
    }
}

public class ExceptionDemo {

    public static void main(String[] args)  {
            Demo d = new Demo();
            try{
                int x = d.div(2, 0);
                System.out.println("x="+x);//Exception e = new ArithmeticException();
            }catch(Exception e){
                System.out.println("分母不能为0");
                System.out.println(e.getMessage());// /by zero
                System.out.println(e.toString());//异常名称：异常信息
                e.printStackTrace();//异常名称，异常信息，异常出现的位置
                //其实jvm默认的异常处理机制，就是在调用printStackTrace
                //打印异常的堆栈跟踪信息
            }
            System.out.println("Over!");
    }
}

运行结果：

针对例1中一般类Demo的编写者会通过throws Exception抛出可能出现的异常，在使用这个类时就不会出现使用者无法判断该类是否可能出现异常的情况，如例2。

例2

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

public class ExceptionDemo {
    public static void main(String[] args){
            Demo d = new Demo();
            int x;
            try {
                x = d.div(2, 0);
                System.out.println("x="+x);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Over!");
    }
}

运行结果：

14.2对多异常的处理：

  1. 声明异常时，建议声明更为具体的异常，这样的处理更为具体；
  2. 对方声明几个异常，就对应几个catch块；不要定义多余catch块，如果多个catch块中的异常出现继承关系，父类异常catch块放在最下方；
  3. 进行catch处理时，catch中一定要定义具体处理方式，不能简单的e.printStackTrace();也不要简单一条书写语句，项目开发一般会生成错误日志保存在硬盘中，后续进行处理。

例3：

class Demo{
    int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException{
        int[] arr = new int[a];
        System.out.println(arr[4]);

        return a/b;
    }
}

public class ExceptionDemo {

    public static void main(String[] args){
            Demo d = new Demo();
            int x;
            try {
                x = d.div(3,0);
                System.out.println("x="+x);
            } catch(ArithmeticException e1) {
                System.out.println(e1.toString());
                System.out.println("分母不能为0");
            }catch(ArrayIndexOutOfBoundsException e){
                System.out.println(e.toString());
                System.out.println("角标越界了");
            }
            System.out.println("Over!");
    }   
}

运行结果：

14.3 自定义异常

在项目中，会出现特定的问题，而这些问题并未被java所描述并封装对象；对于这些特有的问题，进行自定义异常封装。

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

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

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

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

例4：

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("appear",b);
        return a/b;
    }
}

public class ExceptionDemo {

    public static void main(String[] args){
            Demo d = new Demo();
            int x;
            try {
                x = d.div(3,-1);
                System.out.println("x="+x);
            } catch(FuShuException e) {
                System.out.println(e.toString());
                System.out.println("除数不能为负数:"+e.getValue());
            }
            System.out.println("Over!");
    }
}

运行结果：

throw和throws的区别：

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

异常的注意事项：

  1. RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。
  2. 子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
  3. 如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
    简单说：子类覆盖父类只能抛出父类的异常或者子类的子集。

如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。

对于异常分两种：

  1. 编译时被检测的异常（非RuntimeException以及其子类），必须在类名后加throws的标识；
  2. 编译时不被检测的异常（运行时异常，RuntimeException以及其子类）

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

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

例5：

class NoValueException extends RuntimeException{
    NoValueException(String msg){
        super(msg);
    }
}

interface Shape{
    void getArea();
}

class Rec implements Shape{
    private int len,wid;

    Rec(int len,int wid) {//throws NoValueException
        if(len<=0||wid<=0)
                throw new NoValueException("出现非法值");
        this.len=len;
        this.wid=wid;
    }   
    public void getArea(){
        System.out.println(len*wid);
    }
}

class Circle implements Shape{
    private int radius;
    public static final double PI = 3.14; 

    Circle(int radius){
        if(radius<=0)
            throw new NoValueException("非法");
        this.radius = radius;
    }
    public void getArea(){
        System.out.println(radius*radius*PI);
    }
}

public class ExceptionDemo {
    public static void main(String[] args){

        //try {
        Rec r = new Rec(1,2);
            r.getArea();
            Circle c = new Circle(-8);
/*      } catch (NoValueException e) {
            System.out.println(e.toString());
        }*/
        System.out.println("Over!");
    }
}

运行结果：

14.4 总结

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

异常划分：

    Throwable
        |-Error
        |-Exception
            |-RuntimeException

throw和throws的区别：

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

当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，都在编译失败；
注意：RuntimeException除外，即如果函数内抛出RuntimeException异常，函数上可以不用声明。

如果函数声明了异常，调用者需要进行处理，处理方法可以throws可以try。

异常有两种：

  • 编译时被检测异常

该异常在编译时，如果没有处理（没有抛也没有try），编译失败。该异常被标识，代表可以被处理。

  • 运行时异常（编译时不被检测）

在编译时，不需要被处理，编译器不检查。该异常发生，建议不处理，让程序停止，需要对代码进行修正。

异常处理语句：

try{
需要被检测代码；
}catch(){
处理异常的代码；
}
finally{
一定会执行的代码；
}

三种格式：

1

    try{
        需要被检测代码；
    }catch(){
        处理异常的代码；
    }

2

    try{
        需要被检测代码；
    }catch(){
        处理异常的代码；
    }
    finally{
        一定会执行的代码；
    }

3

    try{
        需要被检测代码；
    }
    finally{
        一定会执行的代码；
    }

ps：

  1. finally中定义通常为关闭资源代码，因为资源必须释放。
  2. finally代码块只有一种情况不会被执行，就是之前执行System.exit(0)。

自定义异常：
定义类继承Exception或者RuntimeException

　1.　为了让该自定义类具备可抛性；
　2.　让该类具备操作异常的共性方法。

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

    class MyException extends Exception{
        MyException(String msg){
            super(msg);
        }
    }

异常好处：

  1. 将问题进行封装；
  2. 将正常流程代码和问题处理代码相分离，方便阅读。

异常处理原则：

  1. 处理方式有两种：try或者throws；
  2. 调用到抛出异常的功能时，抛出几个，处理几个；即出现一个try对应多个catch；
  3. 多个catch，父类的catch放在最末端；
  4. catch内需要定义针对性的处理方式，不要简单定printStackTrace，输出语句，也不要不写；

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

    try{
    throw new AException();
    }catch(AException e){
        throw e;
    }

如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转化后，再抛出和该功能相关的异常；
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，当调用者知道，并处理，也可以将捕获异常处理后，转换新的异常。

    try{
        throw new AException();
        }catch(AException e){
            //对AException处理
            throw new BException();
        }
壶里先森
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java内部学习笔记.docx
02-18
5.1 Java异常处理机制 49 5.2 File文件类 51 5.3 RandomAccessFile类 53 5.4基本流：FIS和FOS 55 5.5缓冲字节高级流：BIS和BOS 56 5.6基本数据类型高级流：DIS和DOS 56 5.7字符高级流：ISR和OSW 57 5.8缓冲字符高级...
内部类与异常类：实验1
weixin_30521649的博客
11-26 571
class DangerException extends Exception{ String s; DangerException(String s){ this.s=s; } public void warnMess() { System.out.println(s); } } class MobileShop{ int phones; ...
java 实验 类 内部类_实验六 内部类与异常类.doc
weixin_33971453的博客
02-26 2202
实验六 内部类与异常类实验六 内部类和异常类实验目的1、掌握内部类的常用方法2、掌握匿名类的常用方法3、掌握接异常类的常用方法实验内容1、根据附录里的源代码，按照注释要求，完成代码填空，使程序能够运行得出结果。1)实验1 红牛农场2)实验2 检查危险品3)实验3 内部类的使用方法4)实验4 匿名类的使用方法5)实验5 异常类使用方法2、完成习题：1)编写一个异常类MyException，在编写一个...
Java内部类与异常类（上机实践二）
Chlin.Rei的博客
04-25 6080
Java内部类与异常类（上机实践二） 实践一 内部购物卷 手机专卖店为了促销自己的产品，决定发行内部购物券，但其他商场不能发行该购物券。编写一个 MobileShop 类（模拟手机专卖店），该类中有一个名字为 InnerPurchaseMoney 的内部类（模拟内部购物券）。 class MobileShop { InnerPurchaseMoney purchaseMoney1;//【代码1】//用内部类InnerPurchaseMoney声明对象purchaseMoney1 InnerPur
Java实验之接口与实现、内部类与异常类
猫猫头的博客
01-02 5203
Java实验之接口与实现、内部类与异常类 Java实验之接口与实现 评价成绩 体操比赛计算选手成绩的办法是去掉一个最高分和最低分后再计算平均分,而学校考 察一个班级的某科 目的考试情况时,是计算全班同学的平均成绩。Gymastics类 和 school类都实现了ComputcrAverage接 口,但实现的方式不同。 运行结果： package com.company; interface CompurerAverage { public double average(double x[]); }
Java学习笔记
PaulHoldOn的博客
01-31 1490
Java
观看韩顺平学习整理java的笔记到异常
03-30
帮助大家复习java基础知识其中有 hashCode 2 toString 2 finalize 2 用已学知识做出简单的房屋出租系统 3 类方法使用注意事项和细节讨论 4 main()方法 4 代码块 4 代码块使用注意事项和细节 5 单例模式 6 final...
Java学习笔记(必看经典).doc
06-27
里面包含基础知识，如修饰符，常用的关键字等，内部类，面向对象思想，异常处理相关知识点，常用集合知识点等等。
Java面试笔记.zip
最新发布
01-03
学习笔记和心得：记录了学习过程中的重点难点和心得体会，有助于学习者更好地理解和掌握知识。 二、适用人群 本资源适用于即将毕业或已经毕业，希望通过学习Java找到一份理想工作的同学。无论你是初学者还是有一定...
java学习笔记 初学者必读
05-08
7.11.1. 内部类的分类 7-29 7.11.2. 成员内部类 7-29 7.11.3. 局部内部类 7-30 7.11.4. 静态内部类 7-30 7.11.5. 匿名内部类 7-31 7.12. 集合 7-31 7.12.1. 集合接口类层次 7-32 7.12.2. 集合类层次 7-33 7.12.3. 五...
Java学习笔记（反射+枚举类）
g234872714f的博客
03-15 3423
19 反射 19.1 类的加载概述和加载时机 19.1.1 类的加载概述 当程序要使用某个类时，如果该类还未加载到内存中，则系统会通过加载、连接、初始化三步来实现对这个类进行初始化。 加载： 指将class文件读入内存中，并为之创建一个Class对象，任何类被使用时系统都会建立一个Class对象。 连接： 验证：是否有正确的内部结构，并和其他类协调一致 准备：负责为类的静态成
Java学习笔记（注释、对象初始化过程、单例模式）
g234872714f的博客
11-15 1247
面向对象9.帮助文档的制作9.1注释- 原则： 1、注释形式统一 在整个应用程序中，使用具有一致的标点和结构的样式来构造注释。如果在其它项目中发现它们的注释规范与这份文档不同，按照这份规范写代码，不要试图在既成的规范系统中引入新的规范。 2、注释内容准确简洁 内容要简单、明了、含义准确，防止注释的多义性，错误的注释不但无益反而有害。 - 注释格式：　1. 单行(si
Java学习笔记（网络编程）
g234872714f的博客
03-27 962
21 网络编程21.1 网络参考模型 找到对方IP； 数据要发送到对方指定的应用程序上，为标识这些应用程序，故应用数字进行标识，称为端口，逻辑端口； 定义通信规则，称为协议，国际组织定义了通用协议TCP/IP。 OSI（Open System Interconnection 开放系统互连）参考模型TCP/IP 参考模型七层描述 物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输
Java学习笔记（面向对象1）
g234872714f的博客
11-14 442
面向对象1.何为面向对象 面相对象是相对面向过程而言的 面相对象和面向过程都是一种思想 面向过程 强调功能行为 面向对象 将功能封装进对象，强调具备了功能的对象。 面向对象是基于面向过程的。 2.类与对象 类就是对现实生活中事物的描述； 对象则是这类事物，实实在在存在的个体； 描述类时，有属性（成员变量）和行为（成员方法）； 成员变量与局部变量 成员变量作用于整个类中； 局部变量作用于函数中或
Java学习笔记（IO_1）
g234872714f的博客
12-16 393
17 IO关于IO流，可参见: Java IO流学习总结17.1 IO流IO流用来处理设备之间的数据传输。Java对数据的操作是通过流的方式。 流按操作数据分为两种：字节流和字符流； 按流向分为：输入流，输出流。 字节流读取文字字节数据后，不直接操作而是先查指定的编码表，获取对应的文字。再对这个文字进行操作。简单说：字节流+编码表。17.1.1 IO流常用基类字节流的抽象基类：InputStream
Java学习笔记（继承、接口）
g234872714f的博客
11-16 389
1.继承作用： 提高代码的复用性； 让类与类之间产生关系，有了这个关系，才有多态的特性。 注意： 不要为了获取其他类功能，简化代码而继承；必须是类与类之间所属关系才可以继承 Java中只支持单继承；因为多继承容易带来安全隐患（当多个父类中定义了相同功能，功能内容不同时，子类对象不确定要运行哪个）。 Java支持多层继承。 1.1 变量如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用t
Java学习笔记（GUI）
g234872714f的博客
12-21 363
18 GUI18.1 事件监听机制特点： 事件源：awt包或者swing包中的图形界面组件； 事件：每一个事件源都有自己特有的对应事件的共性事件； 监听器:将可以触发某一个事件的动作（不止一个）都已经封装到了监听器中； Ps：以上三点都已在java中定义好 事件处理： 例1：import java.awt.*; import java.awt.event.*;public class AwtDem
Java学习笔记（字符串）
g234872714f的博客
12-01 341
16 集合16.1 字符串16.1.1 StringString s = “abc”;//s是一个类型变量，”abc”是一个对象；**String类的特点： 字符串对象一旦被初始化就不会被改变**。 例1：public class StringDemo { public static void main(String[] args) { String s1 = "abc"
java 学习笔记 xmind
01-02
Java 学习笔记 XMind 是一款专门用于整理和管理 Java 学习内容的思维导图软件。通过 XMind，我们可以将 Java 相关的知识点、重点、代码案例、类库等内容进行整理和分类，方便我们进行学习和复习。 首先，我用 XMind...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值