Java day9 内部类，异常 2019.7.18

• 内部类
• 匿名内部类
• 匿名内部类2
• 匿名内部类测试
• 异常处理
• 异常处理2
• 多异常处理
• 自定义异常
• RuntimeException

内部类

/*
1.内部类可以直接访问外部类中的成员，包括私有
2.外部类要访问内部类，必须先建立内部对象

访问格式：
1.当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中
可以直接建立内部类对象
格式
	外部类名.内部类名 变量名=外部类对象.内部类对象；
	Outer.Inner in=new Outer().new Inner();

2.当内部类在成员位置上，就可以被成员修饰符所修饰
  比如：private：将内部类在外部类中进行封装。
        static：内部类就具备了静态类的特性
		当内部类被static修饰后就只能访问外部类中的静态成员，出现了访问限制


	在外部或其他类中，如何直接访问static内部类的非静态成员呢？
	new Outer.Inner().function();

	在外部或其他类中，如何直接访问static内部类的静态成员呢？
	Outer.Inner().function();

	注意：当内部类中定义了静态成员，该内部类必须是static的
*/

class Outer
{
	private int num=3;
	private class Inner//只有内部类才可以加上private
	{
		//int num=5;
		void function()
		{
			//int num=6;
			System.out.println("inner:"+num);//num前省略了outer.this
		}//输出顺序653
	}

	void method()
	{
		//Inner in=new Inner();
		//in.function();

		Outer.Inner in=new Outer().new Inner();
		in.function();
	}
}

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

匿名内部类

/*
内部类定义在局部时，
1.不可以被成员修饰符修饰
2.可以直接访问外部类中的成员，因为还持有外部类钟中的引用
  但是不可以访问他所在的局部中的变量。只能访问被final修饰的局部变量

*/


class Outer
{
	int x=3;
	void method(final int a)//连参数也要被final修饰,但是jdk8以后会自动帮你加上，所以可以不写
	{
		final int y=4;//必须要加上final 但是jdk8以后会自动帮你加
		class Inner//不可以被修饰符修饰,局部类
		{
			void function()
			{
				System.out.println(y);
			}
		}
		new Inner().function();
	}
}

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

匿名内部类2

/*
匿名内部类：
1.匿名内部类其实就是内部类的简写格式。
2.定义匿名内部类的前提：
内部类必须是一个继承类或者实现接口

3.匿名内部类的格式：new 父类或者接口（）{定义子类内容}
4.其实匿名内部类就是一个匿名内部子类对象
5.匿名内部类中定义的方法最好不要超过三个
*/
abstract class Demo
{
	abstract void show();
}

class Outer
{
	int x=3;

	/*class Inner extends Demo 
	{
		void show()
		{
			System.out.println("method："+x);
		}
	}*/


	public void function()
	{
		//new Inner().show();

		new Demo()//这是一个Demo建立的对象，这是注释掉的内容的简化写法
		{//匿名内部类
			void show()
			{
				System.out.println("method："+x);
			}
		}.show();//其实就是new Inner().show()


		//还可以给匿名对象起名字
		//Demo a=new Demo(){定义子类内容}，这就是多态，父类引用指向子类。因为Demo（）{}其实就是子类
		//匿名内部类是有局限的，只能调用父类方法，不能调用子类特有的，匿名内部类就是用来复写的

	}
}


class InnerClass3 
{
	public static void main(String[] args) 
	{
		new Outer().function();//匿名对象
	}
}

匿名内部类测试

interface Inter
{
	abstract void method();
}

class Test
{
	/*static class Inner implements Inter
	{
		public void method()
		{
			System.out.println("method run");
		}
	}

	static Inter function()
	{
		Inter a=new Inner();
		return a;
	}*/
	
	static Inter function()
	{
		return new Inter()
		{
			public void method()//不给public无法访问，权限过小
			{
				System.out.println("method run");
			}
		};
	}

}

class InnerClassTest  
{
	public static void main(String[] args) 
	{

		//理解：Test.function() 没有new，说明function（）是静态方法
		//.method又调用了方法，而只有对象可以调用方法，所以function（）返回的是一个对象
		//而接口中才有method方法，所以返回的必是一个Inter对象
		Test.function().method();
	}
}

异常处理

/*
异常：就是程序在运行时出现不正常情况
异常由来：问题也是现实生活中一个具体的事物，也可以通过Java的类的形式来进行没描述，并封装成对象
      其实就是Java对不正常情况进行描述后的对象体现


对于问题的划分：两种：严重与非严重

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

对于非严重的：Java通过Exception进行描述
   对于这种Exception可以使用针对性方式进行处理

Throwable
	|--Error
	|--Exception 



2.异常的处理
try
{
	需要被检测的代码
}

catch(异常类 变量)
{
	处理异常的代码：（处理方式）
}

finally
{
	一定能会执行的语句
}

3.对捕获到的异常惊喜常见方法的操作

*/

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

class ExceptionDemo 
{
	public static void main(String[] args) 
	{
		Demo a=new Demo();
		try
		{
			int b=a.div(4,0);
			System.out.println(b);
		}
		catch (Exception e)
		{
			System.out.println("除零啦");//Exception e=new ArithmeticException();多态
			System.out.println(e.getMessage());//  / by zero
			System.out.println(e.toString());//异常名称+信息
			e.printStackTrace();//异常名称+异常信息+异常位置
			//其实jvm默认调用的异常处理机制，就是在调用printStrackTrace方法
			//打印异常的堆栈的跟踪信息
		}


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

异常处理2

/*
异常：就是程序在运行时出现不正常情况
异常由来：问题也是现实生活中一个具体的事物，也可以通过Java的类的形式来进行没描述，并封装成对象
      其实就是Java对不正常情况进行描述后的对象体现


对于问题的划分：两种：严重与非严重

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

对于非严重的：Java通过Exception进行描述
   对于这种Exception可以使用针对性方式进行处理

Throwable
	|--Error
	|--Exception 



2.异常的处理
try
{
	需要被检测的代码
}

catch(异常类 变量)
{
	处理异常的代码：（处理方式）
}

finally
{
	一定能会执行的语句
}

3.对捕获到的异常惊喜常见方法的操作

*/

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

class ExceptionDemo2
{
	public static void main(String[] args) //throws Exception//抛给虚拟机
	{
		Demo a=new Demo();
		try
		{
			int b=a.div(4,0);
			System.out.println(b);
		}
		catch (Exception e)
		{
			System.out.println(e.toString());//异常名称+信息
		}
		

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

多异常处理

/*
在函数上申明异常
便于提高安全性，让调用进行处理，不让编译失效。


对于异常的处理
1.申明异常时，建议申明更为具体的异常，这样处理的可以更具体。
2.对方申明几个异常，就应该对应catch快，不要定义多余的catch块
如果多个catch块中的异常出现继承关系，父类异常catch块应该放在最下面
*/
class Demo
{
	int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字申明了该功能会可能出现问题
	{
		int[] arr=new int[4];
		System.out.println(arr[4]);
		return a/b;
	}
}

class ExceptionDemo3
{
	public static void main(String[] args) //throws Exception//抛给虚拟机
	{
		Demo a=new Demo();
		try
		{
			int b=a.div(4,0);
			System.out.println(b);
		}
		catch (ArithmeticException e)//尽量要详细，不要用Exception
		{
			System.out.println(e.toString());//异常名称+信息
			System.out.println("分母为0啦");
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("角标越界啦");
		}
		

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

自定义异常

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

自定义异常
需求：在本程序中，除数时负数，也视为时错误的，时无法进行预算的
那么就需要对这个问题进行自定义的描述。

当在函数内部出现了throw抛出异常对象，那么就必须要给对于的处理动作
（若函数内有throw，那么函数上必须要throws）
要么早内部太容易try catch处理
要么在函数申明上让调用者处理

一般情况下，在函数内部出现异常，函数上需要申明


如何自定义异常信息？

class Throwable
{
	private String message;
	Throwable(message)
	{
		this.message=message;
	}

	public String getMessage()
	{
		return message;
	}
}

class Exception//java已经处理过的异常，就是已经传递过信息了，所以自定义的异常继承exception后需要自己传递
{//就是说没必要自己单独拎出来进行复写
	Exception(String message)
	{
		super(message);
	}
}

因为父类中已经把异常信息的操作都完成了
所以子类只要在构造时，将异常的信息传递给父类通过super语句
那么就可以直接通过getMessage方法获取自定义的异常


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

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具有可抛性，这个可抛性时throwable这个体系中独有特点

只有这个体系中的类和对象才可以被throws和throw操作





throws 和throw的区别：
throws使用在函数上
throw使用在函数内

thrwos后面跟的异常类，可以跟多个，用逗号隔开
throw后跟的时异常对象
*/
class FuShuException extends Exception//这样FuShuException也变成了Exception的一个子类，所以可以被catch住
{
	private String mes;
	private int value;
	FuShuException(String mes,int value)//没必要单独复写了
	{
		super(mes);
		this.value=value;
	}

	public int getValue()
	{
		return value;
	}
	
}

class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
			throw new FuShuException("除数出现了负数",b);//手动通过throw关键字抛出一个自定义异常对象
		return a/b;
	}
}

class  ExceptionDemo4
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();
		try
		{
			int x=d.div(4,-2);
			System.out.println("x="+x);
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());
			System.out.println("错误的除数是："+e.getValue());
		}
		
		System.out.println("over");
	}
}

RuntimeException

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

自定义异常
需求：在本程序中，除数时负数，也视为时错误的，时无法进行预算的
那么就需要对这个问题进行自定义的描述。

当在函数内部出现了throw抛出异常对象，那么就必须要给对于的处理动作
（若函数内有throw，那么函数上必须要throws）
要么早内部太容易try catch处理
要么在函数申明上让调用者处理

一般情况下，在函数内部出现异常，函数上需要申明


如何自定义异常信息？

class Throwable
{
	private String message;
	Throwable(message)
	{
		this.message=message;
	}

	public String getMessage()
	{
		return message;
	}
}

class Exception//java已经处理过的异常，就是已经传递过信息了，所以自定义的异常继承exception后需要自己传递
{//就是说没必要自己单独拎出来进行复写
	Exception(String message)
	{
		super(message);
	}
}

因为父类中已经把异常信息的操作都完成了
所以子类只要在构造时，将异常的信息传递给父类通过super语句
那么就可以直接通过getMessage方法获取自定义的异常


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

继承Exception原因：
异常体系有一个特点：因为异常类和异常对象都被抛出。
他们都具有可抛性，这个可抛性时throwable这个体系中独有特点

只有这个体系中的类和对象才可以被throws和throw操作





throws 和throw的区别：
throws使用在函数上
throw使用在函数内

thrwos后面跟的异常类，可以跟多个，用逗号隔开
throw后跟的时异常对象
*/
class FuShuException extends Exception//这样FuShuException也变成了Exception的一个子类，所以可以被catch住
{
	private String mes;
	private int value;
	FuShuException(String mes,int value)//没必要单独复写了
	{
		super(mes);
		this.value=value;
	}

	public int getValue()
	{
		return value;
	}
	
}

class Demo
{
	int div(int a,int b)throws FuShuException
	{
		if(b<0)
			throw new FuShuException("除数出现了负数",b);//手动通过throw关键字抛出一个自定义异常对象
		return a/b;
	}
}

class  ExceptionDemo4
{
	public static void main(String[] args) 
	{
		Demo d=new Demo();
		try
		{
			int x=d.div(4,-2);
			System.out.println("x="+x);
		}
		catch (FuShuException e)
		{
			System.out.println(e.toString());
			System.out.println("错误的除数是："+e.getValue());
		}
		
		System.out.println("over");
	}
}

附上一张异常继承关系图片