-------android培训、java培训、期待与您交流！ ----------
1.内部类
定义：将一个类定义在另一个类的里面，对里面那个类就称为内部类。
内部类的访问规则：
(1).内部类可以直接访问外部类中的成员，包括私有成员 。之所以可以直接访问外部类的成员，是因为内部类中持有了一个外部类的引用，格式为：外部类名.this
(2).外部类要访问内部类，必须建立内部类对象。
(3).当内部类在成员位置上，就可以被成员修饰符所修饰。比如：private、static等等
示例：
class
Outer{
int
x
= 9;
class
Inner{
public
void
show(){
System.
out
.println(
"内部类"
);
}
}
public
void
method(){
Inner in =
new
Inner();
in.show();
}
}
public
class
Demp {
public
static
void
main(String[] args) {
Outer ou =
new
Outer();
ou.method();
}
}
如果要直接访问内部类的话可以这么写：Outer.Inner in = new Outer().new Inner();(前提是内部类不是private修饰)
静态内部类：
只能直接访问外部类中的static成员，有访问局限。在外部其他类中，直接访问静态内部类的非静态成员格式为：new Outer.Inner().方法名。访问静态成员格式为：Outer.Inner.方法名。
注：(1).当内部类中定义了静态成员时，内部类必须为静态内部类。
(2).当外部类中的静态方法访问内部类时，内部类也必须是static的。
内部类定义在局部时：
(1).不可以被成员修饰符所修饰。
(2).可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
2.匿名内部类
(1).匿名内部类其实就是内部类的简写形式。
(2).定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。
(3).匿名内部类的格式：new 父类或者接口(){定义子类的内容}
(4).其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
(5).匿名内部类中定义的方法最好不要超过3个。不然定义和调用的时候，可读性差。
示例：
abstract
class
Rrr{
abstract
void
show();
}
class
Outerr{
int
temp
= 5;
/*class InnerT extends Rrr{
void show(){
System.out.println("内部类");
}
}*/
public
void
via(){
new
Rrr(){
//这是一个子类对象
void
show(){
System.
out
.println(
"匿名内部类"
);
}
}.show();
//new InnerT().show();
}
}
public
class
InnerCast {
public
static
void
main(String[] args) {
Outerr ou =
new
Outerr();
ou.via();
}
}
注：如果上面代码也可以写成：
public
void
via(){
Rrr r =
new
Rrr(){
void
show(){
System.
out
.println(
"匿名内部类..."
+
temp
);
}
};
r.show();
}
实际上利用的是多态，左边的父类，右边是子类。如果子类里面有个单独的方法，则不能用父类的引用来调用子类单独的方法。
3.异常
a.
(1).对于问题的划分：严重的问题和非严重的问题。
(2).对于严重的：java通过Error类进行描述。对于Error不编写针对性的代码处理。
对于非严重的：java通过Exception类进行描述。
(3).Error和Exception的父类是Throwable。
(4).其实JVM处理异常信息就是调用PrintStackTrace()方法来打印异常的堆栈信息。
(5).除了使用try...catch来处理异常之外，还可以用throws Exception来抛出异常。
(6).格式：try...catch、 try...catch...finally、 try...finally
(7).catch是处理异常的，没有catch语句，则不算处理异常。
(8).finally语句：只有在finally语句之前，执行了System.exit(0);则finally语句不执行。
b.
在函数上声明异常。
便于提高安全性，让调用者进行处理。不处理则编译失败。（如果在其他函数中用throws Exception，则在其调用的函数中必须提出解决异常的方法。要么抛出这个异常，要么try...catch处理这个异常。如果一直是抛出这个异常，一直到主方法中还抛出时，这时是给JVM解决。）
c.
对多异常的处理：
(1).声明异常时，建议声明更为具体的异常，这样处理更具体。
(2).对方声明几个异常，就有几个对应catch块，不要定义多余catch块。如果多个catch块中出现的异常出现继承关系，父类异常catch块放在最下面。
(3).建议在进行catch处理时，catch中一定要定义具体处理方式。不要写e.PrintStackTrace()方法，也不要简单打印一句输出语句。可以建立一个硬盘日志文件记录异常信息。
(4).当捕获到的异常，本功能处理不好时，可以继续在catch中抛出。
try{
}catch(Exception e){
throws new bException();
}
如果该异常处理不了，但并不属于该功能出现的异常。可以将异常转换后，再抛出和该功能相关的异常。
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去。让调用者知道，并处理。也可以将捕获异常处理后，转换新的异常。
d.
自定义异常：
(1).当在函数内部出现throw抛出异常对象，就必须给出对应的处理动作。要么在内部try...catch进行处理。要么在函数上进行声明，让调用者处理。
(2).一般情况下，在函数内出现异常，函数上需要声明。
(3).如何定义异常信息？
因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句。那么就可以直接通过getMessage方法获取自定义的异常类信息。
必须是自定义类继承Exception
原因：因为异常类和异常对象都被抛出，它们都具备可抛性。这个可抛性是throwable这个体系中的独有特点，只有这个体系中的类和对象才可以被throws和throw操作
例子：
class
MyException
extends
Exception{
public
MyException(String msg){
super
(msg);
}
}
class
Demo{
int
divide(
int
a,
int
b)
throws
MyException{
if
(b<0){
throw
new
MyException(
"被除数不能为负数"
);
//手动通过throw来抛出异常
}
return
a/b;
}
}
public
class
MyExTest {
public
static
void
main(String[] args) {
Demo d =
new
Demo();
try
{
int
x = d.divide(5, -1);
System.
out
.println(
"x="
+x);
}
catch
(MyException me){
System.
out
.println(me.toString());
}
}
}
自定义异常时，如果该异常发生，无法再继续进行运算，就让自定义异常继承RuntimeException。
e.
throw和throws的区别：
(1).throws使用在函数上，throw使用在函数内
(2).throws后面跟的是异常类，可以跟多个，用逗号给开。throw后跟的是异常对象。
记住：throw单独存在时，下面不要定义语句，因为执行不到。其功能跟return或者break相似。
f.
RuntimeException异常：
如果在函数内抛出该异常或其子类异常，函数上可以不用处理，编译一样通过。
如果在函数上声明该异常或其子类异常，调用者可以不用进行处理，编译一样通过。
原因：之所以不用在函数上声明，是因为不需要调用者处理。当该异常发生，希望程序停止。因为在运行时，出现了无法继续运算的情况。
g.
异常在子父类覆盖中的体现：
(1).子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常，或该异常的子类。
(2).如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
(3).如果父类或者接口的方法中没有异常抛出时，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生异常，就必须要进行try处理，绝对不能抛。
扫一扫
99
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
