黑马程序员--------java面向对象 内部类、异常

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------

内部类

1、 将一个类定义在另一个类里面，对里面那个类就称为内部类。
2、 访问特点：
*内部类可以直接访问外部类中的成员，包括私有成员。这是因为内部类中持有了一个外部类的引用，格式：外部类名.this
*当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象，如在主函数中
主函数中直接建立内部类的对象：Outer.Inner in =new Outer().new Inner();
格式：外部类名.内部类名 变量名 = new 外部类名().new 内部类名();
*而外部类要访问内部类中的成员必须要建立内部类的对象
3、当内部类在外部类的成员位置上时，可以被成员修饰符所修饰。
例如：private：将内部类在外部类中进行封装
static：内部类就具备static特性
4、 当内部类被静态修饰后，只能直接访问外部类中的静态成员了，出现访问局限。
5、 外部其它类中，如何直接访问static内部类的非静态成员呢？
new Outer.Inner().function(); function为内部类非静态方法
6、 外部其它类中，如何直接访问static内部类的静态成员呢？使用频率低
Outer.Inner.function(); function为内部类静态方法（类名.函数名()）
7、 当内部类中定义了静态成员，该类必须是静态的；当外部类中的静态方法访问内部类时，内部类也必须是静态的
8、 什么时候定义内部类呢？
当描述事物时，事物内部还有事物，该事物用内部类描述，因为内部事物在使用外
事物的内容
9、 内部类定义在局部（定义在外部类的成员函数里面）时
*不可以被成员修饰符修饰
*可以直接访问外部类中的成员，因为还持有外部类中的引用；访问所在的局部变量时，这个局部变量必须声明为final型


匿名内部类

1、 匿名内部类就是内部类的简写格式
2、 定义匿名内部类的前提：内部类必须继承一个类或者接口
3、 匿名内部格式： new 父类或者接口(){ 定义子类方法 }
4、 其实匿名内部类其实就是一个子类对象，可以理解为带内容的对象
调用匿名内部类子类方法：new 父类或者接口(){ 定义子类方法 }.子类方法();
5、 匿名内部类中定义的方法最好不要超过3个

练习：InnerClassTest 内部类补足代码

/*

Test.function().method();

分析：Test.function()  类名.方法名() 表示function是一个静态的方法
      .method() function这个方法运算完后是一个对象，而且是一个Inter类型的对象 
      因为只有inter类型的对象才能调用method方法
*/
interface Inter
{
	void method();
}
class Test
{
	//补足代码，通过匿名内部类
	public static Inter function()
	{
		return new Inter()
		{
			public void method()
			{
				System.out.println("hehe");
			}
		};
	}
}

class InnerClassTest
{
	public static void main(String[] args) 
	{
		Test.function().method();
	}
}

异常机制：

1、异常的体系：
*Throwable：
--Error：通常重大问题，运行的类不存在或者内存溢出，不编写针对代码对其处理
--Exception：在运行时出现的一些情况，可以通过try catch finally 处理
2、Exception和Error的子类名都是以父类名作为后缀
3、定义：异常就是程序运行时出现的不正常情况
4、异常的由来：问题也是现行生活中一个具体事物，也可以同java的类的形式进行描述，并封装成对象，其实就是java对不正常情况进行描述后的对象体现。

5、异常的处理：java提供特有的语句进行处理
Try{需要被检测的代码；} catch(异常类 变量){处理异常的代码} finally{一定会执行的语句}
6、对捕获到的异常对象进行常见操作方法。
String getMessage（）：获取异常信息
String toString（）
7、如代码有发生异常的可能，需要在函数上声明异常 throws 异常名称， 便于提高安全性，让调用者进行处理，不处理编译就失败。
8、对多异常的处理.
1）声明异常时，建议声明更为具体的异常，这样处理的可以更具体
2）对方声明几个异常，就对应有几个catch块，不要定义多余catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面
9：注意事项:
1）在进行catch处理时，catch中一定要定义具体的处理方式
2）不要简单定义一句e.printStaticTrace()，也不要简单的就写一条输出语句


自定义异常
1、因为项目中会出现特有问题，而这些问题并没有被java所描述并封装对象，所以对于这些特有的问题可以按照java对问题封装的思想，将特有问题进行自定义的异常封装
2、自定义异常：必须是自定义类继承Exception
原因：异常体系有一个特点，因为异常类和异常对象都被抛出，它们都具可抛性，这个可抛性是Throwable这个体系中独有特点，只有这个体系中的类和对象才可以被throws和throw操作。
3、throws和throw的区别：
1）throws使用在函数上，throw在函数内
2）throws后面跟异常类，可以多个，用逗号隔开；throw后面跟的是异常对象

4、Exception中有一个特殊的子类异常RuntimeException——运行时异常。
特点：1、如果在函数内抛出该异常，函数上可以不用声明，编译一样通过
2、如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过
原因：之所以不用在函数上声明，是因为不需要让调用者处理，当该异常发生。希望程序停止。因为在运行
5、自定义异常时：如果该异常的发生，无法继续运算，就让该异常继承RuntimeException
6、对于异常分为两种“
1）编译时被检测的异常
2）编译时不被检测的异常（运行时异常—RuntimeException以及其子类）

实例：

/*
毕老师用电脑讲课

名称提炼法：毕老师讲课 毕老师有属性
            电脑功能：电脑运行和电脑重启
            会发生的异常：如电脑蓝屏、电脑冒烟，需要对这些异常进行处理
            当电脑发生冒烟了，会导致毕老师课时无法完成，这时需要向上级抛出这个异常，让上级处理 
*/
class LanpinException extends Exception
{
	private String msg;
	LanpinException(String msg)
	{
		super(msg);
	}
}
class MaoyanException extends Exception
{
	private String msg;
	MaoyanException(String msg)
	{
		super(msg);
	}
}
class NoplanException extends Exception
{
	private String msg;
	NoplanException(String msg)
	{
		super(msg);
	}
}
class Computer
{
	void run()
	{
		System.out.println("电脑运行");
	}
	void restart()
	{
		System.out.println("电脑重启");
	}
}
class Teacher
{
	private String name;
	Computer comp ;
	Teacher(String name)
	{
		this.name=name;
		comp = new Computer();
	}
	public void jiangke()throws NoplanException
	{
		int flag=3;
		try
		{
			if(flag==1)
				comp.run();
			else if(flag==2)
				throw new LanpinException("电脑蓝屏了，需要重启");
			else if(flag==3)
				throw new MaoyanException("电脑冒烟了，求救总部");
		}
		catch (LanpinException e)
		{
			System.out.println(e.toString());//打印蓝屏故障信息
			flag=1;
			comp.restart();
		}
		catch (MaoyanException e)
		{
			
			throw new NoplanException("无法继续上课   "+e.getMessage());

		}
		System.out.println("开始讲课");
	}

}
class ExceptionTest
{
	public static void main(String[] args)
	{
		Teacher t = new Teacher("毕老师");
		try
		{
			t.jiangke();
		}
		catch (NoplanException e)
		{
			System.out.println(e.toString());
			System.out.println("换老师或者放假");
		}
	}
}

7、Finally的用法：发生异常一定会执行语句
8、记住一点：catch是用于处理异常，如果没有catch就代表异常没有被处理，如果该异常是检测时异常，那么徐必须声明

三：异常在子父类中的体现
1、子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类
2、如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集
3、如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可抛出异常。如果子类方法发生了异常，就必须进行try处理，绝对不能抛

练习：长方形和圆面积

/*
计算长方形和圆的面积，
思路：当出现输入负数或者0的时候提示非法数据,出现了面积问题
      使用RuntimeException
	  面积是长方形和圆的基本属性，可以进行向上抽取共性面积

*/
class NovalueException extends RuntimeException
{
	NovalueException(String msg)
	{
		super(msg);
	}
}
abstract class Area
{
	abstract void getArea();
}
class Rec extends Area
{
	int len,wid;
	Rec(int len,int wid)
	{
		if(len<=0||wid<=0)
			throw new NovalueException("输入了非法数值");
		this.len=len;
		this.wid=wid;
	}
	public void getArea()
	{
		System.out.println(len*wid);
	}
}
class Circle
{
	private static final double PI=3.14;
	private int radius;
	Circle(int radius)throws RuntimeException
	{
		if(radius<=0)
			throw new NovalueException("半径非法");
		this.radius=radius;
	}
	public void getArea()
	{
		System.out.println(radius*PI);
	}
}
class ExceptionTest2
{
	public static void main(String[] args)
	{
		Rec r = new Rec(3,4);
		r.getArea();
		Circle c = new Circle(-5);
		c.getArea();
	}
}

四：异常总结
1、好处：将问题进行封装
将正常流程代码和问题处理代码相分离，方便于阅读
2、当捕获到的异常，本功能处理不了时，可以继续在catch中抛出
try
{
throw new AException();
}
catch (Aexception e)
{
Throw e
}
3、如果该异常处理不了，但并不属于该功能出现的异常，可以将异常换换后，再抛出和该功能相关的异常，或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道和处理。也可以将捕获到的异常处理后转换为新的异常
示例：毕老师用电脑讲课
try
{
Throw new Aexception ();
}
catch(Aexception e)
{
//或者在抛之前对Aexception处理
throw new Bexception();
}

-----------android培训、java培训、java学习型技术博客、期待与您交流！------------