前言
 
本地开发的时候运行正常，开启了混淆之后编译通过运行失败
 
描述
 
项目中遇到了一个问题，module中有一个方法，改方法会抛Exception，
 
    public Map<String, String> encryptParams(Map<String, String> params) throws Exception {
        return params;
    }
 
在主工程中有一个改类的子类复写类该方法，做了一些其他的逻辑，开发的时候为类方便把混淆关了直接关联工程开发。调试完毕之后开了混淆准备打包然后就build 失败。
 
 
根据提示判断是因为父类中的encryptParams（）方法未抛Exception，所以子类也不能抛。看代码确定是有throw Exception的，于是Module打出来的jar反编译下看看到底有没有。
 
JD-GUI可以很方便的反编译jar包。使用AndroidStudio更方便直接把jar拖到libs下面，然后sync。
 
 
可以看到混淆后的代码
 
 
来一张对比的
 
 
对比发现混淆后的jar是没有throw Exception的，这里的gradle版本是1.5.0，仔细观察发现map的泛型也没有。
 
再来一张gradle 2.3.3 版本的(因为我Studio版本是2.3.3的)，有泛型没有throw Exception
 
 
最后放上三个对比的
 
//    混淆后 gradle 1.5.0
//    public Map encryptParams(Map var1) {
//        return var1;
//    }

//    混淆后 gradle 2.3.3
//    public Map<String, String> encryptParams(Map<String, String> var1) {
//        return var1;
//    }

    //混淆前
    public Map<String, String> encryptParams(Map<String, String> params) throws Exception {
        return params;
    }
 
Demo地址
 
结论
 
gradle 1.5.0版本 在开启混淆生成jar的时候会把泛型和throw Exception去掉，gradle 2.3.3版本开启有泛型无throw Exception。原因暂未查到，有清楚的欢迎讨论。
 
补充
 
后期发现泛型是因为没有在混淆配置中添加忽略，添加以下内容就可以保留混淆。
 
# 避免混淆泛型
-keepattributes Signature
 
最终解决方案
 
今天突然想起来，EventBus在注册了两次之后会抛异常，就去看下EventBus怎么处理的。直接看代码
 
    // Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
       ...
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }
        ...
 
抛了异常但方法上没有throws ，跟进去EventBusException
 
public class EventBusException extends RuntimeException { ... }
 
原来如此。 
 方法来了，只需要把我们之前的Exception 换成 RuntimeException或者自定义一个他的子类就可以解决库中抛的异常不会打进jar中的问题了，然后在需要的地方处理catch到的异常。 
 Exception：在程序中必须使用try…catch进行处理。 
 RuntimeException：可以不使用try…catch进行处理，但是如果有异常产生，则异常将由JVM进行处理。 
 所以，为了保证程序再出错后依然可以执行，在开发代码时最好使用try…catch的异常处理机制进行处理。

 
 
  
package com.exception.demo;

public class Captor {

	/**
	 * @param args
	 * Exception是所有异常类的父类
	 * 如果将它的代码块方其他两个代码块前面，后面的代码块将永远得不到执行
	 * 所以 catch 语句的顺序不可调换
	 * 
	 * 异常的使用原则：
	 *    1.在当前方法中使用 try - catch 语句捕获异常
	 *    2.一个方法被覆盖时，覆盖它的方法必须抛出相同的异常或异常的子类
	 *    3.如果父类抛出多个异常，则覆盖方法必须抛出那些异常的一个子集，不能抛出新异常 
	 */
	static int quotient(int x,int y)throws MyException{	// 定义方法抛出异常
		if(y < 0){	// 判断参数是否小于0
			throw new MyException("除数不能是负数");	// 异常信息
		}
		return x / y;	//  返回值
	}
	
	
	public static void main(String[] args) {	// 主方法
		try {	// try语句包含可能发生异常的语句
			int result = quotient(3, -1);	// 调用语句方法 quotient()
		} catch (MyException e) {	// 处理自定义异常
			System.out.println(e.getMessage());	//输出异常信息
		}catch (ArrayStoreException e) {	// 处理 ArrayStoreException 异常
			System.out.println("除数不能为0");	// 输出异常信息
		}catch (Exception e) {	// 处理其它异常
			System.out.println("程序发生了其他异常");	//输出提示信息
		}
	}

}

class MyException extends Exception {	// 创建自定义异常类
	String message;	// 定义 String 类型变量
	
	public  MyException(String ErrorMessager){	// 父类方法
		message = ErrorMessager;
	}
	
	public String getMessage(){	// 覆盖 getMessage() 方法
		return message;
	}

}
 
 
 
 
　　
 
转载于:https://www.cnblogs.com/spadd/p/4174605.html

Python 抛出异常
 
抛出异常相当于是停止运行这个函数中的代码，将程序执行转到 except 语句。
 
如果没有 try 和 except 语句覆盖抛出异常的 raise 语句，该程序就会崩溃，并显示异常的出错信息。通常是调用该函数的代码知道如何处理异常，而不是该函数本身。所以你常常会看到 raise 语句在一个函数中， try 和 except 语句在调用该函数的代码中。
 
使用 try 和 except 语句，你可以更优雅地处理错误，而不是让整个程序崩溃。
 
#!/usr/bin/env python3
# -*- coding:utf-8 -*-

def boxPrint(symbol, width, height):
    if len(symbol) != 1:
        raise Exception("Symbol must be a single character string.")
    if width <= 2:
        raise Exception("Width must be greater than 2.")
    if height <= 2:
        raise Exception("Height must be greater than 2.")

    print(symbol * width)
    for i in range(height - 2):
        print(symbol + (' ' * (width - 2)) + symbol)
    print(symbol * width)


for sym, w, h in (('*', 4, 4), ('O', 20, 5), ('x', 1, 3), ('ZZ', 3, 3)):
    try:
        boxPrint(sym, w, h)
    except Exception as err:
        print('An exception happened: ' + str(err))
 
 
 
/usr/bin/python3.5 /home/strong/workspace/master.py
****
*  *
*  *
****
OOOOOOOOOOOOOOOOOOOO
O                  O
O                  O
O                  O
OOOOOOOOOOOOOOOOOOOO
An exception happened: Width must be greater than 2.
An exception happened: Symbol must be a single character string.

Process finished with exit code 0
 
 

这是一篇有关JAVA：内层方法抛出异常，外层方法捕捉并处理异常的文章信息。
 我发布到报名在线EDU84.COM上，和大家分享一下JAVA：内层方法抛出异常，外层方法捕捉并处理异常
 public void methodA (){ 
 try{ 
 // 调用methodB 
 methodB(); 
 } 
 catch(ExceptionType et){ 
 // 相应处理措施 
 } 
 } 
 public void methodB throws ExceptionType{ 
 if (condition is true) 
 { 
 // 相应处理措施 
 } 
 else 
 { 
 throw new ExceptionType(argument); 
 } 
 } 
 在这个例子中，方法B的头部中声明了该方法会抛出一个类型为ExceptionType的异常，在方法体中使用throw子句抛出了一个异常，那么该异常被谁捕捉到呢，答案是方法A。因为异常抛出后，JVM会顺着该方法的调用栈一层一层的往上找。因为方法A中有一个catch(ExceptionType et),所以被抛出的异常会被捕捉到并处理。