内部类：
将一个类定义在另一个类里面，称里面那个类为内部类。
举例：
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包中的所有 类。
