内部类：

将一个类定义在另一个类里面，称里面那个类为内部类。

举例：

class Zx

{

public static void main(String []arr)

{

Outer  o = new Outer();

o.method();

}

}

class Outer

{

class Inner //内部类，可以定义多个内部类

{

void function()

{

System.out.println("inner:"+x);

}

}

int x=3;

void method()

{

System.out.println(x);

Inner in = new Inner();

in.function();

}

}

直接访问内部类中的成员：

可以在main()中 写 Outer.inner in = new Outer().new Inner();  //内部类可以被私有化，外部类不能，私有化之后不可以这样写了。

内部类访问规则

1，内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式为:外部类.this.变量名。

2，外部类要访问内部类必须建立内部类对象。

访问格式：

1，当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部类对象 ，

格式 Outer.inner in = new Outer().new Inner();

2,当内部类在成员位置上，就可以被成员修饰符修饰。

比如，private:将内部类在外部类中进行封装

static:内部类就具备了静态的特性。//无法访问非静态变量，只能访问外部类中的静态成员，优先于对象存在。

内部类定义原则

当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容。

class Body

{

private class XinZang

{

}

public void show()

{

new XinZang();

}

}

定义在方法内部的内部类，即不是成员位置

1，不可以被静态和私有修饰，仍然可以访问外部类成员变量，因为还持有外部类中的引用

class Zx

{

public static void main(String []arr)

{

new Outer().method();

}

}

class Outer

{

int x=3;

void method()

{

class Inner//不可以被静态和私有修饰，仍然可以访问外部类成员变量

{

void function()

{

System.out.println(x);

}

}

new Inner().function();

}

}

2，但是不可访问他所在的局部变量，只能访问被final修饰的局部不看了，如method中 int个y，不可与访问y

匿名内部类

1，其实是内部类简写格式。

2，定义匿名内部类的前提

内部类必须是继承一个类或者实现接口。

3，匿名内部类格式： new 父类或者接口()

{

定义子类的内容

}

4，其实匿名内部类就是一个匿名子类对象，而且对象有点胖，带内容的对象。

5，匿名内部类中定义的方法最好不要超过三个。

举例

原来：

class Zx

{

public static void main(String []arr)

{

new Outer().function();

}

}

abstract class A

{

abstract void show();

}

class Outer

{

int x=3;

class Inner extends A

{

void show()

{

System.out.println("show"+x);

}

}

public void function()

{

new Inner().show();

}

}

修改匿名后：

class Zx

{

public static void main(String []arr)

{

new Outer().function();

}

}

abstract class A

{

abstract void show();

}

class Outer

{

int x=3;

public void function()

{

new A() //A 的匿名子类对象

{

void show()

{

System.out.println("show"+x);

}

}.show();

}

}

匿名内部类练习

class Zx

{

public static void main(String []arr)

{

Test.function().method();//补全代码，运行正常

}

}

interface Inter

{

void method();

}

class Test

{

/*

static Inter  function()

{

return new Inter()

{

public void method()

{

System.out.println("111");

}

} ;

}

*/

}

异常

异常：程序运行时出现不正常情况。

异常由来：问题时java对问题进行描述，封装成对象。

对于严重的：java通过Error类进行描述。

对于Error，一般不编写针对性的代码进行处理

对于非常严重的：java通过Exception类进行描述。

对于Exception可以提供针对性代码进行处理

Throwable //父类

异常处理：

javc提供可特特有语句进行处理，格式：

try

{

需要被检测的代码

}

catch(异常类 变量)

{

处理方式

}

finally

{

一定会执行的语句

}

throws Exception //抛出问题

多异常处理

多个catch(x e)即可，x为exception的子类

并且应当把父类放在最后，以方便前面能够精确识别异常种类

catch(Exception e)

{

}

自定义异常：

将特有的问题，java没有封装的异常，进行自定义。

一般情况下，函数内部出现异常，要么在函数内部进行

try

{

}

catch()

{

}

要么在函数头throws 异常。

例如当除数是负数时，视为异常情况。

class Zx

{

public static void main(String []arr) throws Fushu \\!!

{

System.out.print(new Demo().div(3, 44));

}

}

class Fushu extends Exception

{

private String msg;

void Fushu(String msg)

{

this.msg=msg;

}

public String getMessage()

{

return msg;

}

}

class Demo

{

int div(int a,int b) throws Fushu

{

if (b<0)

throw new Fushu("出现了负数的情况");//手动通过throw抛出异常对象  //!!自定义异常

return a/b;

}

}

包

原来对类文件进行管理

可以有多层包目录

package org.crazyit.net;把类存放在该文件中 org.crazyit.net

不同包中的类互相访问。

被访问的包中的类以及类中的成员，需要public修饰

不同包中的子类还可以直接访问父类中被protected修饰的成员

包与包直接权限只有两种，public protected，默认

权限区分。

public

portected

default(默认)

private

同一个类中

ok

ok

ok

ok

同一个包中

ok

ok

ok

子类

ok

ok

不同包中

ok

一个java文件中只能产生一个public类

package.类名=新类名

不同包中的类也可继承，创建对象等等

package zxzx; //在这个包中

public class Zx {            //class必须得是public 才能被外部访问

public void show()

{

System.out.println("show ran"); //函数必须得是public 才能被外部访问

}

}

public class ArrayTool

{

private ArrayTool (){}

public static void main(String [] arr)

{

zxzx.Zx a = new zxzx.Zx(); //package.类名 为新类名

a.show();

}

}

import

为了简化类名的属性

zxzx.Zx a = new zxzx.Zx(); //package.类名 为新类名

improt zxzx.Zx；将包zxzx中的Zx 导入

可以在该类中直接写Zx a = new Zx(); 了

也可以写

improt zxzx.*;导入zxzx包中的所有 类。