“黑马程序员”java面向对象基础_内部类

——- android培训、java培训、期待与您交流！
———

内部类:

什么是内部类?

内部类,其实就是将一个类定义在另一个类的里面,对里面那个类我们就称其为内部类(嵌套类,内置类)

内部类的划分:

1-成员内部类:定义在外部类的成员区域里,与成员变量,成员函数同级;

如:

class Outer{

int num;

void show(){ }

class Innter{ }

}

成员内部类特点:

a.可以被private,protected所修饰,而顶级类只能有public,和默认类修饰符

b.不能脱离外部类而使用,成员内部类依赖于外部类而存在,因为在该外部类以外创建该内部类要如下:

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

c.内部类对象可以访问外部类对象的任意成员,包括private所修饰的.

d.不能与外部类同名

c.不能有静态的成员.

2-静态内部类:在普通内部类前加static,与普通内部类的主要区别是:只能访问外部类的静态成员

如:

class Outer{

static int num;

void show(){ }

static class Innter{ } //要想访问外部类的num,其必须为static修饰

}

静态内部类的特点:

a.可以被private,protected所修饰,而顶级类只能有public,和默认类修饰符

b.不能脱离外部类而使用,成员内部类依赖于外部类而存在,因为在该外部类以外创建该内部类要如下:

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

c.可以访问外部类对象的任意成员,包括private所修饰的.

d.可以拥有非静态成员

e.只能访问外部类的静态成员

3-局部内部类:定义在方法体里面的类.

如:

class
Outer{

static int num;

void show(){

class Innter{ }

}

}

局部内部类的特点:

a.有其有限的作用域,超出该作用于则无法使用

b.可以访问外部类对象的任意成员,包括private所修饰的.

c.只能访问该方法体内被final修饰的常量.定义在方法体中的变量会随着方法的退出而消亡,通过定义其为final变量，可以扩展其生命期.

d.定义在代码块中的内部类只能使用在该block中定义的final变量

4-匿名内部类:在某些情况下，我们只需要内部类的一个对象,而不需要该类的名字;前提:匿名内部类必须继承或实现一个外部类或接口,匿名内部类其实就是一个匿名子类对象

格式: new 父类 of 接口 {子类内容;}

如:

abstract
class Demo {

abstract void show();

}

public
void method(){

//以下相当于new Inner().show();

new Demo(){ //匿名内部类

void
show(){

System.out.println("show---");

}

}.show();

}

匿名内部类的特点:

a.匿名内部类的实例化;意思就是说:创建一个实现(或继承)了Demo类的对象

b:(保留以后补充);

匿名内部类通常使用的场景:

当函数参数shiite接口类型时,而且接口中的方法不超过三个,可以用匿名内部类和实际参数进行传递

内部类一般用于类的设计上

在分析事物时,发现该事物描述中还有事物,而且这个事物还在访问被描述事物的内容中,这时,就是还有的事物定义成内部类来描述

*如果内部类是静态的,那么它就是一个顶层类,简单来说就类似于一个外部类

实例一:

package notesforinnerclass;

//import innerclassdemo.Demo;

abstract class Demo {

abstract void show();

}

public class NotesForInnerClass {

public static void main(String[] args) {

Outer ou = new Outer();

ou.show();

ou.engine();

ou.send();

ou.method();

}

}

class Outer{

int num=1;

void show(){

System.out.println("这里是***外部类***中的show方法");

}

// class Outer{ //不能与外部类同名

//

// }

class Innter01{ //成员内部类

void show(){

System.out.println("这里是***成员内部类***Innter01中show方法");

}

}

static class Innter02{ //静态内部类

void show(){

System.out.println("这里是***静态内部类***Innter02中show方法");

}

}

void send(){

@SuppressWarnings("unused")

int a=1;

final int b=2;

@SuppressWarnings("unused")

class Innter03{ //局部内部类

void show(){

// a++; //不能访问非final修饰的方法成员

num++;

System.out.println("这里是send方法中的***局部内部类***Innter03的show方法不能访问方法中成员变量,只能访问方法中被final修饰的常量"+"num="+num+" b="+b);

}

}

Innter03 innt03 = new Innter03();

innt03.show();

}

public void method(){

//以下相当于new Inner().show();

new Demo(){ //匿名内部类

void show(){

System.out.println("这是***匿名内部类***中的show方法");;

}

}.show();

}

void engine() {

Innter01 innt01 = new Innter01();

innt01.show();

Innter02 innt02 = new Innter02();

innt02.show();

}

}

实例二:

package innerclassdemo;

class Outer {
int num = 7;
static class Inner {
void show(){
System.out.println("Inner show");
}
}
public void method(){
Inner in = new Inner();
in.show();
}
}
public class InnerClassDemo {
public static void main(String[] args) {
Outer ou = new Outer(); //创建外部类的对象
ou.method(); //调用method方法,该方法中创建了其内部类的对象
Outer.Inner in = new Outer.Inner(); //创建内部类的对象.
in.show();
}
}

实例三:

package innerclassdemo;

class Outer1 {
int num = 3;
class Inner { //局部内部类
int num = 4;
void show() {
int num = 5;
System.out.println(Outer1.this.num);
System.out.println(this.num);
System.out.println(num);
}
}
void method() {
new Inner().show();
}
}

public class InnerClassDemo2 {

public static void main(String[] args) {
Outer1 ou = new Outer1();
ou.method();
}

}

实例四:

package innerclassdemo;

import innerclassdemo.Outer.Inner;

/
* 内部类可以存放在局部位置上
/

class Outer3 {
int num = 3;
void method(){
final int x = 9;
class Inner {
void show(){
System.out.println("show..." + x);
}
}
Inner in = new Inner();
in.show();
}
}

public class InnerClassDemo3 {

public static void main(String[] args) {
new Outer3().method();
}

}

实例五:

package innerclassdemo;
//匿名内部类
abstract class Demo {
abstract void show();
}

class Outer4 {
int num = 4;
public void method(){
//以下相当于new Inner().show();
new Demo(){ //匿名内部类
void show(){
System.out.println("show---" + num);
}
}.show();
}
}

public class InnerClassDemo4 {

public static void main(String[] args) {
new Outer4().method();
}
}

实例六:

package innerclassdemo;

interface Inter {
void show1();
void show2();
}

//匿名内部类
public class InnerClassDemo5 {

public static void main(String[] args) {

System.out.println("Hello World");
show(new Inter() { //匿名内部类 .Inter 是接口 有两个方法 show1 ,show2
@Override
public void show1() {
System.out.println("inter show1");
}
@Override
public void show2() {
System.out.println("inter show2------");
}
});
}
public static void show(Inter in) { //接收inter类型的值
in.show1();
in.show2();
}

}

实例七:

package innerclassdemo;
//匿名内部类
class Outer6{
void method(){
new Object(){
public void show() {
System.out.println("show run111");
}
}.show();
// Object obj = new Object(){
// public void show() {
// System.out.println("show run222");
// }
// };
// obj.show(); //不能编译运行,因为匿名内部这个
// //子类被向上转型为了Object类型
// 这样就不能再使用子类的特有方法了
//
}
}

public class InnerClassDemo6 {

public static void main(String[] args) {

new Outer6().method();
}
}

——- android培训、java培训、期待与您交流！
———