----------- android培训、java培训、java学习型技术博客、期待与您交流! ------------
一、内部类
概念:将一个类定义在另一个类里面,里面的那个类就称为内部类(内置类,嵌套类)
特点:而外部类要访问内部类中的成员,必须要建立内部类的对象。
访问规则
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,不可以被成员修饰符修饰2,可以直接访问外部类中的成员,为还持有外部类中的引用,但是不可以访问它所在的局部中的变量,只能访问被final修饰的局部变量。
匿名内部类
建立一个带内容的外部类或者接口的子类匿名对象
使用方法:
//1
new Object(){
void show(){
System.out.println("show run");
}
}.show();
//2
Object obj = new Object(){
void show(){
System.out.println("show run");
}
};
当函数的参数是接口类型引用时,如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。
区别:
第一个可是编译通过,并运行。
第二个编译失败,因为匿名内部类是一个子类对象,当用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内存溢出错误
}
}
当方法异常时通过throws关键字完成,格式:
throws异常类名,异常类名...
抛出异常后
处理方式有两种: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处理代码块,这样的处理有针对性,抛几个就处理几个。
特殊情况: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
自定义jar包的清单文件
jar –cvfm mypack.jar mf.txt packa packb
----------------------- android培训、java培训、java学习型技术博客、期待与您交流! ----------------------