java开发实战学习笔记2

1.数组对象

数组对象：数组中的元素师对象，不是基础类型的数据

public class Demo
{
    private  int a;
    public int getA()
    {
        return this.a;
    }
    public void setA(int a)
    {
        this.a=a;
    }
    public Demo()
    {
        this.a=10;
    }
    public void sayA()
    {
        System.out.println("a="+a);
    }
}
public class Test {

    public static void main(String[] args) {

        // TODO, add your application code
        Demo[] demos=new Demo[2]; //只是简单的声明，没有赋予内存空间
        for(int i=0;i<demos.length;i++)
        {
            System.out.println("demo["+i+"]="+demos[i]);
        }
        /* demos[0].sayA();
         *发生错误，错误为Exception in thread "main" java.lang.NullPointerException at Test.main(Test.java:20)
         */
        for(int i=0;i<demos.length;i++)
        {
            demos[i]=new Demo();

        }
        for(int i=0;i<demos.length;i++)
        {
            System.out.println("demo["+i+"].a="+demos[i].getA());
        }
    }
}
结果:
demo[0]=null
demo[1]=null
demo[0].a=10
demo[1].a=10

2.内部类，外部类

在类Outer的里面，定义一个类Inner，则类Outer称为外部类或者顶层类，类Inner称为内部类

public class Outer {

    private String outerInfo="Hello,this is outerInfo";
    public class Inner{
        int a;
        public void sayA()
        {
            System.out.println("a="+this.a);
        }
        public void sayInfo()
        {
            System.out.println("outerInfo:"+outerInfo);
        }
    }
    public Outer() {
    }
    public void sayAll()
    {
        new Inner().sayA();
        new Inner().sayInfo();
    }
}
public class Test {

    public static void main(String[] args) {

        // TODO, add your application code
        new Outer().sayAll();
    }
}
结果：
a=0
outerInfo:Hello,this is outerInfo

顶层类可以有public,默认访问权限。内部类可以用public,protected,default,private访问权限

几种内部类：

实例内部类：没有使用static修饰的内部类

（1）在创建实例内部类的时候，外部类的实例必须已经先被创建

Inner inner=new Outer().new Inner()

//  Inner inner=new Outer.Inner() 一种错误创建方式

（2）实例内部类享有对外部类的访问权限

（3）实例内部类中不能定义静态成员。

（4）如果实例内部类Inner与外部类Outer含有同名的成员a,则在Inner类中this.a表示Inner类中的a,Outer.this.a表示外部类的a.

静态内部类：使用static修饰的内部类

（1）静态内部类可以直接访问外部类的静态成员，如果要访问外部类的实例成员，则必须通过外部实例对象去访问。

class A{
    private int a1;
    private static int a2;
    
    public static  class B
    {
        int b1=a1;  //编译错误，不能直接访问外部类的实例变量a1;
        int b2=a2;    //合法
        int b3=new A().a1;//合法，可以通过类A的实例访问变量a1
    }
}

（2）静态内部类中可以定义静态成员和实例成员

（3）可以直接使用完整类名定义内部类

局部内部类：在一个方法中定义的类

（1）局部内部类不能用修饰符进行修饰。

（2）局部内部类与实例内部类相识，不能在其中定义静态成员，可以访问外部成员，

（3）局部内部类访问方法变量时，变量类型必须是final类型。