JAVA基础第九天学习日记_内部类、匿名内部类、异常_内部类与异常类实验报告心得-优快云博客

本文链接：https://blog.youkuaiyun.com/zorroblood/article/details/7795170

本文详细介绍了JAVA中的内部类和匿名内部类，包括它们的访问特点、创建对象的方式以及局部内部类的限制。同时，文章探讨了异常处理的重要性，如异常封装、异常体系和异常处理机制，包括try-catch-finally语句的使用，以及自定义异常的创建和使用规范。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

------- android培训、 java培训、期待与您交流！ ----------

内部类：

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

当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容。

访问特点：

l 内部类可以直接访问外部类中的成员，包括私有成员。

l 外部类要访问内部类中的成员必须要建立内部类的对象。

l 局部内部类不能被private和static所修饰，因为它们只能修饰成员。

l 局部内部类可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

class Outer
{
 int x=3;
 void method()
 {
  final int y=4;
  class Inner//此为局部内部类。
  {
   void funnction()
   {
    System.out.println(x);
    System.out.println(y);//局部内部类要使用局部变量，此变量必须是final修饰的。原因是:因为这个内部类存在于方法内方法内的局部变量虽说作用域是方法体内,但是它所包含的内部类却不是与方法共存亡的,所以当方法执行完毕，方法的内存被释放,而这个内部累还在使用该方法的一个不存在的局部变量是不合常理的,所以，被final修饰后值是不可变的，所以即便方法不存在了,那个值还是可以拿来继续使用。也可以换个理解方式，那就是我们不是为了给内部类使用才把局部变量用final修饰,而是被final修饰的，才有资格被内部类使用。
   }
  }
  new Inner().funnction();
 }
}

l 当内部类在成员位置上，就可以被成员修饰符所修饰。

比如：private：将内部类在外部类中进行封装。

Static:内部类就具备static的特性。只能直接访问外部类中的static成员，出现了访问局限。

在外部其他类中，直接访问static内部类的非静态成员：

new outer.Inner().function();

在外部其他类中，直接访问static内部类的静态成员：

Outer.inner.function（）；

当内部类定义了静态成员，该内部类必须是static。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

新建内部类对象：

Outer.inner In = new Outer () .new Inner();

在有局部变量的时候变量的作用范围：

之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式为外部类名.this 。

匿名内部类：

l 匿名内部类其实就是内部类的简写格式。

l 定义匿名内部类的前提是：内部类必须是继承一个类或者实现接口。

l 匿名内部类格式： new 父类或者接口（）｛定义子类的内容｝

l 其实匿名内部类就是一个匿名子类对象。而求这个对象有点“胖”可以理解为带内容的对象。

l 匿名内部类中定义的方法最好不超过3个。

public class AnonymityInnerClass {
		public static void main(String[] args) {
		Test.function().method();//此处调用了Inner接口的method方法，所以function方法返回了一个Inner的子类对象。
	}
}
interface Inner
{
	void method();
}
class Test
{
	static Inner function()//通过匿名内部类实现。补足代码。
	{
		return new Inner()//匿名内部类。
		{
			public void method()
			{
				System.out.println("method run");
			}
		};
	}
}

--------------------------------------------------------------------------------

异常：就是程序运行时出现的不正常情况。

异常的好处：

1. 将问题进行封装。

2. 将正常流程代码和问题处理代码相分离，方便于阅读。

异常体系：

l Throwable

Error

通常出现重大问题如：运行的类不存在或者内存溢出等。

不编写针对代码对其处理

Exception

在运行时运行出现的一些情况，可以通过try catch finally处理

Exception和Error的子类名都是以父类名作为后缀。

Exception和Error都具有一些共性内容。比如：不正常信息，引发原因等。

异常由来：

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

异常的处理：

Java提供了特有语句进行处理：

Try

｛

需要被检测的代码

｝

Catch （异常类变量）

｛

处理异常代码：（处理方式）

（建立catch处理时，catch中一定要定义具体的处理方式。不要简单定义一句e.printStacktrace(),也不要简单的就书写一条输出语句。）

（异常的常见处理信息：

getMessage:得到异常信息；

toString:异常名称：异常信息

printStackTrace:异常名称，异常信息，异常出现的位置。

其实JVM默认的异常处理机制，就是在调用此方法，打印异常的堆栈的跟踪信息）

｝

Finally

｛

一定会执行的语句。

这条语句与方法中的语句的区别是：如果在处理中出现异常并且终止程序，那么over不再执行，但是finally是始终执行。

Finally中定义的通常是关闭资源代码。因为资源必须释放。

Finally只有一种情况不会执行。当执行到System。Exit(0)；finally不会执行。

｝

三种结合格式：

Try、catch try、finally try、catch、finally

对多异常的处理：

声明异常时，建议声明更为具体的异常。这样处理的可以更具体。

对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放到最下面。

public class ExceptionDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Demo d=new Demo();
		try
		{
			int x=d.div(4, 0);
			System.out.println(x);
		}
		catch(ArithmeticException e)
		{
			System.out.println(e.toString());
			System.out.println("被零除了！");
		}
		catch(ArrayIndexOutOfBoundsException e)
		{
			System.out.println(e.toString());
			System.out.println("角标越界了！");
		}
	}

}
class Demo	
{
	int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException
	{
		int[] arr=new int[4];
		System.out.println(arr[3]);
		return a/b;
	}
}

自定义异常：

定义类继承Exception或者RuntimeException

1. 为了让该自定义类具备可抛性。

2. 让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。异常信息传递给父类的构造函数。

class MyException extends Exception

{

MyException（String mes）

{

Super(mes);

}

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

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

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。要么在函数上声明让调用者处理。

如何定义异常信息呢？

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

继承exception原因是：异常体系有个特点：因为异常类和异常对象都被抛出。他们都具备可抛型。这个可抛性是Throwable这个体系中独有的特点。只有这个体系中的类和对象才可以被throw和throws操作。

Throw和throws的区别：

Throws用在函数上， throw用在函数内。

Throws后面跟的异常类。可以跟多个，用逗号隔开。

Throw后跟的是异常对象。

对于异常分为两种：

编译时被检测的异常。

该异常在编译时，如果没有处理（没有抛出也没有try），编译失败。

该异常被标识，代表这可以被处理。

编译时不被检测的异常。（运行是异常。RuntimeException以及其子类）

在编译时，不需要处理，编译器不检查。

该异常的发生，建议不处理，让程序停止，需要对代码进行修正。

Exception中有一个特殊的子类异常RuntimeException运行是异常。

如果在函数内容抛出该异常类，函数上可以不用声明，编译一样通过。

如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。

之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后对代码进行修正。

所以说，自定义异常时：如果该异常的发生，无法在继续运算时进行运算，就让自定义异常继承RuntimeException。

class Demo 
{
 int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException,FushuException//throws用在函数上，后面跟的是异常类。
 {
  if (b<0) {
   throw new FushuException("出现了负数的情况",b);//throw用在函数内，后面跟的是异常对象
  }
  int[] arr=new int[4];
  System.out.println(arr[3]);
  return a/b;
 }
}
class FushuException extends Exception
{
 private String msg;
 private int value;
 FushuException(String msg,int value)
 {
  this.msg=msg; 
  this.value=value;
 }
 public String getMessage()
 {
  return msg;
 }
 public int getValue()
 {
  return value;
 }
}

异常在子父类覆盖中的体现：

1. 子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的异常或者该异常的子类。

2. 如果父类方法抛出多个异常，那么子类在覆盖方法时，只能抛出父类异常的子类。

3. 如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也可以抛出异常。如果子类方法发生了异常。就必须要进行try处理，绝对不能抛出。

异常的练习：

public class ComputerDemo {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Teacher tea=new Teacher("毕老师");
		try {
			tea.prelect();
		} catch (NoplanException e) {
			// TODO Auto-generated catch block
			System.out.println("换老师或放假");
		}
		
	}
}
class BluescreenException extends Exception
{
	private static final long serialVersionUID = 1L;
	BluescreenException(String message) 
	{
		super(message);
	}
}
class SmokeingException extends Exception
{
	private static final long serialVersionUID = 1L;
	SmokeingException(String message)
	{
		super(message);
	}
}
class NoplanException extends RuntimeException
{
	private static final long serialVersionUID = 1L;
	NoplanException(String message)
	{
		super(message);
	}
}
class Computer
{
	private int state=2;
	public void run()throws BluescreenException,SmokeingException
	{	
		if(state==2) 
			throw new BluescreenException("蓝屏了");
		if(state==3)
			throw new SmokeingException("冒烟了");
		System.out.println("电脑运行");
	}
	public void reset()
	{
		state=1;
		System.out.println("电脑重启");
	}
}
class Teacher
{
	private String name;
	private Computer cm;
	Teacher(String name)
	{
		this.name=name;
		cm=new Computer();
	}
	public void prelect()
	{
		try 
		{
			cm.run();
			
		} 
		catch (BluescreenException e)
		{
			System.out.println(e.toString());
			cm.reset();
		}
		catch(SmokeingException e)//冒烟异常，teacher无法处理。抛出。
		{
			System.out.println(e.toString());
			test();
			throw new NoplanException("课时无法继续");//不能处理的异常抛出。
			//test();//写到RuntimeException后面的语句无法执行到，会包异常。
		}
		System.out.println(name+"讲课");
	}
	public void test()
	{
		System.out.println("练习");
	}
}

------- android培训、 java培训、期待与您交流！ ----------　　详细请查看： http://edu.youkuaiyun.com/heima/