Java学习笔记之对象数组和内部类

1、对象数组

对象数组就是数组里包含的是一组对象，在使用之前，我们必须要先开辟数组空间，一开始数组里的每一个对象都是null值，在使用的时候，每一个对象都必须实例化。

1.1 对象数组的声明

类 对象数组名称 [] = new 类 [数组长度]

class Person{
    private String name;

    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Person(String name){
        this.setName(name);
    }
}

public class ChapterFive {
    public static void main(String[] args){
        Person per[] = new Person[3];  // 开辟了三个空间大小的数组
        System.out.println("============= 数组声明 ============");
        // 对象数组初始化之前，每个值都是null
        for(int i=0;i<per.length;i++){
            System.out.println("per[" + i + "] = " + per[i]);
        }
        // 每个元素初始化
        per[0] = new Person("张三");
        per[1] = new Person("李四");
        per[2] = new Person("王五");

        System.out.println("============ 对象实例化 ===========");
        for(int i=0;i<per.length;i++){
            System.out.println("per[" + i + "] = " + per[i].getName());
        }
    }
}

// 运行结果
============= 数组声明 ============
per[0] = null
per[1] = null
per[2] = null
============ 对象实例化 ===========
per[0] = 张三
per[1] = 李四
per[2] = 王五

1.2 数组动态初始化

数组可以静态初始化，也可以动态初始化，对象数组当然也一样可以。

class Person{
    private String name;

    public String getName(){
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Person(String name){
        this.setName(name);
    }
}

public class ChapterFive {
    public static void main(String[] args){
    	// 静态初始化三个对象
        Person per[] = {new Person("张三"),new Person("李四"),new Person("王五")};  
        System.out.println("============ 数组输出 ===========");
        for(int i=0;i<per.length;i++){
            System.out.println("per[" + i + "] = " + per[i].getName());
        }
    }
}

2、内部类

在一个类里还可以再定义另一个类，我们称为内部类，定义了内部类的类称为外部类，内部类可以声明为private或者public，对内部类的访问和外部类中其它成员变量或者方法一样。

标识符 class 外部类名称{
	// 外部类成员
	标识符 class 内部类名称 {
		// 内部类成员
	}
}

class Outer{
    private String info="hello world!";  // 外部类私有属性
    class Inner{  // 定义内部类
        public void print(){
            System.out.println(info);
        }
    }

    public void fun(){  // 定义外部类的方法
        new Inner().print();  // 通过内部类的实例化调用方法
    }
}

public class ChapterFive {
    public static void main(String[] args){
        new Outer().fun();  // 调用外部类的fun方法
    }
}

// 运行结果
hello world!

内部类既有优点又有缺点：

• 缺点： 破坏了类的结构，正常定义一个类，最好只定义属性和方法。
• 优点： 可以方便的访问外部类的私有属性

2.1 使用 static 声明内部类

如果一个内部类用static声明，则此内部类称为外部类，可以在类的外部调用，如果想要调用外部类的属性，则必须声明为static类型

class Outer{
    private static String info="hello world!";  // 外部类私有属性
    static class Inner{  // 定义内部类
        public void print(){
            System.out.println(info);
        }
    }

    public void fun(){  // 定义外部类的方法
        new Inner().print();  // 通过内部类的实例化调用方法
    }
}

public class ChapterFive {
    public static void main(String[] args){
        new Outer.Inner().print();  // 调用外部类的print方法
    }
}

2.2 在外部访问内部类

一个内部类可以在外部类中被访问，也可以直接在其它类中调用，调用格式为：
外部类. 内部类 内部类对象 = new 外部类实例.new 内部类( );

class Outer{
    private String info="hello world!";  // 外部类私有属性
    class Inner{  // 定义内部类
        public void print(){
            System.out.println(info);
        }
    }

    public void fun(){  // 定义外部类的方法
        new Inner().print();  // 通过内部类的实例化调用方法
    }
}

public class ChapterFive {
    public static void main(String[] args){
        Outer out = new Outer();   // 外部类实例化对象
        Outer.Inner in = out.new Inner();   // 实例化内部类对象
        in.print();    // 调用内部类的方法
    }
}

2.3 在方法中定义内部类

一个内部类可以定义在任意的位置，我们看一下在方法中定义的内部类

class Outer{
    private String info="hello world!";  // 定义外部类私有属性
    public void fun(final int temp){  // 定义外部类的方法
        class Inner{                  // 在方法中定义内部类
            public void print(){      // 定义内部类的方法
                System.out.println("类中的属性：" + info);  // 直接访问外部类的私有属性
                System.out.println("方法中的参数：" + temp);
            }
        }
        new Inner().print();
    }
}

public class ChapterFive {
    public static void main(String[] args){
        new Outer().fun(30);   // 调用外部类的方法
    }
}