GVKun编程网logo

Delphi异常处理try except语句和try finally语句用法以及区别〖原创+转载〗

16

对于想了解Delphi异常处理tryexcept语句和tryfinally语句用法以及区别〖原创+转载〗的读者，本文将是一篇不可错过的文章，并且为您提供关于1.编写一个类ExceptionTest，在

对于想了解Delphi异常处理try except语句和try finally语句用法以及区别〖原创+转载〗的读者，本文将是一篇不可错过的文章，并且为您提供关于1. 编写一个类ExceptionTest，在main方法中使用try-catch-finally语句结构实现：、7,模块-异常处理,try.except.else.finally.raise.断言、C#异常处理中try和catch语句及finally语句的用法示例、C++ try-catch-finally 语句：掌握异常处理流的控制的有价值信息。

本文目录一览：

Delphi异常处理try except语句和try finally语句用法以及区别〖原创+转载〗

Delphi异常处理try except语句和try finally语句用法以及区别〖原创+转载〗

总结

以上是小编为你收集整理的Delphi异常处理try except语句和try finally语句用法以及区别〖原创+转载〗全部内容。

如果觉得小编网站内容还不错，欢迎将小编网站推荐给好友。

1. 编写一个类ExceptionTest，在main方法中使用try-catch-finally语句结构实现：

1. 编写一个类ExceptionTest，在main方法中使用try-catch-finally语句结构实现：

package bbb;

import java.util.Scanner;

public class aaa {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入除数:");
        int op1 = input.nextInt();
        System.out.println("请输入被除数：");
        int op2 = input.nextInt();
        int result = 0;
        try {
            result = op1 / op2;
        } catch (ArithmeticException e) {
            e.printStackTrace();
        } finally {
            System.out.println("异常处理");
        }
        System.out.println(result);
    }
}

 

7,模块-异常处理,try.except.else.finally.raise.断言

7,模块-异常处理,try.except.else.finally.raise.断言

异常处理.

 

part1:程序中难免出现错误,错误分成两种:1,语法错误;2,逻辑错误

 

语法错误示例:

if

def test:
    pass


print(hah

 

逻辑错误示例:

#用户输入的不完整(比如输入为空)或者输入非法(输入不是数字)
num=input(">>:")
int(num)

 

什么是异常:

异常就是程序运行时发生错误的信号,

在python中,不同的异常可以用不同的类型去标识(python中统一了类与类型,类型即类),不同的类对象标识不同的异常,一个异常标识一个错误.

错误举例

触发:IndexError
lst=[''aa'',''bb'']
print(lst[3])#输出:list index out of range

KeyError
dic={''name'':''hh''}
print(dic[''age'']) #输出:''age''

ValueError
s=''hello''
int(s) #输出:invalid literal for int() with base 10: ''hello''

 

常用异常

AttributeError:试图访问一个对象没有的属性,比如food.x,但是foo没有属性x

IOError:输入/输出异常,基本上是无法打开文件

ImportError:无法引入模块或包,基本上是路径问题或名称错误.

IndentationError:语法错误(的子类),代码没有正确对齐.

 IndexError:下标索引超出序列边界,比如当list只有三个元素,却试图访问list[5]

KeyError:试图访问字典里不存在的键

KeyboardInterrput:Ctrl+C被按下

NameError:使用一个还未被赋予对象的变量

SyntaxError:语法错误

TypeError:传入对象类型与要求的不符合

UnboundLocalError:试图访问一个还未被设置的全局变量,基本上是由于另有一个同名的全局变量,导致你以为正在访问它.

ValueError:传入一个调用者不期望的值,即使值的类型是正确的.

 

 

更多异常:

ArithmeticError
AssertionError
AttributeError
BaseException
BufferError
BytesWarning
DeprecationWarning
EnvironmentError
EOFError
Exception
FloatingPointError
FutureWarning
GeneratorExit
ImportError
ImportWarning
IndentationError
IndexError
IOError
KeyboardInterrupt
KeyError
LookupError
MemoryError
NameError
NotImplementedError
OSError
OverflowError
PendingDeprecationWarning
ReferenceError
RuntimeError
RuntimeWarning
StandardError
StopIteration
SyntaxError
SyntaxWarning
SystemError
SystemExit
TabError
TypeError
UnboundLocalError
UnicodeDecodeError
UnicodeEncodeError
UnicodeError
UnicodeTranslateError
UnicodeWarning
UserWarning
ValueError
Warning
ZeroDivisionError

 

 

异常处理:

异常发生之后,异常之后的代码就不执行了,

python解释器检测到错误,触发异常(也允许程序员自己触发异常),程序员编写特点的代码,专门用来捕捉这个异常(这段代码与逻辑无关,与异常处理有关)

如果捕捉成功则进入另外一个处理分支,执行你为其定制的逻辑,使程序不会崩溃,这就是异常处理,

 

为什么要进行异常处理:

python解释器去执行程序,检测到一个错误时,触发异常,异常触发后且没被处理的情况下,程序就在当前异常处终止,后面的代码不会运行,谁会去用一个运行着突然就崩溃的软件,

所以,必须提供一种异常处理机制来增强所编写的程序的健壮性与容错性.

 

如何进行异常处理:

异常是由程序的错误引起的,语法上的错误跟异常处理无关,必须在程序运行前就修正

使用if判断式

content=input(">>>")
if content.isalpha():
    print("输入的是字母")
elif content.isdigit():
    print("输入的是数字")
else:
    print("输入的是其他字符")

总结:

1,if判断式的异常处理只能针对某一段代码,对于不同的代码段的相同类型的错误,需要写重复的if来

进行处理.

2,在程序中频繁的写与本程序无关,与异常处理有关的if,会使得代码的可读性极差

3,if是可以解决异常的,

 

python的异常处理,try-except的使用:

 

try:
    ''''''被检测的代码''''''
except 异常检测:
    try中一旦检测到异常,就执行这个位置的逻辑.

 

读文件的例子

try:
    f=open(''tb.txt'',encoding=''utf-8'')
    g=(line.strip() for line in f)
    print(type(g))
    print(next(g))
    print(next(g))
    print(next(g))
    print(next(g))
except StopIteration:
    f.close()

next(g)会触发迭代f,依次next(g)就可以读取文件的一行行内容,无论文件
有多大,同一时刻内存中只有一行内容
g是基于文件句柄f而存在的,因而只能在next(g)抛出异常StopIteration后才可以执行f.close()

 

异常类只能用来处理指定的异常情况

单支,遇到报错信息,防止程序终止,执行另一个语句.

try:
    num=int(input(''>>>''))
    name

except EOFError:
    print("出现了NameError错误")
#当随笔输入一个整数时,后面输出:出现了NameError错误
#出现报错,然后就跳到except处执行预计,前提是except后跟
#的报错类型是对的,否则程序依然报错

 

多分支

try:
    num=int(input(''>>''))#ValueError
    name                # NameError
    dic = {}
    dic[''key'']          # KeyError
except ValueError:
    print("出现了ValueError错误")
except NameError:
    print("出现了NameError错误")
except KeyError:
    print("出现了KeyError错误")
print(11)
print(22)
print(33)
#当输入1a,会报出现了value错误,下面的代码直接跳到print("出现了ValueError错误")
# 然后接着执行3个print,当
#3个except也可以换位置,出现错误之后去捕捉,

 

万能的异常处理

try:
    print(11)
    num=int(input(''>>''))
    print(22)
    name
    lst=[1,23]
    lst[5]
except Exception: #此处Exception可以不写,最好写上
    print("出错了")
# 代码只要有错误的,可以是程序不报错,最后导向到except


try:
    print(11)
    num=int(input(''>>''))
    print(22)
    name
    lst=[1,23]
    lst[5]
except Exception as e: #可以将报错信息显示出来,
    print(e)

#  e 其实是Exception这个类实例化的对象,所有的错误继承exception.
# print(e)打印这个对象,输出了一段字符串,实际上是触发了__str__方法

# 异常处理的两种结局方式:
# 1,只是显示错误信息,不终止程序就行,               用万能的
# 2,针对不同的错误,提示不同的信息,进行不同的操作,  用多分支的

 

实例分析:

def login():
    pass

def register():
    pass

def dariy():
    pass
dic={
    1:login,
    2:register,
    3:dariy
}

# while True:  #第一种判断形式
#     choice=input("请输入:")
#     if  choice.isdigit():
#         if 1<=int(choice)<=4:
#             dic[int(choice)]()
#         else:
#             print("请输入范围内的数")
#     else:
#         print("请输入数字")

while True:  #第二种形式,比第一种代码要简约的多,
    choice=input("请输入: ")
    try:
        dic[int(choice)]()
    except ValueError:
        print("请输入数字")
    except KeyError:
        print("请输入范围内数字")

 

多分支+万能

 

def login():
    pass

def register():
    pass

def dariy():
    pass
dic={
    1:login,
    2:register,
    3:dariy
}


choice=input("请输入: ")
    try:
        dic[int(choice)]()
    except ValueError:
        print("请输入数字")
    except KeyError:
        print("请输入范围内数字")

    except Exception as e:
        print(e)           #万能的是用来保底的,以防出现位置的错误
# as e 要是出现在Value或者key错误之前,那后面的代码将不会执行,即不会再被导流到另外的except

 

try except except...else  模式

#固定搭配必须是
# try:
#     pass
# except : #或者except Exception,至少有一个except
#     pass
# else:
#     pass


try:
    num=int(input(">>"))
except ValueError:
    print("出错了")
except Exception as e:
    print(e)
else:
    print(''输出这里,'')
#当except没有捕获到异常时,才会走else,

 

try except else finally

try finally

这两种方法的用法

#固定搭配,
# try except else  finally
# try finally
try:
    num=int(input(">>"))
except ValueError:
    print("出错了")
except Exception as e:
    print(e)
else:
    print(''执行else这里,'')
finally:
    print("执行finally这里")



try:
    name
finally:
    print("即使报错也要执行finally")
#先执行的finally,后报的错

 

 

 finally的具体用处:用在关闭文件句柄,关闭数据库的链接,关闭网络链接等等.

# 用在文件操作中,假如try里面的代码有报错,\
# finally执行之后,还是可以把文件句柄关掉
try:
    f=open(''a.txt'',encoding=''utf-8'')
    print(f.read())
    f.write()
finally:
    f.close()




def func():
    try:
        print("遇到return要结束函数的执行")
        return 666
        print("执行输出")
    finally:
        print("虽然遇到return,但是还是要执行finally")
print(func())
# 输出:
# 遇到return要结束函数的执行
# 虽然遇到return,但是还是要执行finally
# 666
# "执行输出没有打印"

 

主动触发异常

class A:
    def pay(self):
        raise TypeError("你的子类中应该有一个pay方法")

class QQ(A):
    def pay(self):
        print("执行")
class Wexin(A):
    def paym(self):
        print("执行")
q1=QQ()
w1=Wexin()
w1.pay()
# 输出:TypeError: 你的子类中应该有一个pay方法

 

自定义异常

 

# 自定义异常,
# (大项目,针对python不具备的一些错误类型)
#在代码中出现错误,但是python源码没有收录这个错误,
# 这时就需要开发人员手动定义一个错误类,保证程序可以运行
raised TypeError("类型错误")

class ''未知错误''(BaseException):
    def __init__(self,msg):
        self.msg=msg
    def __str__(self):
        return self.msg

# # raise EvaException(''EvaException:错误!!!!'' )
# # raise TypeError(''EvaException:错误!!!!'' )
try:
    raise ''未知错误''(''EvaException:错误!!!!'' )
except "未知错误" as e:  # e = EvaException(''类型错误'')
    print(e)

 

 

断言,主动抛出异常,

断言 源码处常有,主动抛出异常
assert 1==2  #如果条件不满足,强行终止.
print(111)
print(222)
print(333)

 

 

异常处理的正确使用:

只有在有些异常无法与之的情况下,才应该加上try..except,其他的逻辑错误应该尽量修正.

C#异常处理中try和catch语句及finally语句的用法示例

C#异常处理中try和catch语句及finally语句的用法示例

使用 try/catch 处理异常
try-catch 块的用途是捕捉和处理工作代码所生成的异常。 有些异常可以在 catch 块中处理，解决问题后不会再次引发异常；但更多情况下，您唯一能做的是确保引发适当的异常。
示例
在此示例中，IndexOutOfRangeException 不是最适当的异常：对本方法而言 ArgumentOutOfRangeException 更恰当些，因为错误是由调用方传入的 index 参数导致的。

class TestTryCatch
{
  static int GetInt(int[] array,int index)
  {
    try
    {
      return array[index];
    }
    catch (system.indexOutOfRangeException e) // CS0168
    {
      System.Console.WriteLine(e.Message);
      // Set IndexOutOfRangeException to the new exception's InnerException.
      throw new System.ArgumentOutOfRangeException("index parameter is out of range.",e);
    }
  }
}


注释
导致异常的代码被括在 try 块中。 在其后面紧接着添加一个 catch 语句，以便在 IndexOutOfRangeException 发生时对其进行处理。 catch 块处理 IndexOutOfRangeException，并引发更适当的 ArgumentOutOfRangeException 异常。 为给调用方提供尽可能多的信息，应考虑将原始异常指定为新异常的 InnerException。 因为 InnerException 属性是只读，所以必须在新异常的构造函数中为其赋值。


使用 finally 执行清理代码
finally 语句的目的是确保即使在引发异常的情况下也能立即进行必要的对象（通常是保存外部资源的对象）清理。此类清理功能的一个示例是在使用后立即对 FileStream 调用 Close，而不是等待公共语言运行时对该对象进行垃圾回收，如下所示：

static void CodeWithoutCleanup()
{
  System.IO.FileStream file = null;
  System.IO.FileInfo fileInfo = new System.IO.FileInfo("C:\\file.txt");

  file = fileInfo.OpenWrite();
  file.WriteByte(0xF);

  file.Close();
}

为了将上面的代码转换为 try-catch-finally 语句，需要将清理代码与工作代码分开，如下所示。

static void CodeWithCleanup()
{
  System.IO.FileStream file = null;
  System.IO.FileInfo fileInfo = null;

  try
  {
    fileInfo = new System.IO.FileInfo("C:\\file.txt");

    file = fileInfo.OpenWrite();
    file.WriteByte(0xF);
  }
  catch(System.UnauthorizedAccessException e)
  {
    System.Console.WriteLine(e.Message);
  }
  finally
  {
    if (file != null)
    {
      file.Close();
    }
  }
}

因为在 OpenWrite() 调用前，try 块内随时都有可能发生异常，OpenWrite() 调用本身也有可能失败，所以我们无法保证该文件在我们尝试关闭它时处于打开状态。 finally 块添加了一项检查，以确保在调用 Close 方法前，FileStream 对象不为 null。如果没有 null 检查，finally 块可能引发自身的 NullReferenceException，但是应当尽可能避免在 finally 块中引发异常。
在 finally 块中关闭数据库连接是另一个不错的选择。因为有时候数据库服务器允许的连接数是有限的，所以应尽快关闭数据库连接。在由于引发了异常而无法关闭连接的情况下，使用 finally 块也是比等待垃圾回收更好的一种选择。

C++ try-catch-finally 语句：掌握异常处理流的控制

C++ try-catch-finally 语句：掌握异常处理流的控制

异常处理：语法： try { 可能引发异常的代码 } catch (特定异常类型) { 处理异常 } finally { 在任何情况下都会执行的代码 }实战： 使用 try-catch 语句捕获和处理函数中的 std::runtime_error 异常，并在 finally 块中执行清理任务。最佳实践： 使用特定类型 catch 块捕获特定异常，使用 finally 块释放资源和执行清理，并遵循异常安全原则。

C++ try-catch-finally 语句：掌握异常处理流的控制

使用 C++ try-catch-finally 语句进行异常处理

异常处理对于编写健壮且可恢复的代码至关重要。C++ 中的 try-catch-finally 语句提供了控制异常流程的一种有效方式。

语法

立即学习“C++免费学习笔记（深入）”；

try {
  // 可能引发异常的代码
}
catch (exception_type1 &e1) {
  // 捕获类型 exception_type1 的异常
}
catch (...) {
  // 捕获所有其他异常
}
finally {
  // 在任何情况下都会执行的代码，无论是否引发异常
}
登录后复制

实战案例

考虑以下函数，它可能会引发 std::runtime_error：

int divide_by_zero(int numerator, int denominator) {
  if (denominator == 0) {
    throw std::runtime_error("Cannot divide by zero");
  }
  return numerator / denominator;
}
登录后复制

我们可以在 main() 函数中使用 try-catch 语句来处理此异常：

int main() {
  int numerator = 10;
  int denominator = 0;

  try {
    int result = divide_by_zero(numerator, denominator);
    std::cout << "Result: " << result << std::endl;
  } catch (std::runtime_error &e) {
    // 捕获对除以 0 的异常
    std::cout << "Error: " << e.what() << std::endl;
  } catch (...) {
    // 捕获所有其他异常
    std::cout << "Unknown error occurred" << std::endl;
  }

  // finally 代码块将在任何情况下执行
  std::cout << "Program terminating" << std::endl;

  return 0;
}
登录后复制

finally 代码块

finally 代码块始终在 try 块之后执行，无论是否引发异常。它通常用于释放资源、关闭文件或执行其他清理任务：

finally {
  // 释放分配的内存
  delete ptr;
  // 关闭文件
  file.close();
}
登录后复制

最佳实践

  • 使用特定类型的 catch 块以捕获特定异常。
  • 使用 finally 块来释放资源和执行清理任务。
  • 在 catch 块中处理异常后，可以通过 throw 或 rethrow 将其重新抛出。
  • 遵循异常安全原则，确保在异常发生时对象处于有效状态。

以上就是C++ try-catch-finally 语句：掌握异常处理流的控制的详细内容，更多请关注php中文网其它相关文章！

关于Delphi异常处理try except语句和try finally语句用法以及区别〖原创+转载〗的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于1. 编写一个类ExceptionTest，在main方法中使用try-catch-finally语句结构实现：、7,模块-异常处理,try.except.else.finally.raise.断言、C#异常处理中try和catch语句及finally语句的用法示例、C++ try-catch-finally 语句：掌握异常处理流的控制等相关知识的信息别忘了在本站进行查找喔。

本文标签：

上一篇Delphi 比较第三方正则组件 PerlRegEx 和 官方的 RegularExpressions 速度测试

下一篇DELPHI7执行dos命令并等待完成再执行面的语句（delphi 等待指定时间）

相关文章