多态抽象接口

异常：

定义：程序在运行的过程中发生的错误，这些错误处理不当，就会终止程序运行	
解决异常问题的办法：
	1、判断
		处理的是已知的非常明确的异常位置
		Emg：
		System.out.println("sa");
		int secondnum=0;
		if(secondnum!=0){
			int num = 3 / secondnum;
			System.out.println(num);
		}else{
			System.out.println("出错拉!");
		}
		System.out.println("admin");
		
	2、异常处理
		处理未知可能会出错的异常位置
		
异常处理分类：
	Throwable（异常处理的父类）
		Error（致命性异常）
			特点：
				Error类通常是java运行内部问题如：资源耗尽，jvm错误
				该错误是无法捕获的，程序是不可恢复执行，致命性错误
		Exception（可捕获的异常）
			特点：
				可捕获可处理的异常，正确的处理之后程序将继续运行
			分类：
				编译时异常（非运行时异常）
					特点：该异常很好排错，一般属于语法错误或系统定义的错误
					包含：
						IOException  	文件读写异常
						SQLException	SQL异常
						ClassNotFoundException	类找不到的异常
						
				运行时异常（RuntimeException）
					特点：该异常语法是正确的，在运行时候才会出现，一般是逻辑问题（除数为0或死循环）
					包含：
						SystemException			
						NumberFormatException	数字格式化异常
						NullPointerException	空指针异常
						ArithmeticException		数学异常
异常处理关键字：
	try
		可能出错的代码块放在try块内
	catch
		捕获try块中匹配的异常，当catch捕获的异常和try块中出现的异常不匹配则无法捕获，程序结束
	finally
		必须会被执行的，一般用于释放资源（赋值为null）
	throw
		特点：
			一般是手动抛出异常，和if判断一起使用，通常情况下可以抛出自定义异常
			throw抛出异常最后必须有方法使用try-catch-finally去解决掉，如果不解决就会给jvm解决
		语法：
			if(){
				throw  new 异常类("错误信息")
			}else{
			
			}
			
	throws
		特点：
			方法后面抛出异常，谁调谁使用try-catch-finall解决，不解决可以继续throws止到最后交给jvm处理
		语法：
			访问修饰符  返回类型  方法名称(参数列表) throws 异常类{
			
			}
		

注意：
	try-catch-finally，try是必须的，catch和finally可以省略但不能同时省略
	可以多重catch，当try中出现异常，会在catch块中找第一个能匹配的异常进行处理，此时其他异常会被忽略
		Emg：
			try {
				int result = firstNum/secondNum;
				System.out.println("两个数字相除的结果是:"+result)	   
			}catch(ArithmeticException e) {
				System.out.println("算术异常:");
			}catch(NumberFormatException e) {
				System.out.println("数字转换异常");
			}catch(ArrayIndexOutOfBoundsException e){
				System.out.println("数组下标越界异常");
			}catch(Exception e) {
				System.out.println("其他异常");    
			}
	多重catch，捕获范围小的必须放在捕获范围大的上面，保证最后一个Exception
	如果try块中异常，没有对应的catch捕获，则程序结束

自定义异常
创建步骤：
1、写一个类
2、继承Exception
3、写一个带String类型的参数的构造函数，super(msg)调用父类的Exception的构造函数即可
4、在程序中需要出现自定义异常的地方通过判断然后throw出去就可以了

定义自定义异常类
	class MyException extends Exception{
		public MyException(String msg){
			super(msg);
		}
	}
使用自定义异常类
	public class Demo1 {
		public static void main(String[] args) {
			try {
				int age=10;
				if(age==10){
					throw new MyException("恭喜你");
				}
			} catch (Exception e) {
				System.out.println(e.getMessage());
			}
		}
	}			
注意：
	throw之后一定要使用throws继续抛出或直接使用try-catch-finally捕获
	一个方法被重写时，子类中重写父类的方法，则子类必须抛出父类相同的异常类或比父类抛出的异常更细致的异常子类
	如果父类方法抛出多个异常类，则重写方法必须抛出父类方法异常类的一个子集，即不能抛出新的异常 

=======================================================================

多态
多态表示多种形态,即多种实现方式
分类:
重载(overload)
特征:
1)一个类中
2)方法名相同,参数列表不同(参数的个数、类型、顺序一个不同则不同)
3)能否构成重载和返回类型以及修饰符无关

		调用重载方法的版本取决于参数列表	
		普通方法可以构成重载
		构造方法也可以构成重载
			
	重写(override)
		特征：
			1）两个类
			2）继承关系即：父子关系
			3）返回类型、方法名称、参数列表必须相同
			4）访问修饰符要么一致要么升级
		
		调用重写方法的版本取决于对象类型	

Emg：
class Person{
void eat(){}
}

class Stus extends Person{
	int eat(){}//错误
	int eat(int age){//和父类的eat()构成了重载
		return 0;
	}
}

抽象
抽象表示不够具体，既：属性和行为不具体
关键字：abstract
分类：
abstract修饰的类为抽象类,该类只能被继承
语法：
abstract class 类名{

		}
	abstract修饰的方法为抽象方法,该方法没有方法体，只能被重写
	语法：
		abstract 返回类型  方法名(参数列表);
作用：
	抽象类是一个模板，开发人员可以根据抽象类定义个格式修改和创建新的类
特点：
	1）抽象类主要用于被继承，有利于程序的扩展性
	2）抽象类中的抽象方法不能有方法体
	3）抽象类中可以有抽象方法和非抽象方法
	4）抽象类中可以构造方法、静态（static）方法、最终（final）方法、常量、变量，但构造方法静态方法最终方法不能被抽象修饰
	5）抽象类不能被实例化（new），但是可以采用父类引用指向子类对象创建
	6）抽象类中的抽象方法必须在子类中重写，否则该子类为抽象类
	7）有抽象方法的类一定为抽象类
	8）抽象方法不能是private修饰
Emg:
	abstract class Person{
		//变量
		public int age=10;
		
		//常量
		public static final String name="liusir";
		//最终方法,静态方法。不能被抽象
		public final static String getName(){
			return name;
		}
		//抽象方法，不能有方法体
		public abstract int getAge();
		//构造方法。不能被抽象
		public Person(){}
	}
3w1h
	what？
	where？
	when？
	how？

接口
接口是为了弥补继承的单一性（一个类只能有一个父类），即：使用接口可以实现多重继承
关键字：interface
定义：
接口就是对外的一些功能的声明

语法：
	interface 接口名{
		//常量
		static final String PI=3.14;
		
		//方法声明
		void 方法名(参数列表);
	}
	

注意：
	接口是一个特殊的抽象类
	接口能实现多重继承
	类和类之间是继承extends关系
	接口和接口之间也是继承extends关系
	类和接口之间是实现implements关系
	接口中可以定义常量和方法
	接口中变量默认为final、static、public修饰
	接口中方法默认为public、abstract修饰
	接口中方法不能有方法体