--面向对象第二部分-内部类、异常--java学习日记6（基础知识）

 

       面向对象是一种思想，它将事物抽象，封装，方便人们理解和使用。面向对象就是在解决问题的过程中寻找对象、创建对象和使用对象。把问题里拥有相同属性的东西建立一个类，类有属性和方法，然后创建类的一个对象，调用类的属性方法来解决问题。面向对象以功能来划分问题，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。

       内部类就是面向对象中一个重要的概念。首先明确的是：类是我们为了描述一个事物而将共性的东西抽象出来形成一个整体，当我们要描述一个具体事物时只要指出它的特性就行了。如果事物中又包含其他的事物，或者说一个事物依赖于另一个事物的存在而存在时，我们要描述这个内部依存的事物就要用到内部类。内部类就是定义在类里面的类，如下就定义了一个简单的内部类：

class Outer
{
	private int x = 3;
	
	class Inner//内部类
	{
		//int x = 4;
		void function()
		{
			//int x = 6;
			System.out.println("innner :"+Outer.this.x);
		}
	}

	/*定义一个方法，用来实例化内部类并调用内部类中的方法*/
	void method()
	{
		Inner in = new Inner();
		in.function();
	}
}


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

		//直接访问内部类中的成员。
//		Outer.Inner in = new Outer().new Inner();
//		in.function();
	}
}

       内部类可以直接访问外部类中的成员，包括私有。因为内部类持有一个外部类的引用Outer.this,如上将打印出外部类的x的值3，如果在内部类里定义一个x成员变量，则System.out.println(x)将输出自己的x 即4，此时要得到外部类的域就要显示地用Outer.this.x来获得，如果在内部类方法中定义了局部变量x ,则将打印出局部变量的值，要访问内部类的成员变量x 就要用this.x，this代表这个内部类的示例对象的引用。

       外部类要访问内部类必须首先创建内部类的对象。当内部类定义在外部类成员位置上且为非私有时，外部其他类访问内部类建立内部类对象要通过如下方式：外部类名.内部类名  对象名 = 外部类实例.内部类实例。即：Outer.Inner in = new Outer().new Inner();   当内部类在成员位置上时，就可以被成员修饰符所修饰。比如private：将内部类在外部类中进行封装，只能在外部类中使用。被static修饰的内部类又叫嵌套类，它具备了静态的特性，可以被外部类直接调用。并只能访问外部类中的静态成员，有一定局限性。如果内部类中有静态方法，那么内部类也要定义成静态的，当外部类中的静态方法访问内部类时，内部类也必须是static的。

       内部类定义在局部时，不可以被成员修饰符修饰，但可以直接访问外部类中的成员，因为还持有外部类中的引用。 但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。如下代码：

class Outer
{
	int x = 3;

	void show(final int a)
	{
		final int y = 4;
		class Inner
		{
			void printY()
			{
				System.out.println(y);
			}
		}	
		new Inner().printY();	
	}
}

匿名内部类顾名思义，就是没有名字的内部类，当对一个对象的方法只调用一次或将对象作为参数传给某个方法时可用匿名内部类。它有以下规定：

1，匿名内部类其实就是内部类的简写格式。
2，定义匿名内部类的前提： 内部类必须是继承一个类或者实现接口。
3，匿名内部类的格式：  new 父类或者接口(){定义子类的内容并实现继承的抽象方法}
4，其实匿名内部类就是一个匿名子类对象， 可以理解为带内容的对象。
5，匿名内部类中定义的方法最好不要超过3个，否则影响代码的阅读性。

如下就是定义一个匿名内部类的例子：

interface Inter
{
	void show();
}

class InnerClassDemo
{
	new Inter(){
		public void show(){
			System.out.println("这是一个匿名内部类");
		}
	}
}

       局限性：匿名内部类只能调用实现的接口方法或抽象类中的方法，而不能调用自己定义的方法，且只能调用一次，因为没有为对象取名字，调用结束后，对象就成了垃圾，会在以后被垃圾回收机制回收清除掉。

 

       异常

异常就是程序在运行时出现不正常情况。
异常代表遇到的一系列问题，问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述。并封装成对象。其实异常就是java对不正常情况进行描述后的对象体现。

一般将问题划分为两种：一种是严重的问题，一种非严重的问题。

对于严重的，java通过Error类进行描述。它表示恢复不是不可能但是很困难的情况下的一种眼中问题，如内存溢出等。 对于Error一般不编写针对性的代码对其进行处理，因为程序处理不了。

对于非严重的，java通过Exception类进行描述。Exception表示一种设计或实现问题，即如果程序运行正常则不会发生这种情况。对于Exception可以使用针对性的处理方式进行处理。无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。java编译器要求必须抛出程序可能发生的非运行时异常。

所有的异常都是Throwable的子类，它分为Error和Exception两种。

 

对异常的处理,java 提供了特有的语句try catch。
try
{
 需要被检测的代码；
}
catch(异常类 变量)
{
 处理异常的代码；(处理方式)
}
finally
{
 一定会执行的语句；
}

对捕获到的异常对象进行常见方法操作。String getMessage()：获取异常信息。printStackTrace（）打印栈信息，可以看到出现问题的地方，打印异常的堆栈的跟踪信息。

系统定义的异常，可在方法上直接用throws语句声明抛出，交给调用该方法的类处理，最终交给jvm。如果是自定义的异常，必须在方法内用throw语句抛出。

 

对多异常的处理

1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。
 如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

 

throws 和throw的区别：

throws用在方法上，用于声明调用这个方法可能会抛出什么异常，后面跟具体的异常名称，可以写多个，用逗号隔开。

throw用在方法内，用于抛出一个具体的异常对象，通常用来抛自定义的异常。

 

      在编译程序时可以将异常抛出，但真正开发时应该将异常补货并处理，且应该在捕获到异常后写具体的处理方式，而不要简单地只是打印一下信息。一般情况在，函数内出现异常，函数上需要声明。

 

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

 

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

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

下面是一个简单地自定义异常类：

/*  简单的自定义异常类 */
class DivBy0Exception extends Exception  // 这里必须要继承Exception
{
	private int value;

	DivBy0Exception()
	{
		super(); // 调用父类无参构造方法
	}
	DivBy0Exception(String msg,int value)
	{
		super(msg);// 调用父类的构造方法来初始化打印信息
		this.value = value;
	}

	public int getValue()
	{
		return value;
	}

}

自定义异常时，如果该异常一旦发生就无法再继续进行运行，就让自定义异常继承RuntimeException。如果在函数内容抛出该异常，函数上可以不用声明。如果在函数上声明了该异常，调用者可以不用进行处理。编译一样通过。如果异常发生，希望程序停止，对代码进行检查修改。