-------------Android培训、java培训、期待与您交流------------
第1讲 内部类
1.1、内部类定义
将一个类定义在另一个类的里面,对里面那个 类就称为内部类(内置类,嵌套类)。
内部类的访问规则:
1、内部类可以直接访问外部类中的成员,包括私有。
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式 外部类名.this
2、外部类要访问内部类,必须建立内部类对象。
1.2、访问格式
1、当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。
可以直接建立内部类对象。
格式:
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
2、当内部类在成员位置上,就可以被成员修饰符所修饰。
比如,private:将内部类在外部类中进行封装。
static:内部类就具备static的特性。
当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?
new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?
Outer.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。
当外部类中的静态方法访问内部类时,内部类也必须是static的。
内外部类成员变量访问,程序如下:
<span style="font-size:14px;">class Outer
{
private int x = 3;
class Inner
{
int x = 4;
void function()
{
int x =6;
System.out.println("x="+x);//内部类局部变量 6
System.out.println("x="+this.x);//内部类成员变量 4
System.out.println("x="+Outer.this.x);//外部类成员变量 3
}
}
void method()
{
Inner in = new Inner();
in.function();
}
}
class InnerFace
{
public static void main(String[] args)
{
Outer out = new Outer();
out.method();
//Outer.Inner in = new Outer().new Inner();//直接访问内部类成员
//in.function();
}
}</span>
运行结果:
当描述事物时,事物的内部还有事物,该事物用内部类来描述。
因为内部事物在使用外部事物的内容。
<span style="font-size:14px;">class Outer
{
private static int x = 3;
static class Inner1//静态内部类
{
static void function()
{
System.out.println("inner1:"+x);
}
}
static class Inner2
{
void show()
{
System.out.println("inner2 show:"+x);
}
}
public static void method()
{
Inner1.function();//访问static内部类静态成员
new Inner2().show();
}
}
class InnerFace
{
public static void main(String[] args)
{
Outer.method();
Outer.Inner1.function();//在外部其他类中访问static内部类中的静态成员
new Outer.Inner2().show();//在外部其他类中访问static内部类中的非静态成员
}
}</span>
执行结果:
内部类定义在局部时,
1、不可以被成员修饰符修饰
2、可以直接访问外部类中的成员,因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
1.3、匿名内部类
匿名内部类:
1、匿名内部类其实就是内部类的简写格式。
2、定义匿名内部类的前提:
内部类必须是继承一个类或者实现接口。
3、匿名内部类的格式: new 父类或者接口(){定义子类的内容}
4、其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。
5、匿名内部类中定义的方法最好不要超过3个。
定义匿名内部类与调用,程序如下:
<span style="font-size:14px;">abstract class AbsDemo
{
abstract void show();
}
class Outer
{
int x=3;
public void function()
{
//匿名内部类
AbsDemo d = new AbsDemo()
{
int num = 9;
void show()
{
System.out.println("num==="+num);
}
void abc()
{
System.out.println("haha");
}
};
d.show();
//d.abc();//编译失败
}
}
class InnerFace
{
public static void main(String[] args)
{
new Outer().function();
}
}</span>
执行结果:
第2讲 异常
2.1、异常概念
异常:就是程序在运行时出现不正常情况。
异常由来:问题也是现实生活中一个具体的事物,也可以通过java的类的形式进行描述。并封装成对象。
其实就是java对不正常情况进行描述后的对象体现。
对于问题的划分:两种:一种是严重的问题,一种非严重的问题。
对于严重的,java通过Error类进行描述。
对于Error一般不编写针对性的代码对其进行处理。
对与非严重的,java通过Exception类进行描述。
对于Exception可以使用针对性的处理方式进行处理。
2.2、异常体系
异常体系:
Throwable
|--Error
|--Exception
|--RuntimeException
Throwable
Error
通常出现重大问题如:运行的类不存在或者内存溢出等。不编写针对代码对其处理
Exception
在运行时运行出现的一起情况,
java 提供了特有的语句进行处理。
异常处理3种格式
第一个格式:
try
{
}
catch ()
{
}
第二个格式:
try
{
}
catch ()
{
}
finally
{
}
第三个格式:
try
{
}
finally
{
}
2.3、throws和throw
throws用于标识函数暴露出的异常。
throw用于抛出异常对象。
throws与throw的区别:
thorws用在函数上,后面跟异常类名。
throw用在函数内,后面跟异常对象。
Throwable中的方法
getMessage()
获取异常信息,返回字符串。
toString()
获取异常类名和异常信息,返回字符串。
printStackTrace()
获取异常类名和异常信息,以及异常出现在程序中的位置。返回值void。
printStackTrace(PrintStream s)
通常用该方法将异常内容保存在日志文件中,以便查阅。
异常处理基本方法如下下例:
<span style="font-size:14px;">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,0);
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");
}
}</span>
执行结果:
在函数上声明异常。
便于提高安全性,让调用出进行处理。不处理编译失败。
2.4、对多异常的处理
1、声明异常时,建议声明更为具体的异常。这样处理的可以更具体。
2、对方声明几个异常,就对应有几个catch块。不要定义多余的catch块。
如果多个catch块中的异常出现继承关系,父类异常catch块放在最下面。
进行catch处理时,catch中一定要定义具体处理方式。
不要简单定义一句 e.printStackTrace(),
也不要简单的就书写一条输出语句。
多异常处理方式如下:
<span style="font-size:14px;">class Demo
{
int div(int a,int b)throws ArithmeticException,ArrayIndexOutOfBoundsException//在功能上通过throws的关键字声明了该功能有可能会出现问题。
{
int[] arr = new int[a];
System.out.println(arr[4]);
return a/b;
}
}
class ExceptionDemo
{
public static void main(String[] args)
{
Demo d = new Demo();
try
{
int x = d.div(2,0);
System.out.println("x="+x);
}
/*
catch(Exception e)
{
System.out.println("hahah:"+e.toString());
}
*/
catch (ArithmeticException e)
{
System.out.println(e.toString());
System.out.println("被零除了!!");
}
catch (ArrayIndexOutOfBoundsException e)
{
System.out.println(e.toString());
System.out.println("角标越界啦!!");
}
System.out.println("over");
}
}</span>
执行结果:
2.5、自定义异常
因为项目中会出现特有的问题,而这些问题并未被java所描述并封装对象。
所以对于这些特有的问题可以按照java的对问题封装的思想。将特有的问题。进行自定义的异常封装。
当在函数内部出现了throw抛出异常对象,那么就必须要给对应的处理动作。
要么在内部try catch处理,要么在函数上声明让调用者处理。
一般情况下,函数内出现异常,函数上需要声明。
自定义异常:
必须是自定义类继承Exception。
继承Exception原因:
异常体系有一个特点:因为异常类和异常对象都需要被抛出。
他们都具备可抛性。这个可抛性是Throwable这个体系中独有特点。
只有这个体系中的类和对象才可以被throws和throw操作。
throws和throw的区别
throws使用在函数上。后面跟的异常类。可以跟多个。用逗号隔开。
throw使用在函数内。后跟的是异常对象。
定义异常信息:
因为父类中已经把异常信息的操作都完成了。
所以子类只要在构造时,将异常信息传递给父类通过super语句。
那么就可以直接通过getMessage方法获取自定义的异常信息。
自定义异常如下:
除数为负数时抛出异常
<span style="font-size:14px;">class FuShuException extends Exception //getMessage();
{
private int value;
FuShuException()
{
super();
}
FuShuException(String msg,int value)
{
super(msg); //因为父类中已经把异常信息的操作都完成了。所以子类只要在构造时,将异常信息传递给父类通过super语句。
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 ExceptionDemo
{
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");
}
}</span>
执行结果:
对于异常分两种:
1、编译时被检测的异常。
2、编译时不被检测的异常(运行时异常。RuntimeException以及其子类)
RunTimeException
Exceptoin中有一个特殊的子类异常RuntimeException 运行时异常。
如果在函数内容抛出该异常,函数上可以不用声明,编译一样通过。
如果在函数上声明了该异常。调用者可以不用进行处理。编译一样通过;
之所以不用在函数声明,是因为不需要让调用者处理;
当该异常发生,希望程序停止。因为在运行时,出现了无法继续运算的情况,希望停止程序后,对代码进行修正。
自定义异常时:如果该异常的发生,无法在继续进行运算,就让自定义异常继承RuntimeException。
finally代码块:定义一定执行的代码。通常用于关闭资源。
<span style="font-size:14px;">class NoException extends Exception
{
}
public void method()throws NoException
{
连接数据库;
数据操作;//throw new SQLException();
关闭数据库;//该动作,无论数据操作是否成功,一定要关闭资源。
try
{
连接数据库;
数据操作;//throw new SQLException();
}
catch (SQLException e)
{
会对数据库进行异常处理;
throw new NoException();
}
finally
{
关闭数据库;
}
}</span>
异常在子父类覆盖中的体现;
1、子类在覆盖父类时,如果父类的方法抛出异常,那么子类的覆盖方法,只能抛出父类的异常或者该异常的子类。
2、如果父类方法抛出多个异常,那么子类在覆盖该方法时,只能抛出父类异常的子集。
3、如果父类或者接口的方法中没有异常抛出,那么子类在覆盖方法时,也不可以抛出异常。
如果子类方法发生了异常。就必须要进行try处理。绝对不能抛。
异常试题:
有一个圆形和长方形。
都可以获取面积。对于面积如果出现非法的数值,视为是获取面积出现问题,设计程序获取面积,并解决异常。
长方形的长和宽大于0;
圆的半径大于0
<span style="font-size:14px;">class NoValueException extends RuntimeException
{
NoValueException(String message)
{
super(message);
}
}
interface Shape
{
void getArea();
}
class Rec implements Shape
{
private int len,wid;
Rec(int len ,int wid)//throws NoValueException
{
if(len<=0 || wid<=0)
throw new NoValueException("出现非法值");
this.len = len;
this.wid = wid;
}
public void getArea()
{
System.out.println(len*wid);
}
}
class Circle implements Shape
{
private int radius;
public static final double PI = 3.14;
Circle(int radius)
{
if(radius<=0)
throw new NoValueException("非法");
this.radius = radius;
}
public void getArea()
{
System.out.println(radius*radius*PI);
}
}
class ExceptionTest
{
public static void main(String[] args)
{
Rec r = new Rec(5,3);
r.getArea();
Circle c = new Circle(-3);
System.out.println("over");
}
}</span>
执行结果:
长方形的长和宽是合法的,圆的半径不合法,是需要解决的异常。