内部类:将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)
访问特点:a,内部类可以直接访问外部类中的成员,包括所有成员
b,而外部类要访问内部类中的成员必须要建立内部类的对象
一般用于类的设计
分析事物时,发现该事物描述中还有事物,而且这个事物还在访问被描述事物的内容
这时,就是还有的事物定义成内部类来描述
内部类修饰符:
static void function ( )//如果内部类中定义了静态成员,该内部类也必须是静态的
{
system .out.println ("funtion run +++"+num);
}
内部类的细节:为什么内部类能直接访问外部类中的成员呢?
那是因为内部类持有了外部类的引用,外部类名.this
内部类——局部内部类
内部类可以存放在局部位置上
内部类在局部位置上只能访问局部中被final 修饰的局部变量
匿名 内部类:就是内部类的简写格式
必须有前提:内部类必须继承或者实现一个外部类或者接口
匿名内部类;其实就是一个匿名子类对象
匿名内部类——应用
通常的使用场景之一;当函数参数是接口类型时,而且接口中的方法不超过三个
可以匿名内部类作为实际参数进行传递
匿名内部类细节;
主函数静态不能在非静态中 static
public void method ( )
{
this.new Lnnet( );
}
异常
* 异常的体系
*Throwable
*Error
a,通常出现重大问题如,运行的类不存在或者内存溢出等
b,不编写针对代码对其处理
*Exception
a,在运行时运行出现的一起情况,可以通过 try catch finally
* Exception和Error的子类名都是以父类名作为后缀
异常:是在运行时期发生不正常情况
在java中用类的形式对不正确情况进行了描述和封装对象
描述不正常的情况的类,就称为异常类
以前正常流程代码和问题处理代码分离,提高阅读性
其实异常就是java通过面向对象的思想将问题封装成了对象
用异常类对其进行描述 不同的问题用不同的类进行具体的描述 比如角标越界 空指针等等
异常体系;问题很多,意味着描述的类很多
将其共性进行向上抽取,形成了异常体系
最终问题(不正常情况)就分成了两大类
Throwable:无论是Error,还是异常,问题,问题发生就应该可以抛出,让调用者知道并处理
该体系的特点就在于Throwable及其所有的子类都具有可抛性
可抛性到底指的什么呢?怎么体现可抛性呢?其实是通过两个关键字来体现的
throws throw,凡是可以被这两个关键字 所操作的类和对象都具备可抛性
1——1,一般不可处理的Error
特点:是由Jvm抛出的严重性的问题
这种问题发生一般不针对性处理。直接修饰程序
1——2,可以处理的,Exception
该体系的特点:子类的后缀名都是用其父类名作为后缀,阅读性很强
异常——自定义异常&异常类的抛出throws
对于角标是整数不存在,可以用角标越界表示
对于负数为角标的情况,准备用负数的角标异常来表示
负数角标这种异常在java中并没有定义过
那就按照java异常的创建思想,面向对象,将负数角标进行自定义描述,并封装成对象
这种自定义的问题描述成为自定义异常
注意:如果让一个类称为异常类,必须要继承异常体系,因为只有称为异常体系的子类,才有资格具备可抛性。才可以被两个关键字所操作,throws,throw
异常:编译时,检测异常和运行时异常的区别&throw和throws的区别
异常的分类:1,编译时被检测异常,只要是Exception和其子类都是除了特殊子类runtime Exception体系,这种问题一旦出现,希望在编译时就进行检测,让这种问题有对应的处理方式,这样的问题都可以针对性的处理
2,编译时不检测异常(运行时异常)就是Exception中的Runtime Excetion和其子类
这种问题的发生,无法让功能继续,,运算无法进行,更多是因为调用者的原因导致的或者引发了内部状态的改变导致的,那么这种问题一般不处理,直接编译通过,在运行时,让调用者调用时的程序强制停止,让调用者对代码进行修正
所有的自定义异常时,要么继承Exception,要么继承runtime Exception
throws和throw区别
1,throws使用在函数上,throw使用在函数内
2,throws抛出的是异常类,可以抛出多个,用逗号隔开
throw抛出的是异常对象
面向对象(异常——异常捕捉 try catch)
异常处理的捕捉形式:
这是可以对异常进行针对性处理方式
具体格式:
try
{
//需要被检测异常的代码
}
catch(异常类 变量)//该变量用于接收发生的异常对象
{
//处理异常的代码
}
finally
{
//一定会被执行的代码
}
异常——异常处理原则:
1,函数内容如果抛出需要检测的异常,那么函数上必须声明,否则必须在函数内用try catch捕捉,否则编译失败
2,如果调用到了声明异常的函数,要么try catch 要么throws,否则编译失败
3,什么时候catch什么时候throws呢?
功能内容可以解决,用catch
解决不了,用throws告诉调用者,由调用者解决
4,一个功能如果抛出了多个异常,那么调用时,必须有多个catch进行针对性处理 内部又几个需要检测异常,就抛几个异常,抛出几个,就catch几个
try catch finally 代码块组合特点;
1,try catch finally
2,try catch (多个)当没有必要资源需要释放时,可以不用定义finally
3,try finally 异常无法直接catch处理,但是资源需要关闭
void show ( )throws Exception
{
try
{
//开启资源
throw new Exception( );
}
finally
{
//关闭资源
}
/*
catch (Exception e)
{
}
*/
}
异常注意事项:
a,子类再覆盖父类方法时,父类的方法如果抛出了异常,那么子类的方法只能抛出父类的异常或者该异常的子类
b,如果父类抛出多个异常,那么子类只能抛出父类异常的子类
简单说:子类覆盖父类只能抛出父类的异常或者子类或者子集
注意:如果父类的方法没有抛出异常,那么子类覆盖时绝对不能抛,就只能try
包(package)
a,对象文件进行分类管理
b,给类提供多层命名空间
c,写在程序文件的第一行
d,类名的全称的包名,类名
e,包也是一种封装形式
pack mypack:
class package Demo
{
public static void main (string[ ]args)
{
system.out.printLn("Hello package!”);
}
}
包与包之间访问——protected
package mypack;
class package Demo
{
public static void main (string[ ]args)
{
packa.DemoA d=new.acka.emoA( );
d.show( );
pack b.DemoB b=new packb.Demo B( );
b.method( );
system.out.printLn("Hello package!”);
}
}
总结;包与包之间的访问,被访问的包中的类必须是public,被访问的包中的类的方法也必须是public的
包——导入import
package mypack;
//import packa.DemoA;//导入了packa包中的DemoA类
//import packa.DemoAA;
/*import packa.*;//导入了packa包中所有的类
import packa.abc.*;
packa\DemoA.class
packa\abc\DemoAbc.class
*/
//导包原则:用到哪个类就导入哪个类
import 干嘛用的啊?为了简化类名书写