您的位置：首页 > 编程语言 > Java开发

JAVASE_09天_@面向对象_内部类和异常

2014-03-04 09:26 423 查看
1.内部类
概念:-------事物中还有事物，比如容器里面有迭代器，那么将迭代器定义成内部类---内部类.......也叫内置类,嵌套类内部类大访问规则:
1.内部类可以直接访问外部类中的成员,包括私有.
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式:外部类名.this.成员
2.外部类要访问内部类,必须建立内部类对象.代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class
Outer{

private
int
x=
3
;

class
Inner{
//内部类直接访问外部类成员,包括私有

public
void
function(){

System.out.println(x);
//访问外部私有成员变量

method();//访问外部类成员方法

}

}

private
void
method(){

//第一种:外部类访问内部类必须建立内部类对象(成员函数内部)

Innerin=
new
Inner();

in.function();

}

}

public
class
Test5{

public
static
void
main(String[]args){

//第二种情况:外部类访问内部类(主函数内部)

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

oi.function();

}
}
问题:如下代码为例，引出内部类的实现机制!<1>内部类如何访问外部private成员?????<2>内部类访问局部为何要final？？？？final关键字的目的就是为了保证内部类和外部函数对变量“认识”的一致性.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public
class
OuterInnerTest{

private
int
number=
1
;

public
void
start(
int
x,
final
boolean
bool){

final
int
y=
0
;
//也是局部变量

class
Inner{
//内部类在局部

public
void
add(){

if
(bool)
//访问局部变量

System.out.println(number);
//访问私有

System.out.println(x);
//编译失败

System.out.println(bool);
//编译成功

System.out.println(y);
//编译成功,...访问内部类所在的局部变量必须final

}

}

}

}
1,首先,分析一下为什么内部类可以直接访问外部类的----1成员变量----2成员函数----3局部变量????通常一个类A要想访问另一个类B的成员,不能直接访问,先要获得B的对象,然后对象访问!解析问题:javac编译器会把Outer中Inner类编译为一个独立的class文件;其形式如下(类名为:外部类$内部类):
1
2
3
4
5
6
7
8
9
10
11
class
Outer$1Inner{

//添加的构造函数，参数为外部类对象的引用和该内部类访问的局部变量的引用（这里为boolean类型）

Outer$1Inner(Outer,
boolean
)

//内部类原有的函数

public
void
add();

//局部变量的引用

final
boolean
val$bool;

//外部类对象的引用

final
Outer
this
$
0
;

}
通过上述类的定义，我们可以看出内部类在构造的时候，会被编译器自动传入外部类对象的一个引用，同时也会传入内部类访问的局部变量的引用，这也就解释了内部类对象为什么可以访问外部类的成员变量和函数还有局部变量了2,一个类的私有方法和成员变量是不能被其他类访问的,那么内部类又是如何访问外部类的私有成员变量和函数呢?在编译时进行时，JAVA虚拟机并没有什么所谓的内部类的概念，在JAVA虚拟机看来，该内部类和外部类是两个独立的class文件;现在,外部类中有一个私有的int型的变量number,我们想在内部类中访问它。其实在编译的时候，为了内部类可以访问外部类的私有变量，JAVA编译器还偷偷做了一些额外的工作.编译器除了上文提到的会生成一个内部类class，同时还会修改我们的外部类代码。其修改如下：
1
2
3
4
5
6
7
8
class
Outer{

//编译器自动添加的函数，用来访问私有成员变量counter

static
int
access$
0
(Outer);

//原有的函数

public
void
start();

//私有成员变量

private
int
counter

}
为了访问问counter私有成员变量，编译器偷偷的为我们添加了一个access$0的静态函数，它接收一个Outer对象的引用，并返回该对象内的私有成员变量number的值并且编译器会把我们在内部类中用到number的地方都替换为Outer.access$0(this$0).3,上述2问是内部类的实现机制，现在看一下，访问局部变量为什么要求局部变量添加final关键字？现在我们看一下上面外部类的start（）函数代码的执行过程：如果bool变量不被标注为final，那么就意味着我们可以随时修改bool的值，假设我们在创建了Outer对象后修改了bool的值，那么这时我们的内部类所看到的bool的值还是之前通过构造函数传递进去的老值，这样就导致内部类和外部函数对bool值“认识”的不一致。所以final关键字的目的就是为了保证内部类和外部函数对变量“认识”的一致性。
2.静态内部类
访问格式：
1,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。
可以直接建立内部类对象。
格式
外部类名.内部类名变量名=外部类对象.内部类对象;
Outer.Innerin=newOuter().newInner();2,当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private：将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。在外部其他类中，如何直接访问static内部类的非静态成员呢？
newOuter.Inner().function();在外部其他类中，如何直接访问static内部类的静态成员呢？
outer.Inner.function();注意：当内部类中定义了静态成员，该内部类必须是static的。
当外部类中的静态方法访问内部类时，内部类也必须是static的.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class
TD{

int
y=
6
;

class
Inner{

static
int
y=
3
;

void
show()

{

System.out.println(y);

}

}

}

class
TC{

public
static
void
main(String[]args){

TD.Innerti=
new
TD().
new
Inner();

ti.show();

}

}
//编译失败，非静态内部类中不可以定义静态成员。

内部类中如果定义了静态成员，该内部类必须被静态修饰。

参考文献：
class
Outer{
private
int
x=
3
;
class
Inner{
//内部类直接访问外部类成员,包括私有
int
x=
4
;
public
void
function(){
int
x=
5
;
System.out.println(
"内部类"
+x);
//结果是5
System.out.println(
"内部类"
+
this
.x);
//结果是4
System.out.println(
"内部类"
+
Outer.
this
.x
);
//结果是3
}
}
void
method(){
//外部类访问内部类必须建立内部类
Innerin=
new
Inner();
in.function();
}
}
public
class
InnerClassDemo{
public
static
void
main(String[]args){
Outert=
new
Outer();
t.method();
//直接访问内部类中的成员.
Outer.Innerin=
new
Outer().
new
Inner();
in.function();
}
}
/*
内部类定义在局部时:

1.不可以被成员修饰符修饰
2.可以直接访问外部类中成员,因为还持有外部类中的引用
但是不可以访问它所在的局部中的变量.只能访问被final修饰的局部变量
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class
Out{

int
x=
3
;

void
method(
final
int
a){

final
int
y=
4
;
//

class
In{

void
function(){

System.out.println(x+
"---"
+y+
"---"
+a);
//注意

}

}

new
In().function();
//
//注意内部类没对象不运行，function()方法在没对象时不运行
}

}


public
class
Ty{

public
static
void
main(String[]args){

Outot=
new
Out();

ot.method(
7
);
//结果3---4---7

ot.method(
8
);
//结果3---4---8

}


}
3.内部类定义原则当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部事物的内容。4.匿名内部类
匿名内部类---
目的:简化书写,覆盖方法1.匿名内部类其实就是内部类的简写格式
2.定义匿名内部类的前提:------->内部类必须是继承一个类或者实现接口(除了Object)
3.匿名内部类的格式:new父类或者接口后(){实现接口中的方法};
4.其实匿名内部类就是以一个匿名子类对象.而且这个对象有点胖,可以理解为带内容的对象
5.匿名内部类中定义的方法最好不要超过3个
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
abstract
class
AbsDemo{

abstract
void
show();

}

class
Outer_4{

int
x=
3
;

/*

classInner_4extendsAbsDemo{

voidshow(){

System.out.println("method:"+x);

}

}

publicvoidfunction(){

newInner_4().show();

}

*/

//上面代码变成匿名内部类:

public
void
function(){

new
AbsDemo(){

void
show(){

System.out.println(
"x="
+x);

}

};
//这是一个对象,AbsDemo类的匿名子类对象

new
AbsDemo(){

void
show(){

System.out.println(
"x="
+x);

}

}.show();
//对象调用方法

}



}

public
class
InnerClassDemo4{

public
static
void
main(){

//newOuter_4().function();

}

}
什么时候会用到匿名内部类
1,当调用函数,函数参数是一个接口类型时

show(
new
InterfaceX(){

public
void
method(){

System.out.println(
"methodshowrun"
);

}

});
public
static
void
show(Interin){

in.method();

}
2,在没有父类或接口是也可以写匿名类------Object
1
2
3
4
5
6
7
8
9
10
class
InnerClassTest{

public
static
void
main(String[]args){

new
Object(){

public
void
function(){

System.out.println(
"haha"
);

}

}.function();


}

}
5.异常机制java.lang.Throwable一.体系Throwable
|--Error
|--Exception二.异常try-catch
java提供了特有的语句进行处理。1.try{需要被检测的代码；}catch(异常类变量){处理异常的代码；(处理方式)}finally{一定会执行的语句；}三，对捕获到的异常对象进行常见方法操作。
StringgetMessage()：获取异常信息。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class
Demo{

int
div(
int
a,
int
b)
throws
Exception{
//在功能上通过throws的关键字声明了该功能有可能会出现问题。

return
a/b;

}

}

class
ExceptionDemo{

public
static
void
main(String[]args){

Demod=
new
Demo();

try
{

int
x=d.div(
4
,
1
);

System.out.println(
"x="
+x);

}

catch
(Exceptione){
//Exceptione=newArithmeticException();

System.out.println(
"除零啦"
);

System.out.println(e.getMessage());
///byzero;

System.out.println(e.toString());
//异常名称：异常信息。


e.printStackTrace();
//异常名称，异常信息，异常出现的位置。

//其实jvm默认的异常处理机制，就是在调用printStackTrace方法。

//打印异常的堆栈的跟踪信息。
Stack:堆栈,Trace:追踪
}

System.out.println(
"over"
);

}

}
6.自定义异常

自定义异常：

必须是自定义类继承Exception。
继承Exception原因：

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

他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。
要么在内部trycatch处理。
要么在函数上声明让调用者处理。一般情况在，函数内出现异常，函数上需要声明
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class
FuShuException
extends
Exception{

//自定义负数异常

}

class
Demo{

public
int
div(
int
a,
int
b)
throws
FuShuException{
//

if
(b<
0
)

throw
new
FuShuException();
//手动通过throw关键字抛出一个自定义的异常对象

return
a/b;

}

}

public
class
EXceptionDemo{

public
static
void
main(String[]args){

Demod=
new
Demo();

try
{

int
x=d.div(
4
,-
1
);

System.out.println(
"x="
+x);

}

catch
(FuShuExceptione){

System.out.println(e.toString());

}

}

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

因为自定义的异常并未定义信息。
如何定义异常信息呢？

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

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

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

FuShuException(Stringmsg){

super
(msg);

}

}

class
Demo{

int
div(
int
a,
int
b)
throws
FuShuException{
//

if
(b<
0
)

throw
new
FuShuException(
"除数为负"
);
//手动通过throw关键字抛出一个自定义的异常对象

return
a/b;

}

}
*/
7.throw和throws的区别
1.throws使用在函数上...throw使用在函数内
2.throws后面跟的是异常类.可以跟多个.用逗号隔开;
throw后跟的是异常对象....throw语句后面的语句无法执行8.RuntimeExceptionExceptoin中有一个特殊的子类异常RuntimeException运行时异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过；之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
自定义异常时：如果该异常的发生，无法在继续进行运算，
就让自定义异常继承RuntimeException。
对于异常分两种：
1，编译时被检测的异常。
2，编译时不被检测的异常(运行时异常。RuntimeException以及其子类)

Exception体系包括RuntimeException体系和其他非RuntimeException的体系：①RuntimeException：RuntimeException体系包括错误类型转换、数组越界访问和试图访问空指针等等。
处理RuntimeException的原则是：如果出现RuntimeException，那么一定是程序员的错误。
例如，可以通过检查数组下标和数组边界来避免数组越界访问异常。②其他非RuntimeException（IOException等等）：这类异常一般是外部错误，
例如试图从文件尾后读取数据等，这并不是程序本身的错误，而是在应用环境中出现的外部错误。
*/
*************************************************************************

1.NullPointException
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class
Person{

public
void
checkName(Stringname){

if
(name.equals(
"root"
))
//当name传的值是null时,无法调用函数发生空指针异常NullPointException

//修改为:if("root".equals(name))

//相当于if(name!=null&&name.equals("root"))

System.out.println(
"YES"
);

else

System.out.println(
"NO"
);

}

}


public
class
ExceptionDemo4{

public
static
void
main(String[]args){

Personp=
new
Person();

p.checkName(
null
);
//发生异常

}

}
练习:毕老师用电脑上课(分层思想)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
package
day09;

/*

*毕老师用电脑上课

*

*电脑运行时可能发生的异常:1.BlueScreen2.冒烟

*/

class
BlueScreenException
extends
Exception{

BlueScreenException(Stringmsg){

super
(msg);

}

}

class
SomkingException
extends
Exception{

SomkingException(Stringmsg){

super
(msg);

}

}

class
Computer{

private
int
state=
3
;
//电脑的状态

public
void
run()
throws
BlueScreenException,SomkingException{

if
(state==
2
)

throw
new
BlueScreenException(
"蓝屏了"
);

if
(state==
3
)

throw
new
SomkingException(
"冒烟了"
);

System.out.println(
"电脑运行"
);

}

public
void
reset(){

state=
1
;

System.out.println(
"电脑重启"
);

}

}

class
NoPlanException
extends
Exception{

NoPlanException(Stringmsg){

super
(msg);

}

}

class
Teacher{

private
Stringname;

private
Computercpt;

Teacher(Stringname){

this
.name=name;

cpt=
new
Computer();

}

public
void
prelect()
throws
NoPlanException{

try
{

cpt.run();

}

catch
(BlueScreenExceptione){

System.out.println(e.getMessage());

cpt.reset();

}

catch
(SomkingExceptione){

throw
new
NoPlanException(
"课时无法继续_原由:"
+e.getMessage());

}

System.out.println(
"老师上课"
);

}

}

public
class
ExceptionTest{

public
static
void
main(String[]args){

Teachert=
new
Teacher(
"毕老师"
);

try
{

t.prelect();

}
catch
(NoPlanExceptione){

System.out.println(e.toString());

System.out.println(
"换老师或者放假!"
);

}

}

}

                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航