Java基础 内部类 异常try catch throw RuntimeException

最新推荐文章于 2023-07-19 15:24:08 发布
最新推荐文章于 2023-07-19 15:24:08 发布
阅读量979 收藏
点赞数
分类专栏： .net学习之C#基础提高
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cjh1005221032/article/details/46332829
版权

内部类

  • 将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。
  • 访问特点：
    • 内部类可以直接访问外部类中的成员，包括私有成员。
    • 而外部类要访问内部类中的成员必须要建立内部类的对象。

内部类访问规则

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

访问格式：

  1. 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
    • 格式
    • 外部类名.内部类名 变量名 = 外部类对象.内部类对象;
    • Outer.Inner in = new Outer().new Inner();
  2. 当内部类在成员位置上，就可以被成员修饰符所修饰
    • 比如，private:将内部类在外部类中进行封装。
    • static:内部类就具备static的特性
    • 当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。
    • 在外部其他类中，如何直接访问static内部类呢?
    • Outer.Inner.function();

注意：

  • 当内部类中定义了静态成员，该内部类必须是static的。
  • 当外部类中的静态方法访问内部类时，内部类也必须是static的。
package 内部类1;

class Outer
{
    private int x=10;

    class Inner//内部类
    {
        int x=1;//内外有同名变量时
        void function(){
            System.out.println("inner:"+Outer.this.x);
            //用"外部类名"调用外部类的成员变量供内部类使用
        }
    }
    /*
    class Inner
    {
        void function(){
            System.out.println("inner:"+x);//内部类可以直接使用外部类的成员变量
        }
    }
    */
    void method()
    {
        Inner in=new Inner();//外部类使用内部类,需要创建对象
        in.function();
    }
}



public class InnerClassDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Outer out=new Outer();
        out.method();
    }

}

输出:
inner:10

//直接访问内部类的成员。
        Outer.Inner in=new Outer().new Inner();
        in.function();
内部类可以使用 private 修饰

内部类定义在局部时

  1. 不可以被成员修饰符修饰
  2. 可以直接访问外部类中的成员，因为还持有外部类中的引用。
  3. 但是不可以访问它所在的局部中的变量。只能访问被 final 修饰的局部变量。
class Outer
{
    int x=3;

    void method()
    {
        final int y=4;
        class Inner
        {
            void function()
            {
                System.out.println(y);
            }
        }
        new Inner().function();
    }
}

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

匿名内部类

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

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

    abstract class AbsDemo
{
     abstract void show();
}

class Outer
{
     int x=3;

     public void function()
     {
         new AbsDemo()//匿名内部类
         {
             void show()
             {
                 System.out.println("x==="+Outer.this.x);
             }
         }.show();
     }
}
class Test
{
     public static void main(String [] args)
     {
         Outer ot=new Outer();
         ot.function();
     }
}
静态方法获取内部类
题目:
interface Inner
{
    public abstract void method();
}

class Outer
{
    //补充代码
    static  function()
    {

    }
}

class InnerDemo
{
    public static void main(String [] args)
    {
        Outer.function().method();
    }
}
实现
interface Inner
{
    public abstract void method();
}

class Outer
{

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

class InnerDemo
{
    public static void main(String [] args)
    {
        Outer.function().method();//调用类静态方法得到一个内部类引用,并使用他的方法method();
    }
}

异常

1.异常概述

异常：就是程序在运行时出现不正常情况
异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分：
  1. 严重的问题
  2. 非严重的问题

对于严重的，java通过Error类进行描述.
对于Error一般不编写针对性的代码对其进行处理。

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

2.异常的处理 try catch

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

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

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

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

public class ExceptionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        try
        {
            int x=d.div(4, 0);
            System.out.println("x=="+x);
        }
        catch(Exception e)
        {
            System.out.println("除零了");
            System.out.println(e.getMessage());//   /by zero;
            System.out.println(e.toString());// 异常名称：异常信息。

            e.printStackTrace();//异常名称，异常信息，异常出现的位置
                                //其实jvm默认的异常处理机制，就是在调用printStackTrace()方法，打印异常的堆栈的跟踪信息。
        }

        System.out.println("Over");
    }

}

输出:
除零了
/ by zero
java.lang.ArithmeticException: / by zero
java.lang.ArithmeticException: / by zeroOver

at 异常.异常概述.Demo.div(ExceptionDemo.java:7)
at 异常.异常概述.ExceptionDemo.main(ExceptionDemo.java:18)

3.异常声明throws

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

public class ExceptionDemo 
{
    public static void main(String[] args)throws Exception //main把Exception抛出给虚拟机处理
    {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        int x=d.div(4, 0);
        System.out.println("x="+x);
    }
}
也可以去掉main的throws 自己使用try catch处理异常
try
        {
            int x=d.div(4, 0);
            System.out.println("x=="+x);
        }
        catch(Exception e)//Exeption e = new ArithmeticException();
        {

            e.printStackTrace();//异常名称，异常信息，异常出现的位置
                                //其实jvm默认的异常处理机制，就是在调用printStackTrace()方法，打印异常的堆栈的跟踪信息。
        }

4.对多异常的处理

  1. 声明异常时，建议声明更为具体的异常，这样处理的可以更具体。
  2. 对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
  3. 如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
    建议在catch处理时，catch中一定要定义具体处理方式。
    不要简单定义一句 e.printStackTrace();
    也不要简单的就书写一条输出语句。
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) {
        // TODO Auto-generated method stub
        Demo d=new Demo();

        try
        {
            int x=d.div(4, 0);
            System.out.println("x=="+x);
        }
         //捕获指定异常
        catch(ArithmeticException e)//Exeption e = new ArithmeticException();
        {
            System.out.println(e.toString());
            System.out.println("被零除了");
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            System.out.println(e.toString());
            System.out.println("角标越界");
        }
        catch(Exception e)
        {
            System.out.println(e.toString());
        }

        System.out.println("Over");
    }

}

5.自定义异常

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

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

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

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

如何定义异常信息？

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

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

package 异常.自定义异常;

class FuShuException extends Exception
{
    private int value;
    FuShuException()
    {
        super();
    }
    FuShuException(String msg)
    {
        super(msg);
    }
    FuShuException(String msg,int value)
    {
        super(msg);
        this.value=value;
    }
    int getValue()
    {
        return this.value;
    }
}
class Demo
{

    int div(int a,int b)throws FuShuException
    {
        if(b<0)
            throw new FuShuException("出现负数.",b);
        return a/b;
    }
}


public class ExceptionDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        try
        {
            d.div(5, -2);
        }
        catch(FuShuException e)
        {
            System.out.println(e.toString());
            System.out.println("负数是:"+e.getValue());
        }
    }

}

输出:
异常.自定义异常.FuShuException: 出现负数.
负数是:-2

throws和throw的区别

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

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

RuntimeException

Exception中有一个特殊的子类异常RuntimeException运行时异常。
RuntimeException的子类使用throw在函数内抛出，不需要在函数上使用throws声明。编译一样通过。
并且在调用函数内不用try catch处理。编译一样通过。

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

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

对于异常分两种：
1. 编译时被检测的异常。
2. 编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

package 异常.RuntimeException;

class FuShuException extends RuntimeException
{
    FuShuException(String msg)
    {
        super(msg);
    }
}
class Demo
{
    int div(int a,int b)
    {
        if(b<0)
            throw new FuShuException("出现了除数为负数");
        if(b==0)
            throw new ArithmeticException("被零除了 /0");
        return a/b;
    }
}

public class ExceptionDemoR {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Demo d=new Demo();
        int x=d.div(4, -1);
        System.out.println("x="+x);
    }

}

Exception in thread “main” 异常.RuntimeException.FuShuException: 出现了除数为负数
at 异常.RuntimeException.Demo.div(ExceptionDemoR.java:15)
at 异常.RuntimeException.ExceptionDemoR.main(ExceptionDemoR.java:27)

MagicTurto-BD
关注
专栏目录
Java异常处理--异常处理的方式1：try-catch-finally
人生得意须尽欢
01-12 1437
Java异常处理--异常处理的方式1：try-catch-finally
try-catch中使用RuntimeException
choubo4852的博客
04-14 1637
/** *将JSON转为POJO */ publicstatic<T>TfromJson(Stringjson,Class<?>type){ Tpojo; try{ pojo=(T)OBJECT_MAPPER...
try catch
MakeToday的专栏
05-08 1266
TRY    trystatements CATCH ( ThrowableType1 exIdentifier1 )    catchstatements1 CATCH ( ThrowableType2 exIdentifier2 )    catchstatements2 ... CATCH ( ThrowableTypeN exIdentifierN )    catchstatements
Java：异常的处理（try catch，throw，throws，Exception，RuntimeException，自定义Exception）
qq_43220266的博客
12-01 1994
异常处理 //1. throw用于方法内部，主要表示手工异常抛出。 //2. throws主要在方法声明上使用，明确告诉用户本方法可能产生的异常，同时该方法可能不处理此异常。 public class Test { public static void code1(){ //System.out.println(&quot;1.数学计算开始前&quot;); //System....
throws和thrownew RuntimeException和try-catch的区别
疯狂大剑豪的专栏
09-28 1万+
1. throws出现在方法函数头，可以单独使用；而throw出现在函数体，不可以单独使用，throw要么和try-catch-finally语句配套使用，要么与throws配套使用。      2.throws主要是声明这个方法会抛出这种类型的异常，使其他地方调用它时知道要捕获这个异常。 throw是具体向外抛异常的动作，所以它是抛出一个异常实例。      3. throws表示出
Java throws 不写_java异常处理 throw RuntimeException时不需要同时方法中声明抛出throws 异常等待调用者catch进行捕获 子父类异常问题...
weixin_36214932的博客
02-24 531
packagecom.swift.exception1;public classDemo_Exception {public static voidmain(String[] args) {int[] arr=new int[] {2,5,3,5,4};try{array(arr);}catch(Exception e) {System.out.println("解决这个异常~~");e.prin...
【Java】异常 try-catch throw 详解
这很宇航的博客
06-05 2418
【Java】异常 try-catch throw 详解
Java中的异常处理详解(try、catch、finally、throw、throws)
Trouvailless的博客
06-14 3566
Java中的异常处理详解(try、catch、finally、throw、throws)
java基础第七章内部类与异常类.doc
09-30
Java 基础第七章内部类与异常类 Java 语言支持在一个类中定义另一个类，这样的类称做内部类。内部类和外嵌类之间存在着紧密的关系：内部类可以访问外嵌类的成员变量和方法，而外嵌类也可以使用内部类声明的对象作为...
Java异常处理之try...catch...finally详解
08-26
Java语言为异常处理提供了丰富的异常类，这些类之间有严格的继承关系。所有的类都是继承于Throwable这个父类，java将所有的非正常情况分为两种：Error（错误）和Exception（异常）。 Error错误一般是于虚拟机相关的...
2019年1月29日-Java类的成员内部类，异常处理try-catch-finally,throws,throw
zcguoji的博客
01-29 258
类的成员之五：内部类。 异常处理，如果是Exception,用try-catch-finally，如果是runtimeexception，用throws，自定义的异常对象用throw try-catch-finally是必须要处理的，throws是将异常上报给上一级，一直到java虚拟机，throw是手动抛出 无论怎样，finally都会执行 ...
java 函数 throw_java为什么有些异常throw出去需要在函数头用throws声明，一些就不用。...
weixin_42510317的博客
02-13 179
Excepiton分两类：checked exception、runtime exception；直接继承自Exception就是checked exception，继承自RuntimeException就是runtime的exception。你可以简单地理解checked exception就是要强制你去处理这个异常(不管你throws多少层，你终归要在某个地方catch它)；而runtime ...
【Java基础教程】（十九）异常捕获处理篇 · 上：异常的概念及处理流程解析，try、catch、finally、throws、throw的作用，RuntimeException类介绍~
最新发布
Technology changes the world of life
07-19 1912
异常的概念及处理流程解析，try、catch、finally、throws、throw的作用，RuntimeException类介绍~
Java_异常处理体系（try_catch_throw_throws_finally，超详细~）及return在其中的影响
God_Xzg的博客
11-18 480
java中的try catch throw throws finally return，真@一看就会~~~
Exception和RuntimeException，throws和throw分析
Love414Star的博客
09-08 1262
Exception——编译时期异常，必须要处理。 如果异常在方法上，throws了该类的异常，将来调用者必须处理； 如果异常出现在方法内部，throw了该类型异常，方法上也必须throws了该类型异常。 RuntimeException——运行时期异常，不需要处理，但是需要修改代码。 如果异常在方法上，则throws了该类型的异常，不需要处理； 如果异常出现在方法内部，则thro
java异常处理throw new RuntimeException(e)
热门推荐
mocas_wang的博客
05-12 3万+
1.java try catch 异常后还会继续执行吗？ catch 中如果你没有再抛出异常 , 那么catch之后的代码是可以继续执行的 , 但是try中 , 报错的那一行代码之后 一直到try结束为止的这一段代码 , 是不会再执行的。 //代码1 public static void test() throws Exception { throw new Exception("参数越界"); System.out.println("异常后"); //编译错误，「无法访问的语句
Exception 和 RuntimeException区别
Java的一只小实习生的博客
04-09 749
Exception 和 RuntimeException都是异常，他们有什么区别呢？ 概念 Exception ：受检查的异常，这种异常是强制我们catch或throw的异常。你遇到这种异常必须进行catch或throw，如果不处理，编译器会报错。比如：IOException。 RuntimeException：运行时异常，这种异常我们不需要处理，完全由虚拟机接管。比如我们常见的NullPointerException，我们在写程序时不会进行catch或throw。 RuntimeException也是继
java runtime 异常_Java中RuntimeException和Exception
weixin_39640024的博客
02-16 2400
在java的异常类体系中,Error和RuntimeException是非检查型异常，其他的都是检查型异常。所有方法都可以在不声明throws的情况下抛出RuntimeException及其子类不可以在不声明的情况下抛出非RuntimeException简单的说，非RuntimeException必要自己写catch块处理掉。RuntimeException不用try catch捕捉将会导致程序运...
Java异常处理详解：try, catch, throw, throws的使用
异常处理机制包括try、catch、throw、throws等关键字，它们各自有不同的作用和使用场景。在Java中，异常被分为两大类：RuntimeException（运行时异常）和CheckedException（检查异常）。运行时异常通常是程序员可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值