黑马程序员——面向对象(继承02）-第19天

[b]----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

[/b]

107_面向对象(内部类访问规则)

内部类：将一个类定义在另一个类的里面，对里面的那个类就称为内部类（内置类，嵌套类）

内部类的访问规则：

1，内部类可以直接访问外部类中的成员，包括私有。

之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用。格式是:
外部类名.this

2，外部类要访问内部类，必须建立内部类对象。

例1：

class Outer

{

private int x=3;//私有化在本类中有效。

class Inner//内部类

{

void function()

{

System.out.println("inner :"+x);//内部类直接访问外部类的私有成员

}

}

void method()

{

Inner in=newInner();in创建内部类对象

in.function();//in访问内部类

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer out=new Outer();

out.method();

}

}

//打印

inner :3

例2：

class Outer

{

private int x=3;//私有化在本类中有效。

class Inner//内部类

{

int x=4;

void function()

{

int x=6;

System.out.println("inner:"+x);//先找内部类function方法内的x，x=6。

}

}

void method()

{

Inner in=new Inner();in创建内部类对象

in.function();//in访问内部类

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer out=new Outer();

out.method();

}

}

//打印

inner :6

例3：

class Outer

{

private int x=3;//私有化在本类中有效。

class Inner//内部类

{

int x=4;

void function()

{

int x=6;

System.out.println("inner :"+this.x);//用this强制访问内部类成员的x。x=4

}

}

void method()

{

Inner in=new Inner();//in创建内部类对象

in.function();//in访问内部类

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer out=new Outer();

out.method();

}

}

//打印

inner :4

例4：

class Outer

{

private int x=3;//私有化在本类中有效。

class Inner//内部类

{

int x=4;

void function()

{

int x=6;

System.out.println("inner :"+Outer.this.x);//用this指向了Outer类成员的x。x=3

}

}

void method()

{

Inner in=new Inner();

in.function();//in访问内部类

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer out=new Outer();

out.method();

}

}

//打印

inner :3

总结：从例1和例4的结果相同可以看出，

例1中的

System.out.println("inner:"+x);//Outer.this.x省略成了x。再一次说明内部类可以访问外部类成员。

如果直接访问内部类的成员。下面这种是错误的：

class Outer

{

private int x=3;//私有化在本类中有效。

class Inner//内部类

{

void function()

{

System.out.println("inner :"+x);

}

}

class Outer2//另外定义一个外部类不同，而内部类相同。

{

class Inner//内部类

{

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Inner in=new Inner();//错误！！！这时，主函数就不知道调用那个内部类了。

in.function();

}

}

面试：

那么继续改进。。。

class Outer//这里绝对不能private class Outer

{

private int x=3;//私有化在本类中有效。

private class Inner//内部类!!!当内部类在外部类的成员位置上时，可以被私有化修饰！！！

{

void function()

{

System.out.println("inner :"+x);

}

}

void method()

{

Inner in=new Inner();

in.function();//in访问内部类

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer.Inner in=new Outer().new Inner();//外部类.内部类in=外部类.内部类

in.function();

}

}

08_面向对象(静态内部类)

访问格式：

1，当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。

可以直接建立内部类对象。

格式：

外部类.内部类变量名=外部类对象.内部类对象

Outer.Inner in =Outer.Inner();

2，当内部类在成员位置上，就可以被成员修饰符所修饰。

比如，private：将内部类在外部类中进行封装。

static：内部类就具备了static的特性。

当内部类被static修饰后，只能访问外部类中的static成员，出现了访问局限。

在外部其它类中，如何访问静态内部类的非静态成员。？？

可以通过new Outer.Inner().function();

在外部其它类中，如何访问静态内部类的静态成员。？？

可以通过new Outer.Inner.function();//是静态，直接类名调用

注意：当内部类中定义了静态成员，该内部类必须是static的。

注意：当外部类中的静态方法访问内部类时，内部类也必须是静态的。

class Outer//这里绝对不能private class Outer

{

private int x=3;//私有化在本类中有效。

static class Inner//静态化内部类。

{

void function()

{

System.out.println("inner :"+x);

}

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

//编译错误。从静态内部类中引用非静态变量x

}

}

在外部其它类中，如何访问静态内部类的非静态成员。？？

可以通过newOuter.Inner().function();

class Outer

{

private static int x=3;//私有化,静态化x

static class Inner//静态化内部类。

{

void function()//function()是非静态的

{

System.out.println("inner :"+x);

}

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

new Outer.Inner().function();//内部类对象调用非静态function方法。

}

}

在外部其它类中，如何访问静态内部类的静态成员。？？

可以通过newOuter.Inner.function();

class Outer

{

private static int x=3;//私有化,静态化x

static class Inner//静态化内部类。

{

Void staticfunction()//function()是静态的

{

System.out.println("inner :"+x);

}

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

new Outer.Inner.function();//加载Outer,加载Inner，加载function。

}

}

注意：当内部类中定义了静态成员，该内部类必须是static的。

class Outer

{

private static int x=3;//私有化,静态化x

class Inner//非静态内部类。

{

static void function()//function()是静态的

{

System.out.println("inner :"+x);

}

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

//编译错误，内部类中不能有静态声明。

}

}

class Outer

{

private staticint x=3;//私有化,静态化x

static class Inner//静态内部类。

{

static void function()//function()是静态的

{

System.out.println("inner :"+x);

}

}

class Inner2

{

void show()

{

System.out.println("inner2show");

}

}

public static void method()

{

Inner.function();//静态内部类中的静态成员

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer.method();//静态成员，访问静态变量。都不需要new！！！

}

}

//打印：

inner :3

class Outer

{

private static int x=3;//私有化,静态化x

static class Inner//静态内部类。

{

static void function()//function()是静态的

{

System.out.println("inner :"+x);

}

}

class Inner2

{

void show()

{

System.out.println("inner2show");

}

}

public static void method()

{

new Inner2().show();//创建new

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer.method();//编译错误，静态成员，访问非静态方法。

}

}

注意：当外部类中的静态方法访问内部类时，内部类也必须是静态的。

class Outer

{

private static int x=3;//私有化,静态化x

static class
Inner//静态内部类。

{

static void function()//function()是静态的

{

System.out.println("inner :"+x);

}

}

static class Inner2

{

void show()

{

System.out.println("inner2show");

}

}

public staticvoid method()

{

new Inner2().show();//访问静态内部类的非静态成员

}

}

class InnerClassDemo

{

public static void main(String[] args)

{

Outer.method();

}

}

//打印：

inner2 show

109_面向对象(内部类定义原则)

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

因为内部事物在使用外部事物的内容。

class Body

{

private class XinZang//私有化心脏。公开心脏是很伤心的。

{

}

public void show()//提供心脏给外部访问的方法。

{

new XinZang();

}

}

110_面向对象(匿名内部类)

class Outer

{

intx=3;

voidmethod()//非静态，没对象的时候，不运行。

{

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(Outer.this.x);

}

｝

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

//编译运行报错。

}

}

}

}

class Outer

{

intx=3;

voidmethod()//非静态，没对象的时候，不运行。

{

newInner().function();//编译的时候，新创建类Inner时，还没有加载function方法，

找不到function，编译错误。

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(Outer.this.x);

}

｝

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().method();//编译错误

}

}

class Outer

{

intx=3;

voidmethod()//非静态，没对象的时候，不运行。

{

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(Outer.this.x);

}

｝

newInner().function();//放在后面就保障了function方法被加载过。

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().method();

}

}

//打印：

3

class Outer

{

intx=3;

voidmethod()//非静态，没对象的时候，不运行。

{

inty=4;

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(y);

}

｝

newInner().function();

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().method();

}

}//编译错误：

从内部类中访问局部变量y:需要被声明为最终类型final。

内部类定义在局部时，

1，不可以被成员修饰符修饰

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。

但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

class Outer

{

intx=3;

voidmethod()//非静态，没对象的时候，不运行。

{

final int y=4;

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(y);

}

｝

newInner().function();

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().method();

}

}//打印：

4

class Outer

{

intx=3;

voidmethod(int a)//a是一个变化的局部变量。当调用时7。即变成int a=7;

{

finalint y=4;

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(a);

}

｝

newInner().function();

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().method(7);

}

}

//编译错误。再次出现内部类访问局部变量，

class Outer

{

intx=3;

voidmethod(final int a)

{

finalint y=4;

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(a);

}

｝

newInner().function();

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().method(7);

}

}

//打印：

7

class Outer

{

intx=3;

voidmethod(final int a)

{

final int y=4;

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(a);

}

｝

newInner().function();

｝

｝

class InnerClassDemo

{

publicstatic void main(String[] args)

{

Outerout=new Outer();

out().method(7);//往里面传7，a不是就锁定为7了吗？new一次

out().method(8);//怎么还可以往里面传8呢？再new一次

}

}

//编译通过。这是为什么？？？

首先out().method(7);调用method方法，在栈内存中开辟空间，把7赋给a，并锁定。注意，执行完后，就要出栈，释放内存。

然后out().method(8);再调用method方法，进栈，出栈。

当method方法，出现a++,就有问题了。。。

void method(finalint a)

{

a++;//a是固定的，不能改变。

finalint y=4;

classInner//局部内部类不能修饰为静态

{

voidfunction()

{

System.out.println(a);

}

｝

newInner().function();

｝

//编译错误。

匿名内部类：

1，匿名内部类其实就是内部类的简写格式。

2,定义匿名内部类的前提：

内部类必须是继承一个类或实现接口。

3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。

5，匿名内部类中最好不要超过3个。

//定义一个父类（公共类）

class AbsDemo

{

abstract void show();//抽象

}

class Outer

{

intx=3;

classInner extends AbsDemo//Inner继承了AbsDemo

{

voidshow()

{

System.out.println("show"+x);

}

}

publicvoid function()

{

newInner().show();

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}

//打印：

show3

简化成匿名内部类。

class AbsDemo

{

avstract void
show();

}

class Outer

{

intx=3;

publicvoid function()

{

//newAbsDemo()；这里代表了创建了AbsDemo对象。而抽象类不可以被new对象创建？？？它里面有抽样方法。。。

new AbsDemo()//创建AbsDemo对象，后面还带着内容。就相当于一个对象体，一个很胖的对象。

{//这个AbsDemo的子类对象。因为它要复写AbsDemo的父类对象的内容。

voidshow()

{

System.out.println("x="+x);

}

};

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}

再变化成更奇葩的！！！

class AbsDemo

{

avstractvoid show();

}

class Outer

{

intx=3;

publicvoid function()

{

//newAbsDemo()；这里代表了创建了AbsDemo对象。而抽象类不可以被new对象创建？？？它里面有抽象方法。。。

new AbsDemo()//创建AbsDemo对象，后面还带着内容。就相当于一个对象体，一个很胖的对象。

{//这个AbsDemo的子类对象。因为它要复写AbsDemo的父类对象的内容。

voidshow()

{

System.out.println("x==="+x);

}

}.show();//相当于 new Inner().show();即AbsDemo的匿名子类对象.show();

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}

//优点：简化代码。

缺点：初步一看，阅读性差。

在AbsDemo的子类对象，创建其它的方法。比如abc()

class AbsDemo

{

abstract void show();

}

class Outer

{

intx=3;

publicvoid function()

{

new AbsDemo()

{

voidshow()

{

System.out.println("x==="+x);

}

void abc()//定义了子类特有的方法，是正常的。

{

System.out.println("haha");

}

}.abc();//故调用abc也是可以的。

//匿名对象只能对方法调用一次。再次调用又要重新写一次。。。

new AbsDemo()

{

voidshow()

{

System.out.println("x==="+x);

}

voidabc()//定义了子类特有的方法，是正常的。

{

System.out.println("haha");

}

}.show();

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}

//打印：

haha

x===3

class AbsDemo

{

abstractvoid show();

}

class Outer

{

intx=3;

publicvoid function()

{

AbsDemod=new AbsDemo()//父类引用子类。相当与AbsDemo a=new Inner();

{

voidshow()//子类复写

{

System.out.println("x==="+x);

}

voidabc()

{

System.out.println("haha");

}

};

d.show();//当d.abc();编译错误。父类中没有方法abc()

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}

//打印：

x===3

父类AbsDemo中有多个show()方法。

class AbsDemo

{

avstractvoid show();

avstractvoid show1();

avstractvoid show2();

avstractvoid show3();

}

class Outer

{

intx=3;

publicvoid function()

{//这样阅读性很差

newAbsDemo()//匿名变量中，最多不超过3个方法。

{

publicvoid show()

{

publicvoid show1()

{

}

publicvoid show2()

{

}

publicvoid show3()

{

}

};

AbsDemod=new AbsDemo()//父类引用子类。相当与AbsDemo a=new Inner();

{

voidshow()//子类复写

{

System.out.println("x==="+x);

}

voidabc()

{

System.out.println("haha");

}

};

d.show();//当d.abc();编译错误。父类中没有方法abc()

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}

class AbsDemo

{

abstract void show();

}

class Outer

{

intx=3;

publicvoid function()

{

AbsDemod=new
AbsDemo()

{//此时AbsDemo相当于类

intnum=9;//num相当于类中的成员变量

voidshow()

{

System.out.println("num==="+num);

}

voidabc()

{

System.out.println("haha");

}

};

d.show();

}

}

class InnerClassDemo

{

publicstatic void main(String[] args)

{

newOuter().function();

}

}

//打印：

num===9

练习：

interface Inter

{

voidmethod();//在实现接口中，method是抽象非静态的。在接口中，抽象abstract可以隐藏不写。

}

class Test

{

//补足代码，通过匿名内部类。

static class Inner
implementsInter

{

publicvoid method()

{

System.out.println("methodrun");

}

}

static function()//定义静态function

{

returnnew Inner();

}

}

class InnerClassTest

{

publicstatic void main(String[] args)

{

Test.function().method();//上面已经new过了，这里就不用new

}

}

//Test.function().method();可以看出function是静态的。而method是非静态的。

因为它是抽象的。

改成匿名的：

interface Inter

{

voidmethod();

}

class Test

{

//补足代码，通过匿名内部类。

staticfunction()

{

returnnew
Inter()

{

publicvoid method()

{

System.out.println("methodrun");

}

};

}

}

class InnerClassTest

{

publicstatic void main(String[] args)

{

Test.function().method();//上面的返回值，在匿名内部类中已经new创建了，这里不用new