类之间的成员访问小结

有如何访问自身类里面的成员，还有如何访问另一个类里面的成员，
以及如何访问另一个非静态内部类或者静态内部类里面的成员。
原类A

import java.util.Arrays;

public class A {
    int a1 = 1;
    static int a2 = 2;
    private int a3;//私有变量可以通过getter和setter方法来获取
    public void setA3(int a3) {
        this.a3 = a3;
    }
    public int getA3() {
        return a3;
    }
    public void Aa1() {
        System.out.println("Aa1");
    }
    public static void Aa2() {
        System.out.println("Aa2");
    }
    public void Aa3() {
        A.Aa2();//用一个非静态方法来替换一个静态方法
    }
    private void Aa4() {
        System.out.println("Aa4");//私有方法在本类里面可以直接获取
    }
    //得到方法里面的多个参数的两种方法
    public int[] function1() {//1.通过返回数组类型
        int i = 4;
        int j = 5;
        int[] a = {i,j};
        return a;
    }
    public void function2(int[] a) {//2.设置一个带有数组类型的形参且无返回值的方法
        int i = 6;
        int j = 7;
        a[0] = i;
        a[1] = j;
    }
    public void swap(int[] a) {
        int i = a[0];
        a[0] = a[1];
        a[1] = i;
    }
    public static void main(String[] args) {
        System.out.println("==========");//访问自身类里面的成员
        A p = new A();//创建一个A类的实例对象p
        p.Aa1();//通过p去访问Aa1方法
        Aa2();//都是同类静态方法，可以直接访问
        p.Aa3();
        p.Aa4();
        p.setA3(3);
        int[] b = p.function1();//定义一个新的数组来接收其返回值
        int[] c = new int[2];
        p.function2(c);//定义一个新的数组，通过类似赋值的手段来得到其中的值
        int[] d = {4,5};
        p.swap(d);
        System.out.println(p.getA3());
        System.out.println(p.a1);//通过p去访问a1变量
        System.out.println(a2);//都是静态类型，可以直接访问
        System.out.println(Arrays.toString(b));
        System.out.println(Arrays.toString(c));
        System.out.println(Arrays.toString(d));
        System.out.println("==========");//访问另一个类里面的成员
        B q = new B();//创建一个B类的实例对象q
        q.Bb1();//通过q去访问Bb1方法
        B.Bb2();//由于Bb2是外类的静态方法，可以通过B类去访问Bb2方法
        q.Bb3();
        q.Bb5();//通过访问外类的包装方法来访问外类的私有方法
        q.setB3(30);//通过访问外类的getter和setter方法来访问外类的私有变量
        System.out.println(q.getB3());
        System.out.println(q.b1);//通过q去访问b1变量
        System.out.println(B.b2);//由于b2是外类的静态变量，可以通过B类去访问b2变量
        System.out.println("==========");//访问另一个非静态内部类里面的成员
        Out.In x = new Out().new In();
        //首先定义一个Out.In形式的内部类变量
        //然后new Out()一个外部类实例
        //最后再new一个非静态内部类实例
        x.in();
        System.out.println("==========");//访问另一个静态内部类里面的成员
        StaticOut.StaticIn y = new StaticOut.StaticIn();
        //首先定义一个StaticOut.StaticIn形式的内部类变量
        //然后再new一个静态内部类实例
        y.in();
    }
}

另一个普通类B

public class B {
    int b1 = 10;
    static int b2 = 20;
    private int b3;
    public void setB3(int b3) {
        this.b3 = b3;
    }
    public int getB3() {
        return b3;
    }
    public void Bb1() {
        System.out.println("Bb1");
    }
    public static void Bb2() {
        System.out.println("Bb2");
    }
    public void Bb3() {
        B.Bb2();
    }
    private void Bb4() {
        System.out.println("Bb4");
    }
    public void Bb5() {
        B p = new B();
        p.Bb4();
        B.Bb6();
    }
    private static void Bb6() {
        System.out.println("Bb6");
    }
}

另一个非静态内部类In

public class Out {
    class In {
        public void in() {
            System.out.println("测试信息1");
        }
    }
}

另一个静态内部类StaticIn

public class StaticOut {
    static class StaticIn {
        public void in() {
            System.out.println("测试信息2");
        }
    }
}