文章会有【原创】或者【转载】标示,部分来自Google Baidu的学习结果 {Java/PHP/Python/Ruby/Go}

Java 在学习三十四【原创】  


【内部类的访问控制符可以使用publicprotectedprivate,而外部类只能使用public和默认】

例如编译生成好的文件

Outer$Inner.class

Outer1$Inner1.class

PersonZ$Bird.class

1:成员内部类:

【注意1:】一个非静态的成员访问非京台的成员 省略了this

【注意2:】非静态的内部类不能用this不是当前对象,要用就是类名.this

【注意3:】如同外部类的一个成员变量,不能声明任何static成员


package coreJava;


public class Test12 {


public static void main(String[] args) {

// 通过Outer访问Inner

Outer outer = new Outer();

outer.outerFun();

// 直接访问Outer的内部类

System.out.println("##############################");

Outer.Inner i = new Outer().new Inner("hhy", 33);

i.innerFun();

}


}


class Outer {

private int i = 10;

public int getI() {

return i;

}


public void setI(int i) {

this.i = i;

}

public void outerFun() {

Inner inner = new Inner("test", 33);

inner.innerFun();

}

public void outerTest() {

System.out.println("Outer");

}

class Inner { //默认权限,可以为public等,等价于一个普通的成员变量

private String name;

private int age;

public Inner(String name, int age) {

this.name = name;

this.age = age;

}

public void innerFun() {

System.out.println("Name:" + name + ", Age:" + age);

System.out.println("Outer:i---" + i);

//等价于一个成员访问了另一个成员

//一个非静态的成员访问非京台的成员 省略了this

//非静态的内部类不能用this不是当前对象,要用就是类名.this

outerTest();

Outer.this.outerTest();

}

}

}


2:静态内部类

1):直接在外部类成员中访问

2):如果是非Private的直接创建对象使用

Outer1.Inner1 in1 = new Outer1.Inner1();

3):静态内部类只能访问外部静态成员;

output类中使用:Inner1.innerTest2(); inner类中使用:test2();【外部类的静态方法】

package coreJava;


public class Test13 {


public static void main(String[] args) {

// TODO Auto-generated method stub

Outer1 o1 = new Outer1();

o1.test1();

Outer1.test2();

System.out.println("#####################");

o1.test3();

System.out.println("#####################");

Outer1.Inner1 in1 = new Outer1.Inner1();

in1.innerTest1();

in1.innerTest2();

}


}


class Outer1 {


public void test1() {

Inner1.innerTest2();

System.out.println("outer test1");

}


public static void test2() {

System.out.println("outer static test2");

}


public void test3() {

Inner1 i1 = new Inner1();

i1.innerTest1();

Inner1.innerTest2();

}


// 内部静态类

static class Inner1 {


public void innerTest1() {

System.out.println("inner test1");

}


public static void innerTest2() {

test2();

System.out.println("inner static test2");

}

}

}


3:局部内部类

4:匿名内部类

1:已经知道父类,获取其子类的实例对象;

2:已经直接接口,获取实现了该接口的类的对象;

匿名类在用的时候必须是直接获取该匿名类的对象

new 父类或者接口() {

子类的实现或者是该接口的实现

}


package coreJava;


public class Test15 {


public static void main(String[] args) {

// TODO Auto-generated method stub

PersonZ z = new PersonZ();

z.getOneCanFly().fly();

z.getOtherFly().fly();

Animal a = new Animal() {


@Override

void play() {

// TODO Auto-generated method stub

System.out.println("test Animal");

}

};

a.play();

}


}


abstract class Animal {

abstract void play();

}


class PersonZ {

// 看到函数返回的值类型是接口,返回的是实现了该接口的类的对象

public CanFly getOneCanFly() {

class Bird implements CanFly {


@Override

public void fly() {

// TODO Auto-generated method stub

System.out.println("bird fly...");

}


} //这个类声明了一个函数的内部,只在该函数内有效

return new Bird();

}

public CanFly getOtherFly() {

return new CanFly() {

public void fly() {

// TODO Auto-generated method stub

System.out.println("other bird fly...");

}

};

}

}