----------------------class="Apple-converted-space">?android开发、java培训、期待与您交流！ ----------------------
?
1.内部类
?1.1什么是内部类？
?
??将一个类定义在另一个类的里面，对里面的那个类就称为内部类（内置类，嵌套类）。
?
??把类1定义到类2内部有什么好处呢？
?
??
?如果把类1定义到外面的话，类2要用类1的功能属性什么的是不是要先
创建类1的对象然后
?
??
?才能调用类1中的东西啊，而把类1定义到类2中的话，要访问类1的内的东西，就不用创建
?
??
?对象了。
?
?内部类访问规则：
?
??比如说孙悟空是个类，牛魔王也是个类，孙悟空要访问牛魔王的心脏，是不是要先获得牛魔王
?
??的对象，然后再调用牛魔王的get心脏方法。但是如果孙悟空飞进了牛魔王的肚子里面，是不是
?
??就能直接访问牛魔王这个类里面的东西啦？包括其私有的东西。这时候孙悟空就是个内部类，
?
??牛魔王是外部类，孙悟空能直接访问牛魔王的类里的东西，而牛魔王要想访问孙悟空的心脏，是
?
??不是要先获得孙悟空的对象啊，然后才能访问它的心脏。
?
?
??内部类访问规则：
?
??1.内部类可以直接访问外部类成员，包括私有的；之所以能访问是因为省略了 “外部类名.this”
?
??2.外部类访问内部类需建立内部类对象
?
?
?内部类访问格式：
?
??当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。
?
??格式为：外部类名.内部类名 ?变量名 = 外部类对象.内部类对象;
?
??
??
??
??
??Outer.Inner in = new Outer().new Inner();
??
?
??部分代码：
?
??class Outer
?
??{
?
??
?int x=3;
?
??
?void method()
?
??
?{
?
??
??
?Inter in = new Inter();//外部类访问内部类需建立内部类对象
?
??
??
?in.show();//调用内部类中方法
?
??
?}
?
??
?class Inter//内部类
?
??
?{
?
??
??void show()
?
??
??{
?
?//内部类可以直接访问外部类中的成员
?
?System.out.println("inter"+x);//打印外部类中成员变量x，同下句
?
?System.out.println("inter"+Outer.this.x);//其实是省略了外部类名.this.
?
??
??}
?
??
?}
?
??}
?
??class InnerClassDemo
?
??{
?
??
?public static void main(String[] args)?
?
??
?{
?
??
??
?
??
?//在外部其他类中直接访问内部类的成员
?
??
?//Inner in = new Inner();这样不行，因为如果另一个类中也有一个名为Inner的内部类，
?
??
??
??
??
??
??
??
??
??
??
??
??//这样写是不是就不知道这个Inner是哪个类中的内部类啦？
?
??
??
??Outer.Inter in = new Outer().new Inter();//所以要这样创建，指出是哪个类的内部类
?
??
??
??in.show(); //创建内部类对象，直接调用它的方法。 ?
?
??
?}
?
??}
?
?1.2 静态内部类：
?
?a.成员内部类
?
??当内部类在成员位置上，就可以被成员修饰符所修饰。比如：
?
??
?private：将内部类在外部类中进行封装。
?
??
?static:当内部类被static修饰后,它就具备了static的特性，能直接被外部类的类名调用，
?
??
??
??
?并且只能直接访问外部类中的static成员。出现了访问局限。
?
?
??
?在外部其他类中，如何直接访问static内部类的非静态成员呢？
?
??
??new Outer.Inner().
function();
?
??
?因为是静态的了，所以能直接被外部类的类名调用，Outer.Inner()是内部类了，一new就行了。
?
?
??
?在外部其他类中，如何直接访问static内部类的静态成员呢？
?
??
?Outer.Inner.function();直接内部类类名调用
?
?
??
?注意：当内部类中定义了静态成员，该内部类必须是static的。
?
??
??
??当外部类中的
静态方法访问内部类时，内部类也必须是static的。
?
??部分代码如下：
?
??class Outer
?
??{
?
??
?static int x=8;
?
??
?static class Inter//当内部类中的方法有静态成员时，内部类也一定为静态
?
??
?{
?
?static void show()//当内部类被static修饰后,只能直接访问外部类中的static成员
?{
System.out.println(x);
?}
?
??
?}
?
??
?static void show()//当外部类的静态方法访问内部类时，内部类也必须为静态的
?
??
?{
?Inter in = new Inter();
?in.show();
?System.out.println("dangligedang ");
?
??
?}
?
??}
?
??class ?OutClassDemo2
?
??{
public static void main(String[] args)?
{
//当静态内部类种方法为非静态时，要先创建内部类对象，在调用内部类中的非静态方法
?new Outer.Inter().show();
//如果内部类中的方法为静态的，下面这种写法可以。
?Outer.Inter.show();
}
?
??}
?
??内部类定义规则：
?
??
?当描述事物时，事物的内部还有事物，该事物用内部类来描述。因为内部事务在使用外部
?
??
?事物的内容。
?
?b.局部内部类
?
?内部类定义在局部时，
?
??1，不可以被成员修饰符修饰，就把局部类当做一个局部变量，它是不需要被修饰符修饰的
?
??2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
?
??
?但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
?
??部分代码：
?
??class Outer
?
??{
?
??
?int x = 3;
?
??
?void method(final int a)
?
??
?{
?final int y = 4;
?new Inner().function(); //这句只能放局部内部类下面，从上往下读，读到这还没内部类呢
?class Inner//局部类不能被成员修饰符修饰
?{
?
?void function()
?
?{
?
??System.out.println(x);//能直接访问外部类的成员
?
??System.out.println(y);//不能直接访问内部类所在局部的变量，除非被final修饰
?
?}
?}
?new Inner().function(); //创建内部类对象，调用其方法
?
??
?}
?
1.3.匿名内部类
?
?匿名内部类是指没有指定类名的内部类，当某个类不需要重复使用时，就可以把该类定义为匿名内部类，
?
?由于匿名内部类没有类名所以在程序中你只能使用一次。
?
?
??匿名内部类:
?
??
?1，匿名内部类其实就是内部类的简写格式。
?
??
?2，定义匿名内部类的前提：
?
??
??内部类必须是继承一个类或者实现
接口。
?
??
?3，匿名内部类的格式： ?new 父类或者接口(){定义子类的内容}
?
??
?4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以
理解为带内容的对象。
?
??
?5，匿名内部类中定义的方法最好不要超过3个。
?
?
?部分代码：
?
??abstract class AbsDemo
?
??{
?
??
?abstract void show();
?
???
?
??}
?
??class Outer
?
??{
?
??
?int x = 3;
?
?
??
?
?
??
?public void function()
?
??
?{
?//Inner in = new Inner();
?//in.show();
?new AbsDemo()//定义一个匿名内部类
?{
?
?void show()
?
?{
System.out.println("这里实现了接口中的方法");
?
?}
?}.show();//调用内部类中的show()方法。
?
??
?}
?
??}
----------------------------------------------------------------------------------------------------------------------------------------------------
2.
异常
?1.什么是异常？
?
??异常就是程序在运行时出现不正常情况。
?
??
??异常由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述并封装
?
??成对象。其实就是java对不正常情况进行描述后的对象体现。
?
??
?
??对于问题的划分：两种：一种是严重的问题，一种非严重的问题。
?
??对于严重的，java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
?
??对与非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。
?
??无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。
?
??
?2.异常的处理格式：
?
??try
?
??{
?
??
?需要被检测的代码；
?
??}
?
??catch(异常类 变量)
?
??{
?
??
?处理异常的代码；(处理方式)
?
??}
?
??finally
?
??{
?
??
?一定会执行的语句；如关闭资源，IO流什么的
?
??}
?
?
??3，对捕获到的异常对象进行常见方法操作。
?
??Throwable中的方法
?
??
?getMessage()获取异常信息，返回字符串。
?
??
?toString()获取异常类名和异常信息，返回字符串。 ?
??
??
?
??
?printStackTrace()获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。 ?
??
?
??
?printStackTrace(PrintStream s)通常用该方法将异常内容保存在日志文件中，以便查阅。
?
?3.声明异常 throws
?
?在函数上声明异常。便于提高
安全性，让调用出进行处理。不处理编译失败。
?
?
?部分代码：
?
?class Demo//3.所以这个程序的编写者要考虑到这一点
?
?{
?
?//5.所以这时候编写者就要在这声明一下说，这个功能使用时可能会出现问题你在用时要注意一下
?
??int div(int a,int b)throws Exception//6.通过throws声明该功能可能会出问题，但是我解决
?
??{ ?
??
??
??
?//不了,就抛给了使用者让使用者去处理
return a/b;//4.你写的这个程序中有除法功能,但是别人在用你写的这个功能时，人家往里
//传什么你是不知道的，所以要考虑到使用者有可能往里传除数为0的情况
?
??} ?
??
?
?}
?
?class ?ExceptionDemo
?
?{
?
??public static void main(String[] args) //throws Exception ?8.或抛
?
??{
Demo d = new Demo();
?//2.但是可处理可不处理,因为你
用别人写的div功能时,根本就不知道这个功能会不会发生问题,你怎
?//么处理,你用到的每一个功能会不会有问题你都不知道，你不会都挨个处理一遍吧
try
{
//7.这时候人家给你标出来了这个功能可能会出问题，使用者用时就要注意了，或try或抛
?int x = d.div(4,1);//1.使用者传参数的时候可能会使程序停掉，比如除数为0
?System.out.println("x="+x);
}
catch (Exception e)//Exception e = new ArithmeticException();
{
System.out.println("除零啦");
} ?
System.out.println("over");
}
?
?}
?
?4.多
异常处理
?
?在定义功能的时候，有时会
发现这个功能可能出现的问题不止一个。
?
?
?在进行多异常处理时应注意：
?
?1，声明异常时，建议声明更为具体的异常。这样处理的可以更具体。
?
?2，对方声明几个异常，就对应有几个catch块。不要定义多余的catch块。如果多个catch块
?
??中的异常出现继承关系，父类异常catch块放在最下面。
?
?
?建立在进行catch处理时，catch中一定要定义具体处理方式。不要简单定义一句 e.printStackTrace(),
?
?也不要简单的就书写一条输出语句。
?
?5.
自定义异常
?
?因为项目中会出现特有的问题，比如在你设计的功能中，除数也不能为负数。而这种情况并没有被
?
?java所描述，这样的话就要自己定义了。
?
?所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题进行自定义的异常封装。
?
?
?当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作。要么在内部try catch处理。
?
?要么在函数上声明让调用者处理。一般情况下，函数内出现异常，函数上需要声明。
?
?
?如何定义异常信息呢？
?
??因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时，将异常信息传递给父类通过
?
??super语句。那么就可以直接通过getMessage方法获取自定义的异常信息。
?
?
?总之，在自定义异常的时候，那个自定义类，要继承Exception或者其子类。并且通过
构造函数自定义
?
?异常信息，然后通过throw将自定义异常抛出。
?
??例如：
?
??
?class FuShuException extends Exception //自定义异常
?
??
?{
?FuShuException(String msg)//通过构造函数自定义异常信息
?{
?
?super(msg);//因为父类中都定义好了，直接拿来用就行了
?}
?
??
?}
?
?
??
?class Demo
?
??
?{
?int div(int a,int b)throws FuShuException//在函数上声明抛出
?{
?
?if(b<0)//手动通过throw
关键字抛出一个自定义异常对象。
?
?throw new FuShuException("出现了除数是负数的情况");
?
?return a/b;
?}
?
??
?}
?
?
??
?class ?ExceptionDemo3
?
??
?{
?public static void main(String[] args)?
?{
?
?Demo d = new Demo();
?
?try//捕获异常并进行处理
?
?{
?
??int x = d.div(4,-9);
?
??System.out.println("x="+x); ?
?
?}
?
?catch (FuShuException e)
?
?{
?
??System.out.println(e.toString());
?
?}
?}
?
??
?}
?
?
?
??throw与throws的区别是什么？
?
??
?throw用于抛出一个异常类对象，通常用于自定义异常类情况，如throw new MyException().
?
??
??并且是在函数内使用。它后面跟的是异常对象。
?
??
?throws则是在方法声明时告诉调用者该方法会抛出哪些异常,而异常的捕获处理交给调用者
?
??
??去处理。throws使用在函数上，它后面跟的是异常类。可以跟多个，用逗号隔开。
?
??
?当函数内容有throw抛出异常对象，并未进行try处理。必须要在函数上声明，都在编译失败。
?
?
??
?注意，RuntimeException除外。也就说，函数内如果抛出的RuntimeExcpetion异常，函数上
?
??
?可以不用声明。
?
??
?
?6.运行时异常：RuntimeException
?
??异常有两种：
?
??
?编译时被检测异常
?
??
??该异常在编译时，如果没有处理(没有抛也没有try)，编译失败。该异常被标识，代表
?
??
??这可以被处理。
?
??
?运行时异常(编译时不检测 RuntimeException以及其子类)
?
??
??在编译时，不需要处理，编译器不检查。该异常的发生，建议不处理，让程序停止。
?
??
??需要对代码进行修正
?
?
??如果在函数内抛出RuntimeException异常，函数上可以不用声明，编译一样通过。
?
??如果在函数上声明了RuntimeException异常。调用者可以不用进行处理。编译一样通过；
?
?
??之所以不用在函数声明，是因为不需要让调用者处理。当该异常发生，希望程序停止。因为在
?
??运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
?
?
??自定义异常时：如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException。
?
?
??部分代码：
?
??class Demo
?
??{
?
??//3.编写者的意思就是当调用者传入的参数非法时就让程序停下来，这样就没必要把异常抛给调用者了
int div(int a,int b)//throws ArithmeticException4.因为抛的意思就是让调用者知道哪错了，
{ ?
??
??
??
??
??
??
??
??//然后让调用者去处理
//1.在写这个功能发现调用者可能传入非法参数,这时就抛出一个运行时异常ArithmeticException
?if(b==0)//2.抛这种异常的意思是,你敢传非法参数我就敢让程序停下来,你传对了再继续用
?
?throw new ArithmeticException ("被零除啦");
?return a/b;
}
?
??}
?
??class ExceptionDemo4?
?
??{
public static void main(String[] args)?
{ ?
?Demo d = new Demo();
//5.这样调用者就不知道这个功能有异常,他也就不会进行try处理了
?int x = d.div(4,0);//6.这样的话当调用者传除数为0的时候，能编译成功，但是会运行出错
?
?//调用者想要程序运行成功，这时就必须传一个正确的数了
?System.out.println("x="+x); ?
}
?
??}
?
?
?异常体系：
?
??Throwable
?
??
?|--Error
?
??
?|--Exception
?
??
??|--RuntimeException
?
?
?异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和
?
??
??
?throws关键字所操作。只有异常体系具备这个特点。
?
??
???
?
?异常的好处：
?
??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();
?
?}
?
?
?异常的注意事项：
?
??异常在子父类覆盖中的体现；
?
??
?1，子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法，只能抛出父类的
?
??
??异常或者该异常的子类。
?
??
?2，如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
?
??
?3，如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。
?
??
??如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。
?
?部分代码：
?
class Fu
{
void show()throws AException
{
}
}
class Test
{
void function(Fu f)
{
try
{
f.show();
}
catch (AException e)
{
}
}
}
class Zi extends Fu
{
void show()throws CException
{
}
}
class
{
public static void main(String[] args)
{
Test t = new Test();
t.function(new Zi());
}
}
?
?
----------------------?android开发、java培训、期待与您交流！ ----------------------
相关文章
