对象数组
所谓的对象数组，就是指包含了一组相关的对象，但是在对象数组使用时应注意：数组一定要先开辟空间，但是因为其实引用数据类型，所以数组里面的每个对象都是null值，则在使用数组中的每个对象必须分别进行实例化操作。
对象数组的声明：
格式：类 数组名[ ] =new 类[数组长度]; //此时数组中每个对象的值都是默认值，为null
对象数组的动态实例化
动态实例化跟数组的声明格式是一样的，都是通过new关键字来声明，代码如下：
class Person
{
private String name;
public Person(String name){
this.name=name;
}
public String getName(){
return name;
}
}
public class ObjectArrayDemo01
{
public static void main(String args[]){
System.out.println("-----对象数组声明之前------");
Person per[]=new Person[3]; //声明一个对象数组，都是默认值 为null
for(Person x:per){ //循环输出
System.out.println(x);
}
System.out.println("-----对象数组声明之后------");
//为对象数组动态赋值
per[0]=new Person("张三");
per[1]=new Person("李四");
per[2]=new Person("王五");
for(Person x:per){ //循环输出
System.out.println(x.getName());
}
}
}当一个对象为null时，调用其方法会抛出java.lang.NullPointerException，所以上面代码在为数组实例化之前打印的是对象，因为里面每个对象都是Null，调用getName()方法会出异常。
对象数组的静态实例化
对象数组的静态初始化值跟普通数组是一样的，如以下代码：
class Person
{
private String name;
public Person(String name){
this.name=name;
}
public String getName(){
return name;
}
}
public class ObjectArrayDemo02
{
public static void main(String args[]){
Person per[]={new Person("张三"),new Person("李四"),new Person("王五")};; //为对象数组静态初始化 与普通数组一样
for(Person x:per){ //循环输出
System.out.println(x.getName());
}
}
}内部类
·在类的内部也可以定义另外一个类，如果在类Outer的内部再定义一个类， Inner，此时类Inner就称为内部类，而类Outer称为外部类。
·内部类可声明为public或private。当内部类声明成public活private时，对其访问的限制与成员变量和成员方法完全相同。
·内部类的定义格式：
标识符 class 外部类名称{
//外部类成员
标识符 class 内部类名称{
//内部类的成员
}
}内部类定义代码如下：
class Outer
{
private String info="hello world!"; //声明外部类成员变量
class Inner
{
public void getInfo(){ //内部类方法
System.out.println(info); //可以直接访问外部类的私有属性
}
}
public void fun(){ //外部类通过实例化内部类调用其方法
new Inner().getInfo();
}
}
public class InnerClassDemo01
{
public static void main(String args[]){
Outer out=new Outer();
out.getInfo();
}
}内部类存在的特点：
·缺点：
正常的一个类操作时，在类中最好只定义属性和方法。如果定义一个类的话，则肯定破坏了程序的结构。
·优点：
使用内部类最大的优点就是可以方便的访问外部的私有属性。
使用static声明内部类
如果一个内部类使用static关键字声明，则此内部类就可以称为是外部类，可以直接通过 外部类.内部类 进行访问。
class Outer
{
private static String info="hello world!"; //声明外部类成员变量
static class Inner
{
public void getInfo(){ //内部类方法
System.out.println(info); //可以直接访问外部类的私有属性
}
}
public void fun(){ //外部类通过实例化内部类调用其方法
new Inner().getInfo();
}
}
public class InnerClassDemo02
{
public static void main(String args[]){
new Outer.Inner().getInfo(); //由外部类名.内部类进行访问
}
}注意：此时访问的外部类的属性也必须是static类型的
外部类访问普通内部类
假如内部类没有被声明为static 要想在本类或其它类进行调用，则只有一种方法：
· 外部类.内部类 内部类对象 = 外部类实例.new 内部类();
代码如下：
class Outer
{
private String info="hello world!"; //声明外部类成员变量
class Inner
{
public void getInfo(){ //内部类方法
System.out.println(info); //可以直接访问外部类的私有属性
}
}
public void fun(){ //外部类通过实例化内部类调用其方法
new Inner().getInfo();
}
}
public class InnerClassDemo03
{
public static void main(String args[]){
Outer out=new Outer(); //实例化外部类
Outer.Inner oi=out.new Inner(); //访问内部类
oi.getInfo(); //调用内部类方法
}
}在方法中定义内部类
一个内部类可以在任意的位置上定义，下面代码内部类在方法中定义：
class Outer
{
private String info="hello world!"; //声明外部类成员变量
public void fun(){ //外部类通过实例化内部类调用其方法
class Inner
{
public void getInfo(){ //内部类方法
System.out.println(info); //可以直接访问外部类的私有属性
}
}
new Inner().getInfo();
}
}
public class InnerClassDemo04
{
public static void main(String args[]){
new Outer().fun();
}
}注意：如果内部类在有参数的方法中被定义，而内部类要访问该参数，则此参数必须是final类型。
class Outer
{
private String info="hello world!"; //声明外部类成员变量
public void fun(final int temp){ //参数类型必须是最终类型，即final
class Inner
{
public void getInfo(){ //内部类方法
System.out.println("外部类的变量："+info); //可以直接访问外部类的私有属性
System.out.println("传递的参数："+temp);
}
}
new Inner().getInfo();
}
}
public class InnerClassDemo05
{
public static void main(String args[]){
new Outer().fun(30);
}
}
