黑马程序员_内部类与异常

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

内部类

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

内部类的访问规则:

1.内部类可以直接访问外部类中的成员.包括私有.

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

2.外部类要访问内部类.必须要建立内部类对象.
访问格式:

1.当内部类定义在外部类的成员位置上.而且非私有,可以在外部类其他类中

可以直接建立内部类对象.

格式

外部类名.内部类名 变量名=new外部类对象.new内部类对象

Outer.Inner in=new Outer().new Inner();

2.当内部类在成员位置上,就可以被成员修饰符所修饰.

比如,private:将内部类在外部类中进行封装.

static:内部类就具备static的特性

当内部类被static修饰后.只能直接访问外部类中的static成员.出来了访问局限.

在外部类其它类中如何直接访问static内部类的非静态成员呢?

new Outer.Inner().function();

在外部其它类中,如何直接访问static内部类的静态成员呢?

uter.Inner.function();

注意:当内部类中定义了静态成员.该内不类必须是static.

*/

示例:

class Outer//外部类
{
private int x=3;//外部成员变量
class Inner//内部类
{
int x=4;//内部成员变量
void function()
{
int x=5;//内部局部成员变量.
System.out.println(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();//调用function()方法
*/
}
}

内部类定义在局部时，

1，不可以被成员修饰符修饰

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。

但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

class Outer//外部类
{
int x = 3;//成员变量
void method(final int a)
{
final int y = 4;//被final修饰的常量
class Inner//局部内部类
{
void function()
{
//只能方法被final修饰的常量因为.
//因为一常量在常量池比方法存在的时间长.
System.out.println(y);
}
}
//如果放在上面编译失败.因为虚拟机还不知道有内部类Inner呢.
new Inner().function();
}
}
class  InnerClassDemo3
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method(7);
out.method(8);
}
}

匿名内部类:

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

2，定义匿名内部类的前提：

内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}

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

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

示例:

abstract class AbsDemo//父类
{
abstract void show();
}
class Outer外部类
{
int x = 3;
public void function()
{
//匿名内部类
AbsDemo d = new AbsDemo()
{
int num = 9;
void show()
{
System.out.println("num==="+num);
}
void abc()
{
System.out.println("haha");
}
};
d.show();
//d.abc();//编译失败;
}
}
class InnerClassDemo4
{
public static void main(String[] args)
{
new Outer().function();
}
}

异常：

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

异常由来：

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

其实就是java对不正常情况进行描述后的对象体现。

对于问题的划分：两种：一种是严重的问题，一种非严重的问题。

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

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

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

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

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

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

异常体系：

Throwable

|--Error

|--Exception

|--RuntimeException

异常体系的特点：

异常体系中的所有类以及建立的对象都具备可抛性。

也就是说可以被throw和throws关键字所操作。

只有异常体系具备这个特点。

异常有两种：

1.编译时被检测异常

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

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

2.运行时异常(编译时不检测)

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

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

异常处理语句：

try

{

需要被检测的代码；

}

catch ()

{

处理异常的代码；

}

finally

{

一定会执行的代码；

}

有三个结合格式：

1. try

{

}

catch ()

{

}

2. try

{

}

finally

{

}

3. try

{

}

catch ()

{

}

finally

{

}

注意：

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

2，finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

异常的处理:

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

try

{

需要被检测的代码；

}

catch(异常类 变量)

{

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

}

finally

{

一定会执行的语句；

}

对捕获到的异常对象进行常见方法操作:

String getMessage()：获取异常信息。

在函数上声明异常。

便于提高安全性，让调用出进行处理。不处理编译失败。

对多异常的处理:

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

2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。

如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。

建立在进行catch处理时，catch中一定要定义具体处理方式。

不要简单定义一句 e.printStackTrace(),

也不要简单的就书写一条输出语句。

自定义异常:

因为项目中会出现特有的问题，

而这些问题并未被java所描述并封装对象。

所以对于这些特有的问题可以按照java的对问题封装的思想。

将特有的问题。进行自定义的异常封装。

当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。

要么在内部try catch处理。

要么在函数上声明让调用者处理。

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

发现打印的结果中只有异常的名称，却没有异常的信息。

因为自定义的异常并未定义信息。

如何定义异常信息呢？

因为父类中已经把异常信息的操作都完成了。

所以子类只要在构造时，将异常信息传递给父类通过super语句。

那么就可以直接通过getMessage方法获取自定义的异常信息。

自定义异常：

必须是自定义类继承Exception。

继承Exception原因：

异常体系有一个特点：因为异常类和异常对象都被抛出。

他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。

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

throw和throws的用法：

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。

注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上可以不用声明。

异常的好处：

1，将问题进行封装。

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

异常的处理原则：

1，处理方式有两种：try 或者 throws。

2，调用到抛出异常的功能时，抛出几个，就处理几个。

一个try对应多个catch。

3，多个catch，父类的catch放到最下面。

4，catch内，需要定义针对性的处理方式。不要简单的定义printStackTrace，输出语句。

也不要不写。

当捕获到的异常，本功能处理不了时，可以继续在catch中抛出。

try

{

throw new AException();

}

catch (AException e)

{

throw e;

}

如果该异常处理不了，但并不属于该功能出现的异常。

可以将异常转换后，在抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，

当调用者知道。并处理。也可以将捕获异常处理后，转换新的异常。

try

{

throw new AException();

}

catch (AException e)

{

// 对AException处理。

throw new BException();

}

异常示例:

毕老师用电脑上课

假如出现了问题.比如冒烟.蓝屏.

class LanPingException extends Exception//自定义蓝屏异常.因为可以处理集成Exception
{
LanPingException(String Message)//覆盖父类的方法
{
super(Message);//因为父类有赋值方法.直接用就OK了
}
}
class MaoYanException extends Exception//自定义冒烟
{
MaoYanException(String Message)
{
super(Message);
}
}
class NoPlanException extends Exception//课时计划完不成.讲师的异常
{
NoPlanException(String Message)
{
super(Message);
}
}
class Computer//电脑类
{
private int count=3;//定义一个变量为1的时候正常.2的时候代表蓝屏.3.冒烟
void run()throws LanPingException,MaoYanException//run电脑启动
{
if(count==2)
throw new LanPingException("蓝屏");//抛出蓝屏异常,不在这里处理是因为电脑自身处理不了
if(count==3)
throw new MaoYanException("冒烟");

System.out.println("电脑启动");
}
void reset()//电脑重启.重启之后count变量为1.电脑正常运行
{
System.out.println("电脑从启");
count=1;
}
}
class Teachar//讲师类.毕老师
{
private String name;//将名字设为私有
private Computer comp;//电脑类私有
Teachar(String name)
{
this.name=name;//用构造函数.将name和电脑computer初始化
comp=new Computer();
}

void prelect()throws NoPlanException
{
try//因为电脑处理不了异常.所以在这里try
{
comp.run();
}
catch (LanPingException e)
{
comp.reset();//蓝屏之后调用从启方法
}
catch (MaoYanException e)
{
test();//冒烟之后启动自习.因为解决不了.所以抛给张老师
throw new NoPlanException("课程无法继续"+e.getMessage());
}

System.out.println("讲课");
}
void test()
{
System.out.println("自习");
}
}
class ExceptionTest
{
public static void main(String[] args)//主函数.也代表Boss
{
Teachar t=new Teachar("毕老师");//创建Teachar对象并让毕老师讲课
try
{
t.prelect();//因为电脑冒烟了.毕老师蒙圈了.问题交给boss张老师来处理
}
catch (NoPlanException e)
{
System.out.println(e.toString());
System.out.println("换老师或者放假");
}

}
}

示例2:

/*

有一个圆形和长方形。

都可以获取面积。对于面积如果出现非法的数值，视为是获取面积出现问题。

问题通过异常来表示。

现有对这个程序进行基本设计。

*/

class NoValueException extends RuntimeException//自定义异常继承了并RuntimeException
{
NoValueException(String message)
{
super(message);
}
}

interface Shape//定义一个接口.共性方法面积抽象的
{
void getArea();
}
class Rec implements Shape//长方形实现Shape接口
{
private int len,wid;//将长宽私有化
Rec(int len ,int wid)//用构造函数将长宽初始化.因为继承了RuntimeException所以在方法上不用抛了
{
if(len<=0 || wid<=0)//判断长和宽是否出现负数如果是.就抛NoValueException异常
throw new NoValueException("出现非法值");
this.len = len;//
this.wid = wid;
}
public void getArea()//覆盖接口中的方法求面积 长乘宽
{
System.out.println(len*wid);
}
}
class Circle implements Shape//圆
{
private int radius;
public static final double PI = 3.14;//给园定义一个final修饰的常量

Circle(int radius)//给圆进行初始化.并且判断是否半径为负数
{
if(radius<=0)
throw new NoValueException("非法");
this.radius = radius;
}
public void getArea()//覆盖接口的方法求面积.
{
System.out.println(radius*radius*PI);
}
}
class  ExceptionTest1
{
public static void main(String[] args)
{
Rec r = new Rec(3,4);//创建Rec对象
r.getArea();//求面积方法
Circle c = new Circle(-8);
System.out.println("over");
}
}

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