public class Tran { public double avg(int a, int b) throws MyException { if (a < 0 || a > 100 || b < 0 || b > 100) { throw new MyException("参数必须在0和100之间"); } return (a + b) / 2.0; } public static void main(String[] args) { Tran tran = new Tran(); try { double result = tran.avg(101, 50); System.out.println("平均数为：" + result); } catch (MyException e) { System.out.println(e.getMessage()); } }}class MyException extends Exception { public MyException(String message) { super(message); }}

这段代码定义了一个名为 Tran 的类，其中包含了一个名为 avg 的方法。该方法接受两个 int 类型的参数 a 和 b，并返回它们的平均数（以 double 类型返回）。如果参数不在 0 到 100 的范围内，则会抛出一个自定义异常类 MyException 的实例，并输出该异常的消息。

在 main 方法中，先创建了一个 Tran 类的实例 tran。然后尝试调用 avg 方法，并传入参数 101 和 50。由于 101 不在 0 到 100 的范围内，avg 方法会抛出一个 MyException 异常，并输出异常的消息。在 catch 语句块中，捕获该异常并输出其消息。

相关问题

class MyException extends Exception { public MyException(String errorMessage) { super(errorMessage); }}class Tran { public int avg(int a, int b) throws MyException { if (a < 0 || a > 100 || b < 0 || b > 100) { throw new MyException("输入参数必须为0-100之间的整数"); } return (a + b) / 2; }}public class Main { public static void main(String[] args) { Tran tran = new Tran(); try { int result = tran.avg(-1, 101); System.out.println(result); } catch (MyException e) { System.out.println("捕获到自定义异常：" + e.getMessage()); } }}

这段代码定义了一个自定义异常类 MyException，包含一个带有错误信息参数的构造函数。另外还定义了一个 Tran 类，其中的 avg 方法会抛出 MyException 异常，当输入参数不在 0-100 之间时会抛出该异常。最后在主方法中调用 avg 方法并对其进行异常处理，若捕获到 MyException 异常则输出错误信息。

运用编程计算A上的关系R={<a,b>,<b,a>,<b,c>,<c,d>}的自反闭包、对称闭包、传递闭包，其中A={a,b,c,d}.

首先，我们需要定义一个二维列表来表示关系R，其中列表的行表示元素对，列表的列表示元素。

R = [['a', 'b'], ['b', 'a'], ['b', 'c'], ['c', 'd']]

接下来，我们分别计算自反闭包、对称闭包和传递闭包。

1. 自反闭包

自反闭包是指将关系R中的每个元素都加上一个形如 <a,a> 的元素，使得关系R成为自反关系。

遍历A中的每个元素，若该元素在R中不存在，则将其与自身形成一个元素对，并加入到R中。

for a in A:
    if [a, a] not in R:
        R.append([a, a])

此时，R变成了以下形式：

R = [['a', 'b'], ['b', 'a'], ['b', 'c'], ['c', 'd'], ['a', 'a'], ['b', 'b'], ['c', 'c'], ['d', 'd']]

2. 对称闭包

对称闭包是指将关系R中所有的对称元素对都加上其反向对，使得关系R成为对称关系。

遍历关系R中的每个元素对，若其反向对不存在于R中，则将其反向对加入到R中。

for pair in R:
    if [pair[1], pair[0]] not in R:
        R.append([pair[1], pair[0]])

此时，R变成了以下形式：

R = [['a', 'b'], ['b', 'a'], ['b', 'c'], ['c', 'd'], ['a', 'a'], ['b', 'b'], ['c', 'c'], ['d', 'd'], ['b', 'a'], ['c', 'b'], ['d', 'c']]

3. 传递闭包

传递闭包是指将关系R中所有可传递的元素对都加入到R中，使得关系R成为传递关系。

首先，我们需要定义一个函数来判断两个元素对是否可传递。若存在一个中间元素，使得第一个元素与中间元素有关系，中间元素与第二个元素有关系，则两个元素对可传递。

def is_transitive(pair1, pair2):
    if pair1[1] == pair2[0]:
        return True
    return False

接下来，我们使用一个嵌套循环遍历所有元素对，对于每个元素对，再遍历一遍所有元素对，若两个元素对可传递，则将其加入到R中。

for pair1 in R:
    for pair2 in R:
        if is_transitive(pair1, pair2):
            if [pair1[0], pair2[1]] not in R:
                R.append([pair1[0], pair2[1]])

此时，R变成了以下形式：

R = [['a', 'b'], ['b', 'a'], ['b', 'c'], ['c', 'd'], ['a', 'a'], ['b', 'b'], ['c', 'c'], ['d', 'd'], ['b', 'a'], ['c', 'b'], ['d', 'c'], ['a', 'c'], ['a', 'd'], ['b', 'd']]

因此，关系R的自反闭包、对称闭包和传递闭包分别为：

$$R_{ref}=\{<a,a>,<b,b>,<c,c>,<d,d>,<a,b>,<b,a>,<b,c>,<c,d>\}$$

$$R_{sym}=\{<a,a>,<b,b>,<c,c>,<d,d>,<a,b>,<b,a>,<b,c>,<c,b>,<c,d>,<d,c>\}$$

$$R_{tran}=\{<a,a>,<b,b>,<c,c>,<d,d>,<a,b>,<b,a>,<b,c>,<c,d>,<a,c>,<a,d>,<b,d>\}$$