内部类、匿名内部类、异常及异常处理_怎么处理本体里面的非匿名类-优快云博客

本文链接：https://blog.youkuaiyun.com/a626361893/article/details/50533237

一、内部类

定义：
将一个类定义在另一个类的里面，里面那个类就称为内部类（内置类，嵌套类）。

访问特点：
内部类可以直接访问外部类中的成员，包括私有成员。
而外部类要访问内部类中的成员必须要建立内部类的对象。

示例：

/*
内部类的设计：
分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容，这时候就定义
内部类。
*/
class Outer
{
	private int num = 3;
	class Inner//内部类
	{
		void show()
		{
			System.out.println("show run..." + num);
		}
	}
	public void method()
	{
		Inner in = new Inner();
		in.show();
	}
}

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

1.内部类的位置：
内部类定义在成员位置上，可以被private、static成员修饰符修饰。被static修饰的内部类只能访问外部类中的静态成员。

2.如果内部类是静态的，内部类成员也是静态的，可以不用创建内部类对象，直接调用。

3.如果内部类中定义了静态成员，该内部类也必须是静态的！

4.为什么内部类能直接访问外部类中的成员呢？
那是因为内部类持有了外部类的引用，外部类名.this。

5.内部类定义在局部位置上，也可以直接访问外部类中的成员。
同时可以访问所在局部中的局部变量，但必须是被final修饰的。

二、匿名内部类

定义：
就是内部类的简化写法。

前提：
内部类可以继承或实现一个外部类或者接口。


格式：
new外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}


简单理解：
就是建立一个带内容的外部类或者接口的子类匿名对象。


什么时候使用匿名内部类呢？
通常使用方法是接口类型参数，并且该接口中的方法不超过三个，可以将匿名内部类作为参数传递。

好处：
增强阅读性。

示例2：

interface Inter//创建一个接口
{
	void show1();
	void show2();
}

class Outer
{
	public void method()
	{
		Inter in = new Inter()
		{
			public void show1()
			{
				System.out.println("...show1...." );
			}
			public void show2()
			{
				System.out.println("...show2...." );
		}
	};
	in.show1();
	in.show2();
   }
}

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

示例3：

interface Inter
{
	void show1();
	void show2();
}

/*
通常的使用场景之一：

当函数参数是接口类型时，而且接口中的方法不超过三个。

可以用匿名内部类作为实际参数进行传递。
*/
class InnerClassDemo3
{
	public static void main(String[] args)
	{
		show(new Inter()
		{
			public void show1()
			{
				System.out.println("...show1..." );
			}
			public void show2()
			{
				System.out.println("...show2..." );
			}
		});
	}
	public static void show(Inter in)
	{
		in.show1();
		in.show2();
	}
}

三、异常

异常：

就是程序在运行时出现不正常情况。

异常由来：

问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分：

两种：一种是严重的问题，一种非严重的问题。

异常体系

Throwable

|—Error

|—Exception

对于严重的，java通过Error类进行描述。

对于Error一般不编写针对性的代码对其进行处理。

对于非严重的，java通过Exception类进行描述。

对于Exception可以使用针对性的处理方式进行处理。

无论Error或者Exception都具有一些共性内容。

比如：不正常情况的信息，引发原因等。

class Demo
{
	int div(int a,int b)throws Exception{//在功能上通过throws的关键字声明了该功能有可能会出现问题。
        return a/b;
    }
}
class  ExceptionDemo{
	public static void main(String[] args) {
        Demo d = new Demo();
        try{
            int x = d.div(4,1);
            System.out.println("x="+x);
        }catch (Exception e){//Exception e = new ArithmeticException();
            System.out.println("除零啦");
            System.out.println(e.getMessage());//  / by zero;
            System.out.println(e.toString());// 异常名称 ： 异常信息。
            e.printStackTrace();//异常名称，异常信息，异常出现的位置。
                            //其实jvm默认的异常处理机制，就是在调用printStackTrace方法。
                            //打印异常的堆栈的跟踪信息。
        }       
        System.out.println("over");
    }
}

四、异常的处理

java 提供了特有的语句进行处理。

try

{

需要被检测的代码；

}

catch(异常类变量)

{

处理异常的代码：(处理方式)

}

finally

{

一定会执行的语句；

}

处理过程：
try中检测到异常会将异常对象传递给catch，catch捕获到异常进行处理。
finally里通常用来关闭资源。比如：数据库资源，IO资源等。
需要注意：try是一个独立的代码块，在其中定义的变量只在该变量块中有效。
如果在try以外继续使用，需要在try外建立引用，在try中对其进行初始化。IO，Socket就会遇到。

示例：

class FuShuIndexException extends RuntimeException
{
	FuShuIndexException(){}
	FuShuIndexException(String msg)
	{
		super(msg);
	}
}

class Demo
{
	public static int method(int[] arr, int index) throws 
	NullPointerException,FuShuIndexException{
		if(arr == null)
				throw new NullPointerException(" 没有任何数组实体 ");
		if(index < 0){
				throw new FuShuIndexException(" 数组的角标是负数啦！ ");
		}
		return arr[index];
	}
}

class ExceptionDemo
{
	public static void main(String[] args){
	  int[] arr = new int[3];
	  try{
			int num = Demo.method(arr,-30);
			System.out.println("num:" + num);
		 } catch(NullPointerException e){
				System.out.println(e);
		 } catch(FuShuIndexException e){
				System. out.println("message:" + e.getMessage());
				System.out.println("string:" + e);
				e.printStackTrace(); //jvm  默认的异常处理机制就是调用异常对象的这个方法。
				System.out.println(" 负数角标异常！！！ ");
		} catch(Exception e){//Exception 的 catch 放在最下面，先处理有针对性的异常
				System.out.println(e);
		}
				System.out.println("over" );
	}
}

异常处理的原则：
1.函数内容如果抛出需要检测的异常，那么函数上必须要声明。
否则，必须在函数内用try/catch捕捉，否则编译失败。
2.如果调用到了声明异常的函数，要么try/catch，要么throws，否则编译失败。

3.什么时候catch，什么时候throws呢？
功能内容可以解决，用catch。
解决不了，用throws告诉调用者，由调用者解决。
4.一个功能如果抛出了多个异常，那么调用时，必须有对应多个catch进行针对性处理。
内部有几个需要检测的异常，就抛几个异常，抛出几个，就catch几个。

示例：

class Demo{
	public int show(int index) throws ArrayIndexOutOfBoundsException{
	if(index < 0)
		throw new ArrayIndexOutOfBoundsException("越界啦！");
		int[] arr = new int[3];
		return arr[index];
	}
}

class ExceptionDemo{
	public static void main(String[] args){
		Demo d = new Demo();
		try{
				int num = d.show(-3);
				System.out.println("num = " + num);
			} catch(ArrayIndexOutOfBoundsException e){
				System.out.println(e.toString());
				System.exit(0);//退出jvm
			} 
			finally{//通常用于关闭（释放）资源
				System.out.println("finally");//由于前面执行了System.exit(0);，故不会执行此语句。
			}
			System.out.println("over");
	}
}

Throwable中的方法：
1.getMessage()：获取异常信息，返回字符串。
2.toString()：获取异常类名和异常信息，返回字符串。
3.printStackTrace()：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void。
4.printStackTrace(PrintStreams)：通常用该方法将异常内容保存在日志文件中，以便查阅。

自定义异常：

可以自定义出的问题称为自定义异常。项目中的特有问题并未被 Java 所描述并封装对象，可以按照 Java 对问题封装的思想，将特有的问题进行自定义的异常封装；

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作，要么在内部try catch处理，要么在函数上声明（否则编译失败，RuntimeException除外）；一般情况函数内部出现异常在函数上需要声明；

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

自定义异常：必须是自定义类继承Exception或者RuntimeException；

原因：

异常体系有一个特点：异常类和异常对象都要被抛出，他们都具备可抛性，这个可抛性是Throwable这个体系的独有特点；只有这个体系中的类和对象才可以被throw和thorws操作；让类具备操作异常的共性方法；通过throw将自定义异常抛出。

示例：

Class DemoException extends Exception
{
	DemoException(String message)
	{
		super(message);
	}
}

throws和throw的区别：

1.throws用于标识函数暴露出的异常类，并且可以抛出多个，用逗号分隔。throw用于抛出异常对象。
2.thorws用在函数上，后面跟异常类名。throw用在函数内，后面跟异常对象。
定义功能方法时，需要把出现的问题暴露出来让调用者去处理，那么就通过throws在函数上标识。
在功能方法内部出现某种情况，程序不能继续运行，需要进行跳转时，就用throw把异常对象抛出。

class FuShuIndexException extends Exception{
	
	FuShuIndexException(){}

	FuShuIndexException(String msg){
		super(msg);
	}
}

class Demo{
	public static int method(int[] arr, int index) throws FuShuIndexException{
		if(index < 0){
			throw new FuShuIndexException("数组的角标是负数啦！" );
		}
		return arr[index];
	}
}

class ExceptionDemo2{
	public static void main(String[] args) throws FuShuIndexException{
		int[] arr = new int[3];
		Demo.method(arr,-30);
	}
}

异常的分类：
1.编译时被检测异常：只要是Exception和其子类都是，除了特殊子类RuntimeException体系。
这种问题一旦出现，希望在编译时就进行检测，让这种问题有对应的处理方式。
这样的问题都可以针对性的处理。
2.编译时不检测异常（运行时异常）：就是Exception中的RuntimeException和其子类。
这种问题的发生，无法让功能继续，运算无法运行，更多是因为调用的原因导致的或者引发了内部状态的改变导致的。
那么这种问题一般不处理，直接编译通过，在运行时，让调用者调用时的程序强制停止，让调用者对代码进行调整。
所以自定义异常时，要么继承Exception，要么继承RuntimeException。

示例：

<span style="font-size:10px;">class FuShuIndexException extends RuntimeException{</span>
	
	FuShuIndexException(){}

	FuShuIndexException(String msg){
		super(msg);
	}
}

class Demo{
	public static int method(int[] arr, int index){//RuntimeException没有必要用throws抛出，并不是必须要处理
		if(index < 0){
			throw new FuShuIndexException("数组的角标是负数啦！" );
		}
		return arr[index];
	}
}

RuntimeException是那些可能在Java虚拟机正常运行期间抛出的异常的超类。
可能在执行方法期间抛出但未被捕获的RuntimeException的任何子类都无需在throws子句中进行声明。

异常综合案例：

/*
毕老师用电脑上课。

问题领域中涉及两个对象。
毕老师，电脑。

分析其中的问题。
比如电脑蓝屏，冒烟等。
*/
class LanPingException extends Exception{
	LanPingException(String msg){
		super(msg);
	}
}

class MaoYanException extends Exception{
	MaoYanException(String msg){
		super(msg);
	}
}

class NoPlanException extends Exception{
	NoPlanException(String msg){
		super(msg);
	}
}

class Computer{
		private int state = 1;//0 2
		public void run() throws LanPingException,MaoYanException{
			if(state == 1)
				throw new LanPingException("电脑蓝屏啦！");
			if(state == 2)
				throw new MaoYanException("电脑冒烟啦！");
			System. out.println("电脑运行");
		}
		public void reset(){
			state = 0;
			System.out.println("电脑重启");
		}
}

class Teacher{
	private String name ;
	private Computer comp ;

	Teacher(String name){
	this.name = name;
	comp = new Computer();
	}	

	public void prelect() throws NoPlanException{
	try{
		comp.run();
		System.out.println(name+"讲课");
	}catch(LanPingException e){
		System.out.println(e.toString());
		comp.reset();
		prelect();
	} catch(MaoYanException e){
		System. out.println(e.toString());
		test();
		//可以对电脑进行维修
		throw new NoPlanException("课时进度无法完成，原因：" + e.getMessage());
		}
	}
	public void test(){
	System.out.println("大家练习");
	}
}

class ExceptionDemo3{
	public static void main(String[] args){
		Teacher t = new Teacher("毕老师");
		try{
				t.prelect();
		} catch(NoPlanException e){
				System.out.println(e.toString()+".......");
				System.out.println("换人");
			}
		}
}

异常的注意事项：
1.RuntimeException以及其子类如果在函数中被throw抛出，可以不用在函数上声明。
2.子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类。
3.如果父类抛出多个异常，那么子类只能抛出父类异常的子集。
简单说：子类覆盖父类只能抛出父类的异常或者子类的子集。
4.如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try。