java基础04 内部类

内部类(内置类，嵌套类)
1、内部类修饰符(private static )

(1)、内部类可以被private修饰。当内部类处于类的成员位置上时，可以被private修饰，将内部类在外部类中进行封装。
(2)、内部类可以被static修饰为静态内部类。

2、内部类访问规则

(1)、内部类示例

class Outer{

int x = 3 ;

void m_Out(){

sop(x) ;

}

class Inner{

void m_In() ;

}

}

(2)、Outer和Inner的互访

如上代码

(i)、Inner访问Outer：

a、内部类Inner可以不建立Outer的对象就访问Outer的成员(包括私有，因为私有在本类中有效)。

b、内部类可以直接访问外部类的原因是，持有外部类Outer的引用Outer.this。

(ii)、Outer访问Inner：外部类Outer要访问Inner的成员则必须建立Inner的对象。

class Outer{

class Inner{

void m_In(){

System.out.println() ;

}

}

//建立Inner对象

class m_Out{

Inner in = new Inner() ;

in.m_In() ;

}

}

(3)、其他类直接访问内部类Inner的成员：要标示出Inner所属的类。

示例：

Outer.Inner in = new Outer().new Inner() ;//很少用，一般考试会考到。

in.m_In() ;

3、静态内部类

(1)、当内部类被static修饰后，只能直接访问外部类中的static成员，出现了访问局限。
(2)、在外部其他类中访问静态内部类的非静态成员和静态成员。

a、在外部其他类中访问静态内部类的非静态成员(属于对象调用方法)。

class Outer{

private int x = 3 ;

static class Inner{

void function(){

System.out.println(x) ;

}

}

}

class Demo{

public static void main(String[] args){

//内部类对象调用方法

new Outer.Inner().function() ;

}

}

b、在外部其他类中访问静态内部类的静态成员。(当内部类中定义了静态成员，该内部类必须是静态的)

Outer.Inner.function() ;//Inner和function()都是静态的，可以这样用。

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

4、内部类定义原则

当描述事物时，事物的内部还有事物，该事物用内部类类描述。因为内部事物在使用外部事物的内容。
例如描述人时，心脏在人的内部。人和心脏属于组合结构。心脏有自己的属性和功能，可以将心脏定义在人体的内部。如
class Body{

//心脏需要被私有修饰，并提供访问方式

private class XingZang{}

//提供访问方式。(不能随便访问，一般要对访问者进行判断)

public XingZang showXingZang{

XingZang xz = new XingZang() ;

return xz ;

}

}

5、匿名内部类

5.1、内部类定义在局部时

(1)、不可以被成员修饰符修饰。

(2)、可以直接访问外部类中的成员，

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

b、内部类定义在局部时，从内部类中只能访问被final修饰的局部变量。

示例代码

class Outer{

int x = 3 ;

void method(){

final int y = 4 ;

class Inner{

void function(){

/*内部类定义在局部时，访问局部变量，这个变量要被final修饰*/

System.out.println(/*Outer.this.*/ y ) ;

}

}

}

} 

(3)、访问局部变量

class Outer{

int x = 3 ;

void method(final int a){

final int y = 4 ;

class Inner{

void function(){

System.out.println(a);

}

}

}

}

class Demo{

public static void main(){

Outer out = new Outer() ;

out.method(7) ;

//调用method方法，a进入栈内存，将7赋给a，a就被final修饰了，不可改变，这句话执行完后，a出栈，被释放。（如果写a++就不行，因为这样a就成了固定的）再调用a，又进栈了。

out.method(8) ;

}

}

5.2、匿名内部类

(1)、匿名内部类其实就是一个匿名子类对象。

(2)、new 父类或者接口(){定义子类的内容}

(3)、定义内部类的前提

a、内部类必须继承一个类或者实现接口

abstract class XingZang{

abstract void show() ;

}

class Person{

int age = 23 ;

/*(1)、非匿名内部类

class PersonXingZang extends XingZang {

void show(){

System.out.println( age) ;

}

}

//建立对象调用内部类的方法

public void function{

new Inner().show() ;

}*/

//(2)、匿名子类对象调用方法

public void function(){

//2.1、建立XingZang的匿名子类对象

new XingZang(){

//复写XingZang中的抽象方法

void show(){

System.out.println(age) ;

}

}./*调用方法*/show() ;

//2.2、或者可以这样为其命名：父类引用 = 子类对象 ；

这样父类引用只能调用父类方法，而不能调用子类特有的方法

XingZang xz = new XingZang(){

//复写XingZang中的抽象方法

void show(){

System.out.println(age) ;

}

} ;

}

}

class Cat{

//cat有自己的心脏

}