day5--java基础编程：异常，内部类

6 异常

6.1 异常概述

• 出现背景：
  在使用计算机语言进行项目开发的过程中，即使程序员把代码写得尽善尽美，在系统的运行过程中仍然会遇到一些问题，因为很多问题不是靠代码能够避免的，比如:客户输入数据的格式，读取文件是否存在，网络是否始终保持通畅等等。

• 异常：
  在Java语言中，将程序执行中发生的不正常情况称为"异常"。(开发过程中的语法错误和逻辑错误不是异常)

6.2 异常体系

说明：

• Throwable：在 Java 中，所有的异常都有一个共同的祖先 Throwable（可抛出）
  • Error：严重问题，不需要处理
  • Exception：称为异常类，它表示程序本身可以处理的问题
    • RuntimeException：在编译期是不检查的，出现问题后，需要我们回来修改代码
    • 非RuntimeException：编译期就必须处理的，否则程序不能通过编译，就更不能正常运行了

6.2.1 Error举例

package com.atguigu.java;
/*
 * Error:
 * Java虚拟机无法解决的严重问题。如：JVM系统内部错误、资源耗尽等严重情况。比如：StackOverflowError和OOM。
 * 
 * 一般不编写针对性的代码进行处理。出现问题只能改代码。
 * 
 * 
 */
public class ErrorTest {
	public static void main(String[] args) {
		//1.栈溢出：java.lang.StackOverflowError
//		main(args);
		//2.堆溢出：java.lang.OutOfMemoryError 
		Integer[] arr = new Integer[1024*1024*1024];
		
	}
}

6.2.2 Exception举例

package com.atguigu.java1;

import java.io.File;
import java.io.FileInputStream;
import java.util.Date;
import java.util.Scanner;

import org.junit.Test;

/*
 * 一、异常体系结构
 * 
 * java.lang.Throwable
 * 		|-----java.lang.Error:一般不编写针对性的代码进行处理。
 * 		|-----java.lang.Exception:可以进行异常的处理
 * 			|------编译时异常(checked)
 * 					|-----IOException
 * 						|-----FileNotFoundException
 * 					|-----ClassNotFoundException
 * 					|-----SQLException sql异常
 * 			|------运行时异常(unchecked,RuntimeException)
 * 					|-----NullPointerException
 * 					|-----ArrayIndexOutOfBoundsException
 * 					|-----ClassCastException
 * 					|-----NumberFormatException 数字格式异常
 * 					|-----InputMismatchException 输入不匹配异常
 * 					|-----ArithmeticException 算术异常
 * 
 * 
 * 
 * 面试题：常见的异常都有哪些？举例说明
 */
public class ExceptionTest {
	
	//******************以下是编译时异常***************************
	@Test
	public void test7(){
//		File file = new File("hello.txt");
//		FileInputStream fis = new FileInputStream(file);
//		
//		int data = fis.read();
//		while(data != -1){
//			System.out.print((char)data);
//			data = fis.read();
//		}
//		
//		fis.close();
		
	}
	
	//******************以下是运行时异常***************************
	//ArithmeticException
	@Test
	public void test6(){
		int a = 10;
		int b = 0;
		System.out.println(a / b);
	}
	
	//InputMismatchException
	@Test
	public void test5(){
		Scanner scanner = new Scanner(System.in);
		int score = scanner.nextInt();
		System.out.println(score);
		
		scanner.close();
	}
	
	//NumberFormatException
	@Test
	public void test4(){
		
		String str = "123";
		str = "abc";
		int num = Integer.parseInt(str);
		
		
		
	}
	
	//ClassCastException
	@Test
	public void test3(){
		Object obj = new Date();
		String str = (String)obj;
	}
	
	//IndexOutOfBoundsException
	@Test
	public void test2(){
		//ArrayIndexOutOfBoundsException
//		int[] arr = new int[10];
//		System.out.println(arr[10]);
		//StringIndexOutOfBoundsException
		String str = "abc";
		System.out.println(str.charAt(3));
	}
	
	//NullPointerException
	@Test
	public void test1(){
		
//		int[] arr = null;
//		System.out.println(arr[3]);
		
		String str = "abc";
		str = null;
		System.out.println(str.charAt(0));
		
	}
	
	
}

6.3 JVM的默认处理方案

如果程序出现了问题，我们没有做任何处理，最终JVM会做默认的处理

• 把异常的名称，异常原因及异常出现的位置等信息输出在了控制台（由下图可知）
• 程序停止执行（由下图可知，结束并没有输出到控制台）

6.4 Throwable的成员方法

6.5 编译时异常和运行时异常的区别

Java中的异常被分为两大类: 编译时异常和运行时异常，也被称为受检异常和非受检异常所有的RuntimeException类及其子类被称为运行时异常，其他的异常都是编译时异常

• 编译时异常: 必须显示处理，否则程序就会发生错误，无法通过编译
• 运行时异常: 无需显示处理，也可以和编译时异常一样处理

6.6 异常处理概述

• 为什么要进行异常处理：
  因为java虚拟机的默认处理方案，会让程序在出现异常的地方直接结束掉。而在实际开发中我们程序某一个部分出现问题了，它不应该影响后续的执行，所以我们要自己处理异常。

• 如果程序出现了问题，我们需要自己来处理，有两种方案:

  • try … catch …
  • throws

• 异常处理：抓抛模型

  • 过程一：“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个异常对象，并将对象抛出。一旦抛出异常对象后，其后的代码就不会再执行。
    • 关于异常对象的产生：
      ① 系统自动生成的异常对象
      ② 手动的生成一个异常对象，并抛出（throw）
  • 过程二：“抓”：可以理解为异常的处理方式：
    • try-catch-finally ：真正的处理异常，后续代码会执行
    • throws：没有真正处理异常仅仅是抛给调用者，后续代码不会执行

• 如果程序出现了异常没有处理：

  • 最终会跑到main方法中，main方法由jvm虚拟机管理，jvm虚拟机处理异常是杀死进程，结束掉程序。

• 异常处理的意义：

  • 程序出现异常后仍能正确执行，不影响程序运行。

6.7 异常处理方式一:(try-catch-finally)

说明：

• try-catch-finally，又叫做捕获方式。

语法：

//try只能而且出现一次  catch可以出现0到N次    finally出现0到1次  
try{
  	//可能出现异常的代码
  
  }catch(异常类型1 变量名1){
  		//处理异常的方式1
  }catch(异常类型2 变量名2){
  		//处理异常的方式2
  }catch(异常类型3 变量名3){
  		//处理异常的方式3
  }
 ....
  finally{
  		//一定会执行的代码
  }

执行流程:

• 程序从try里面的代码开始执行
• 出现异常，会自动生成一个异常类对象，该异常对象将被提交给Java运行时系统
• 当Java运行时系统接收到异常对象时，会到catch中去找匹配的异常类，找到后进行异常的处理
• 执行完毕之后，程序还可以继续往下执行。

6.7.1 测试1：try-catch结构

package com.shuai;
/**
 * 1.finally是可选的。
 * 
 * 2.使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常就会生成一个对应类的异常对象，根据
 *   此对象的类型到catch中进行匹配。
 * 
 * 3.一旦try中的异常对象匹配到一个catch时，就进入catch中进行异常的处理，一旦处理完成，就跳出当前的
 *   try-catch结构(在没有写finally的情况)，继续执行其后的代码。
 * 
 * 4.catch中的异常类型如果没有父子类关系，谁声明在上，，谁声明在下无所谓。
 *   catch中的异常类型如果有父子类关系，则要求子类在上父类在下，从小到大的排序，否则报错。
 * 
 * 5.常用的异常处理方式：1)String e.getMessage()  2)void e.printStackTrace() 这个比较常用
 * 
 * 6.在try结构中定义的变量，出了try结构以后就不能使用了。想要使用把变量声明在外面，赋值在结构里面。
 * 
 * 7.为什么不写成int num;而要多赋值个0，首先因为变量想要输出首先要声明好后并且有初始化的值，而局部变量
 *   没有默认值，一旦try中的程序报错，直接输出num,num没有值程序会报错，为了避免这种情况，加上0不会影响程
 *   序也不会因为异常情况导致num没有值而保错。
 * 
 *8.try-catch-finally也可以嵌套
 
 * 体会1：使用try-catch-finally结构处理编译异常时，使得编译时不会报错，但运行时有可能报错，相当于try-catch-finally
 *       将编译时可能出现的异常延迟到运行时出现。
 * 体会2：开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。
 *       针对于编译时异常，我们说一定要考虑异常的处理。(如果与前端页面交互提示时，仍要处理。)
 */
public class Demo05 {
    public static void main(String[] args) {
        String str="123";
        str="abc";
        /*为什么不写成int num;而要多赋值个0，首先因为变量想要输出首先要声明好后并且有初始化的值，
        而局部变量没有默认值，一旦try中的程序报错，直接输出num,num没有值程序会报错，为了避免这种
        情况，加上0不会影响程序也不会因为异常情况导致num没有值而报错。*/

        int num = 0;
        try {
            num=Integer.parseInt(str);
            //int num=Integer.parseInt(str);//出现异常
            System.out.println("hell0-------01");//不会输出
        } catch (NullPointerException  e) { //习惯上异常名叫 e
            System.out.println("出现了空指针转换异常");
        }catch (NumberFormatException e) { //一个类型e只在一个catch中有效，所以不同的catch中名字可以相同。
            //System.out.println("出现了数值转换异常"); 一般不这样写，用异常类方法代替，如下：

            //String e.getMessage()：此方法返回值是String类型，想要看就要输出它。因为有返回值就要定义变量进行接收，查看就要输出，这里简写一块了。
            // System.out.println(e.getMessage()); //打印异常信息

            //void e.printStackTrace():此方法返回值是void类型，不需要在进行输出就能查看。
            e.printStackTrace();  //打印异常详细信息


        }catch (Exception e){
            System.out.println("出现了异常");//不会输出
        }
        //System.out.println(num);报错不能调用，因为变量num在catch中定义的，作用域在catch中。
        System.out.println(num);
        System.out.println("hell0-------02");//会输出

    }

}

6.7.2 测试2：finally使用场景分析

package com.atguigu.java1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

import org.junit.Test;

/*
 * try-catch-finally中finally的使用：
 * 
 * 
 * 1.finally是可选的
 * 
 * 2.finally中声明的是一定会被执行的代码。即使catch中又出现异常了，try中有return语句，catch中有
 * return语句等情况。
 * 
 * 3.像数据库连接、输入输出流、网络编程Socket等资源，JVM是不能自动的回收的，我们需要自己手动的进行资源的
 *   释放。此时的资源释放，就需要声明在finally中。
 * 
 * 
 * 
 */
public class FinallyTest {
	
	
	@Test
	public void test2(){
		FileInputStream fis = null;
		try {
			File file = new File("hello1.txt");
			fis = new FileInputStream(file);
			
			int data = fis.read();
			while(data != -1){
				System.out.print((char)data);
				data = fis.read();
			}
			
			
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			try {
				if(fis != null)//如果文件没有创建成功为赋的默认值null会报空指针异常，加上if判断避免这一情况。
					fis.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	
	
	@Test
	public void testMethod(){
		int num = method();
		System.out.println(num);
	}
	
	public int method(){
		
		try{
			int[] arr = new int[10];
			System.out.println(arr[10]);
			return 1;
		}catch(ArrayIndexOutOfBoundsException e){
			e.printStackTrace();
			return 2;
		}finally{
			System.out.println("我一定会被执行");
			return 3;
		}
		
		
	}
	
	@Test
	public void test1(){
		try{
			int a = 10;
			int b = 0;
			System.out.println(a / b);
			
		}catch(ArithmeticException e){
			e.printStackTrace();
			
//			int[] arr = new int[10];
//			System.out.println(arr[10]);
			
		}catch(Exception e){
			e.printStackTrace();
		}
//		System.out.println("我好帅啊！！！~~");
		
		finally{
			System.out.println("我好帅啊~~");
		}
		
	}
	
}

快捷键：选中报错包裹的代码—>Suround With—>Try/catch Block

注意：修改代码关闭流放在finally中。

6.8 异常处理方式二:(throws)

• 使用背景：
  虽然我们通过try…catch.….可以对异常进行处理，但是并不是所有的情况我们都有权限进行异常的处理也就是说，有些时候可能出现的异常是我们处理不了的，这个时候该怎么办呢?
  针对这种情况，Java提供了throws的处理方案

• 格式：

throws 异常类名;

• 注意：这个格式是跟在方法的括号后面的

• 编译时异常必须要进行处理，两种处理方案: try…catch 或者throws，如果采用throws这种方案，将来谁调用谁处理

• 运行时异常可以不处理，出现问题后，需要我们回来修改代码

• 执行流程：

  • "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
  • 一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。
  • 异常代码后续的代码，就不再执行！

6.8.1 案例1:测试throws关键字

package com.atguigu.java1;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * 异常处理的方式二：throws + 异常类型
 *
 * 1. "throws + 异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
 *     一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常
 *     类型时，就会被抛出。异常代码后续的代码，就不再执行！
 *
 * 2. 体会：try-catch-finally:真正的将异常给处理掉了。
 *        throws的方式只是将异常抛给了方法的调用者。  并没有真正将异常处理掉。
 *
 * 3. 开发中如何选择使用try-catch-finally 还是使用throws？
 *   3.1 如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws，意味着如果
 *       子类重写的方法中有异常，必须使用try-catch-finally方式处理。
 *   3.2 执行的方法a中，先后又调用了另外的几个方法，这几个方法是递进关系执行的。我们建议这几个方法使用throws
 *       的方式进行处理。而执行的方法a可以考虑使用try-catch-finally方式进行处理。
 *
 */
public class ExceptionTest2 {


    public static void main(String[] args){
        try{
            method2();

        }catch(IOException e){
            e.printStackTrace();
        }

//		method3();

    }


    public static void method3(){
        try {
            method2();
        } catch (IOException e) {
        //IOException 是FileNotFoundException异常的父类，这里处理方式又相同所以只需要写一个catch即可。
            e.printStackTrace();
        }
    }

    //method1抛出了2个异常，这里method2调用为什么只抛出一个异常呢？？
    //如果2个异常是父子类关系，并且处理异常的方式相同，比如都是e.printStackTrace();，那么只需要抛出一个异常即可。
    public static void method2() throws IOException{
        method1();
    }


    public static void method1() throws FileNotFoundException,IOException{
        File file = new File("hello1.txt");
        FileInputStream fis = new FileInputStream(file);

        int data = fis.read();
        while(data != -1){
            System.out.print((char)data);
            data = fis.read();
        }

        fis.close();

        System.out.println("hahaha!");
    }


}

6.8.2 案例2:测试方法重写子类抛出异常小于父类

方法重写的规则之一：：子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型。

package com.atguigu.java1;

import java.io.FileNotFoundException;
import java.io.IOException;

/*
 * 方法重写的规则之一：
 * 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
 * 
 * 
 */
public class OverrideTest {
	
	public static void main(String[] args) {
		OverrideTest test = new OverrideTest();
		test.display(new SubClass());
	}

	
	public void display(SuperClass s){
		try {
			s.method();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

class SuperClass{
	
	public void method() throws IOException{
		
	}
	
	
}

class SubClass extends SuperClass{
//如果方法重写调用子类的方法的方法体，子类抛出的异常大于父类的，父类已经处理的异常在子类中不包含，则父类处理异常没有什么意义。
	public void method()throws FileNotFoundException{
		
	}
}

6.9 手动抛出异常对象(throw)

• 使用背景：如下图。

• 作用：用于在方法体内部抛出异常对象

• 关于异常对象的产生：

  • 系统自动生成的异常对象
  • 手动的生成一个异常对象，并抛出（throw）

• 注意：手动抛出异常如果是运行时异常对象可以不用处理，如果抛出的是编译期异常对象一定要处理异常。

6.9.1 没有手动抛出异常对象之前

package com.atguigu.java2;

public class StudentTest {
	
	public static void main(String[] args) {
		
			Student s = new Student();
			s.regist(-1001);
			System.out.println(s);//直接输出对象的引用实际上时输出.toString()方法。
		
	}
	
}


class Student{
	
	private int id;
	
	public void regist(int id)  {
		if(id > 0){
			this.id = id;
		}else{
			/*
			 * 即便你此时输入的是负数不合理，只能给你个提示输入的数据错误，但是这样写还是把结果输出了。
			 * 正常来讲：应该是输入的是负数不合理，程序直接报错不会再向下执行输出结果，所以这里一般是手动抛出异常对象，
			 *        一旦数据不合理直接报异常，程序停止运行。
			 */
			System.out.println("您输入的数据非法！");
			
		}
		
	}

	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}
	
	
}

6.9.2 手动抛出异常对象之后

package com.atguigu.java2;

public class StudentTest {
	
	public static void main(String[] args) {
		try {
			Student s = new Student();
			s.regist(-1001);
			System.out.println(s);
		} catch (Exception e) {
//			e.printStackTrace();

         		
			/*throw new RuntimeException("您输入的数据非法！")里面的值是由RuntimeException的有参构造方法中super(xxx)调用--->
			 * 父类的Exception的有参构造方法中super(xxx)调用----> Throable中的有参构造方法，在Throable类中通过有参构造方法
			 * 赋值(this.detailMessage = message;) 给成员变量： private String detailMessage;为：您输入的数据非法！
			 * 即：值最终赋值给Throable类的成员变量detailMessage。
			 * 			 					 	
			 * void e.getMessage() 底层源码：
			 * public String getMessage() {
             *     return detailMessage;
             *  }
			 * 这个方法getMessage()的返回值为Throable类中的detailMessage成员变量，所以输出结果为：您输入的数据非法！ */
			System.out.println(e.getMessage());
		}
	}
	
}


class Student{
	
	private int id;
	
	public void regist(int id) throws Exception {
		if(id > 0){
			this.id = id;
		}else{
//			System.out.println("您输入的数据非法！");
			//手动抛出异常对象
//			throw new RuntimeException("您输入的数据非法！");抛出运行时异常，调用方不用处理。
//			throw new Exception("您输入的数据非法！");Exception包含编译器异常，所以一旦throws抛出，在调用方一定要进行处理编译器异常。
			throw new MyException("不能输入负数");//抛出的是自定义异常
			//错误的 String不是异常类
//			throw new String("不能输入负数");
//return 0;如果方法有返回值且不影响结果，则可以用throw代替return，因为如果报异常也会结束方法运行。

		}
		
	}

	@Override
	public String toString() {
		return "Student [id=" + id + "]";
	}
	
	
}

6.9.3 throw和throws的区别

6.10 自定义异常

使用背景：

• 目的是系统提供的异常类型是有限的，如果程序产生的异常不在提供中，可以抛出自己定义的异常使得异常类型更加精确（一般和throw连用）
• 一般这个自定义异常类，定义这个类时要做到见名知意。

格式：

范例：

6.10.1 测试

和案例6.9.2连用。

package com.atguigu.java2;
/*
 * 如何自定义异常类？
 * 1.继承于现有的异常结构：RuntimeException 、Exception(包含运行和编译器异常，
 *    所以编译期就要进行处理异常)
 *   RuntimeException异常：只需要继承RuntimeException异常或者它的子类。
 *   Checked异常：只需要继承Exception异常或者Exception的子类,但需要除RuntimeException之外。
 * 2.提供全局常量：serialVersionUID
 * 3.提供重载的构造器
 * 
 */
public class MyException extends Exception{
	
	static final long serialVersionUID = -7034897193246939L;
	
	//无参构造方法
	public MyException(){
		
	}
	//有参构造方法
	public MyException(String msg){
	/*
		 * 调用父类的有参构造，因为上面的案例中处理异常使用的是e.getMessage()方法，
		 * 这个方法返回值为Throable的成员变量dtailMessage属性。而现在自定义异常对象
		 * 的通过有参构造方法创建对象并传参，这个自定义异常对象的参数不是自己定义的而是定义
		 * 在顶级父类Throable中的成员变量，所以想要赋值给父类Throable的属性需要在子类
		 * 的构造方法中通过super一步一步调用父类构造方法，最终在Throwable的构造方法中把
		 * 值赋值给成员变量dtailMessage。
		 */
		super(msg);
	}
}

7. 内部类

7.1 成员内部类(静态/非静态)

package com.atguigu.java2;
/*
 * 类的内部成员之五：内部类
 * 1. Java中允许将一个类A声明在另一个类B中，则类A就是内部类，类B称为外部类
 * 
 * 2.内部类的分类：成员内部类（静态、非静态）  vs 局部内部类(方法内、代码块内、构造器内)
 * 
 * 3.成员内部类：
 * 		一方面，作为外部类的成员：
 * 			>调用外部类的结构
 * 			>可以被static修饰
 * 			>可以被4种不同的权限修饰
 * 
 * 		另一方面，作为一个类：
 * 			> 类内可以定义属性、方法、构造器等
 * 			> 可以被final修饰，表示此类不能被继承。言外之意，不使用final，就可以被继承
 * 			> 可以被abstract修饰
 * 
 * 
 * 4.关注如下的3个问题
 *   4.1 如何实例化成员内部类的对象
 *   4.2 如何在成员内部类中区分调用外部类的结构
 *   4.3 开发中局部内部类的使用  见《InnerClassTest1.java》
 * 
 */
public class InnerClassTest {
	public static void main(String[] args) {
		
		//创建Dog实例(静态的成员内部类):
		Person.Dog dog = new Person.Dog();
		dog.show();
		//创建Bird实例(非静态的成员内部类):
//		Person.Bird bird = new Person.Bird();//错误的
		Person p = new Person();
		Person.Bird bird = p.new Bird();
		bird.sing();
		
		System.out.println();
		
		bird.display("黄鹂");
		
	}
}


class Person{//外部类
	
	String name = "小明";
	int age;
	
	public void eat(){
		System.out.println("人：吃饭");
	}
	
	
	//静态成员内部类
	static class Dog{
		String name;
		int age;
		
		public void show(){
			System.out.println("卡拉是条狗");
//			eat();
		}
		
	}
	//非静态成员内部类
	class Bird{
		String name = "杜鹃";
		
		public Bird(){
			
		}
		
		public void sing(){
			System.out.println("我是一只小小鸟");
			Person.this.eat();//调用外部类的非静态属性 属性不同名可以省略为:eat();
			eat();
			System.out.println(age);
		}
		
		public void display(String name){
			System.out.println(name);//方法的形参
			System.out.println(this.name);//内部类的属性
			System.out.println(Person.this.name);//外部类的属性 属性不同名可以省略
		}
	}
	
	
	public void method(){
		//局部内部类
		class AA{
			
		}
	}
	
	{
		//局部内部类
		class BB{
			
		}
	}
	
	public Person(){
		//局部内部类
		class CC{
			
		}
	}
	
	
	
}

7.2 局部内部类(匿名/非匿名)

package com.atguigu.java2;

public class InnerClassTest1 {
	
	
	//开发中很少见
	public void method(){
		//局部内部类
		class AA{
			
		}
	}
	
	
	//返回一个实现了Comparable接口的类的对象
	public Comparable getComparable(){
		
		//创建一个实现了Comparable接口的类:局部内部类
		//方式一：
//		class MyComparable implements Comparable{ //Comparable为源码里面的接口
//
//			@Override
//			public int compareTo(Object o) {
//				return 0;
//			}
//			
//		}
//		
//		return new MyComparable();
		
		//方式二：
		return new Comparable(){

			@Override
			public int compareTo(Object o) {
				return 0;
			}
			
		};
		
	}
	
}