------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流! -------
一、内部类
概念:将一个类定义在另一个类里面,里面的那个类就称为内部类(内置类,嵌套类)
特点:而外部类要访问内部类中的成员,必须要建立内部类的对象。
访问规则
1,内部类可以直接访问外部类中的成员,包括私有。之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式外部类名.this
2,外部类要访问内部类,必须建立内部类对象。
3,内部类可以被私有修饰,当内部类在外部类的成员变量上时。
1,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。
可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();//这种形式很少用。
- class Outer
- {
- private static int x = 3;
- static class Inner//静态内部类
- {
- static void function()
- {
- System.out.println("innner :"+x);
- }
- }
- public static void method()
- {
- Inner.function();
- new Inner2().show();
- }
- }
- class InnerClassDemo2
- {
- public static void main(String[] args)
- {
- Outer.method();
- Outer.Inner.function();
- new Outer.Inner().function();
- //直接访问内部类中的成员。
- Outer.Inner in = new Outer().new Inner();
- in.function();
- }
- }
2,当内部类在成员位置上,就可以被成员修饰符所修饰。
比如,private:将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后,相当于外部类。只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?
new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?
uter.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。
当外部类中的静态方法访问内部类时,内部类也必须是static的。
3,内部类定义在局部时,
a) 不可以被成员修饰符修饰
b) 可以直接访问外部类中的成员,因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
内部类编译后的文件名为:“外部类名$内部类名.java”;
- class Outer
- {
- private int x = 3;
- class Inner//内部类
- {
- //int x = 4;
- void function()
- {
- //int x = 6;
- System.out.println("innner :"+Outer.this.x);
- }
- }
- void method()
- {
- Inner in = new Inner();//创建内部类的对象。
- in.function();//调用内部类的方法
- }
- }
匿名内部类
建立一个带内容的外部类或者接口的子类匿名对象
使用方法:
- //1
- new Object(){
- void show(){
- System.out.println("show run");
- }
- }.show();
- //2
- Object obj = new Object(){
- void show(){
- System.out.println("show run");
- }
- };
区别:
第一个可是编译通过,并运行。
第二个编译失败,因为匿名内部类是一个子类对象,当用Object的obj引用指向时,就被提升为了
Object类型,而编译时检查Object类中是否有show方法,所以编译失败。
匿名类代码范例:
- interface Inter
- {
- void method();
- }
- class Test
- {
- //补足代码。通过匿名内部类。
- /*
- static class Inner implements Inter
- {
- public void method()
- {
- System.out.println("method run");
- }
- }
- */
- static Inter function()
- {
- return new Inter()
- {
- public void method()
- {
- System.out.println("method run");
- }
- };
- }
- }
- class InnerClassTest
- {
- public static void main(String[] args)
- {
- //Test.function():Test类中有一个静态的方法function。
- //.method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。
- //因为只有是Inter类型的对象,才可以调用method方法。
- Test.function().method();
- // Inter in = Test.function();
- // in.method();
- show(new Inter()
- {
- public void method()
- {
- System.out.println("method show run");
- }
- });
- }
- public static void show(Inter in)
- {
- in.method();
- }
- }
- class InnerTest
- {
- public static void main(String[] args)
- {
- new Object()//object子类对象。没有接口没有父类。还可以写匿名类吗?可以,
- {
- public void function()
- {
- }
- }.function();
- }
- }
二、异常
异常:就是java按照面向对象的思想将问题进行对象封装。这样就方便于操作问题以及处理问题。
出现的问题有很多种,比如角标越界,空指针等都是。就对这些问题进行分类。而且这些问题都有共性内容比如:每一个问题都有名称,同时还有问题描述的信息,问题出现的位置,所以可以不断的向上抽取。形成了异常体系。
对于异常问题有两种:
1,严重的,java通过Error类进行描述。对于Error一般不编写针对性的代码对其进行处理。
2,非严重的,java通过Exception类进行描述。
Throwable:可抛出的。
|--Error:错误,一般情况下,不编写针对性的代码进行处理,通常是jvm发生的,需要对程序进行修正。
|--Exception:异常,可以有针对性的处理方式
可抛性的体现:就是这个体系中的类和对象都可以被throws和throw两个关键字所操作
- class ExceptionDemo{
- public static void main(String[] args) {
- byte[] buf = new byte[1024*1024*700];//java.lang.OutOfMemoryError内存溢出错误
- }
- }
抛出异常后
处理方式有两种:1、捕捉;2、抛出。
对于捕捉:java有针对性的语句块进行处理。
try
{
需要被检测的代码;
}
catch(异常类 变量)
{
处理异常的代码;(处理方式)
}
finally
{
一定会执行的语句;
}
finally代码块只有一种情况不会被执行,就是在之前执行了System.exit(0);
对捕获到的异常对象进行常见方法操作(Throwable中的方法)
String getMessage():获取异常信息,返回字符串
toString();获取异常类名和异常信息,返回字符串。
printStackTrace();获取异常类名和异常信息,以及异常出现在程序中的位置,返回值void.
printStackTrace(PrintStream s);通常用该方法将异常内容保存在日志文件中,以便查阅。
在函数上声明异常,便于提高安全性,让调用出进行处理。不处理编译失败。
- class Demo
- {
- int div(int a,int b)throws Exception//在功能上通过throws的关键字声明了该功能有可能会出现问题。
- {
- return a/b;
- }
- }
- class ExceptionDemo
- {
- public static void main(String[] args)
- {
- Demo d = new Demo();
- try
- {
- int x = d.div(4,1);
- System.out.println("x="+x);
- }
- catch (Exception e)//Exception e = new ArithmeticException();
- {
- System.out.println("除零啦");
- System.out.println(e.getMessage());// / by zero;
- System.out.println(e.toString());// 异常名称 : 异常信息。
- e.printStackTrace();//异常名称,异常信息,异常出现的位置。
- //其实jvm默认的异常处理机制,就是在调用printStackTrace方法。
- //打印异常的堆栈的跟踪信息。
- }
- System.out.println("over");
- }
- }
特殊情况:try对应多个catch时,如果有父类的catch语句块,一定要放在下面。
throw 和throws关键字的区别:
throw用于抛出异常对象,后面跟的是异常对象;throw用在函数内。
throws用于抛出异常类,即用于标识函数暴露出的异常。后面跟的异常类名,可以跟多个,用逗号隔开。throws用在函数上。
异常分两种:
1:编译时被检查的异常,只要是Exception及其子类都是编译时被检测的异常。
2:运行时异常,其中Exception有一个特殊的子类RuntimeException,以及RuntimeException的子类是运行异常,也就说这个异常是编译时不被检查的异常。
编译时被检查的异常和运行时异常的区别:
编译被检查的异常在函数内被抛出,函数必须要声明,否编译失败。
声明的原因:是需要调用者对该异常进行处理。
运行时异常如果在函数内被抛出,在函数上不需要声明。
不声明的原因:不需要调用者处理,运行时异常发生,已经无法再让程序继续运行,所以,不让调用处理的,直接让程序停止,由调用者对代码进行修正。
定义异常处理时,什么时候定义try,什么时候定义throws呢?
功能内部如果出现异常,如果内部可以处理,就用try;
如果功能内部处理不了,就必须声明出来,让调用者处理
自定义异常
定义:当开发时,项目中出现了java中没有定义过的问题时,这时就需要我们按照java异常建立思想,将项目的中的特有问题也进行对象的封装
步骤:
1,自定义类继承Exception或者其子类。
继承Exception原因:异常体系有一个特点:因为异常类和异常对象都被抛出。他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。只有这个体系中的类和对象才可以被throws和throw操作。
2,通过构造函数定义异常信息
class FuShuExceptionextends Exception//getMessage();
{
FuShuException()
{
super();
}
}
3,通过throws或throw进行自定义异常抛出操作。
范例
- class FuShuException extends Exception //getMessage();
- {
- private int value;
- FuShuException()
- {
- super();
- }
- FuShuException(String msg,int value)
- {
- super(msg);
- this.value = value;
- }
- public int getValue()
- {
- return value;
- }
- }
- class Demo
- {
- int div(int a,int b)throws FuShuException
- {
- if(b<0)
- throw new FuShuException("出现了除数是负数的情况------ / by fushu",b);//手动通过throw关键字抛出一个自定义异常对象。
- 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());
- //System.out.println("除数出现负数了");
- System.out.println("错误的负数是:"+e.getValue());
- }
- System.out.println("over");
- }
- }
如果出现异常,并不处理,但是资源一定关闭,所以try finally集合只为关闭资源。
finally很有用,主要用户关闭资源。无论是否发生异常,资源都必须进行关闭。
System.exit(0); //退出jvm,只有这种情况finally不执行。
如果父类或者接口中的方法没有抛出过异常,那么子类是不可以抛出异常的,如果子类的覆盖的方法中出现了异常,只能try不能throws。
如果这个异常子类无法处理,已经影响了子类方法的具体运算,这时可以在子类方法中,通过throw抛出RuntimeException异常或者其子类,这样,子类的方法上是不需要throws声明的。
常见异常:
1、脚标越界异常(IndexOutOfBoundsException)包括数组、字符串;
空指针异常(NullPointerException)
2、类型转换异常:ClassCastException
3、没有这个元素异常:NullPointerException
4、不支持操作异常;
throw和throws的用法:
throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象,并未进行try处理。必须要在函数上声明,都在编译失败。
注意,RuntimeException除外。也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。
异常处理语句:
try
{
需要被检测的代码;
}
catch ()
{
处理异常的代码;
}
finally
{
一定会执行的代码;
}
异常的处理原则:
1,处理方式有两种:try或者throws。
2,调用到抛出异常的功能时,抛出几个,就处理几个。
一个try对应多个catch。
3,多个catch,父类的catch放到最下面。
4,catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。也不要不写。当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。
try
{
thrownew AException();
}
catch (AExceptione)
{
throwe;
}
三、包
包:对类文件进行分类管理,给类提供多层命名空间,写在程序文件的第一行,类名的全称的是包名.类名,包也是一种封装形式。
包之间的访问
被访问的包中的类权限必须是public的。
类中的成员权限:public或protected。
protected是为其他包中的子类提供的一种权限。只能是不同包中的子类可以使用的权限。
import 导入的是包中的类。建议,不要写通配符 *,需要用到包中的哪个类,就导入哪个类。
public protected default private
同一个类中 ok ok ok ok
同一个包中 ok ok ok
子类 ok ok
不同包中 ok
Jar包:Java的压缩包,方便项目的携带。方便于使用,只要在classpath设置jar路径即可。
数据库驱动,ssh框架等都是以jar包体现的。
Jar包的操作
通过jar.exe工具对jar的操作。
创建jar包
jar –cvf mypack.jar packa packb
查看jar包
jar –tvf mypack.jar [>定向文件]
解压缩
jar –xvf mypack.jar