简单整理一下内部类

装箱和拆箱

装箱:

int i = 22;

Integer inte = new Integer(i); //将i包装成Integer类型的对象

inte=Integer.valueof(i); //获得一个i值的Integer对象

inte=i; 这里隐式调用了Integer.valueof()方法

拆箱: 对象的值取出来赋值给基本类型对象-->基本类型

i = inte.intvalue();

i=inte; //这里也是隐式的调用了inte.intvalue()的方法

byte-->Byte

char-->Charactor

short-->Short

int-->Integer

double-->Double

float-->Float

booelan-->Boolean

这些包装类型跟String类型类似他们在常量池中有一些缓存

Double Float除外

整数缓存的范围是 (-128---127)

布尔类型 true false

char的值的0--127

(话不多说上例子)

输出结果为true

将两个Integer的对象的值更改成为128 输出结果为false;

超出范围就会在堆中新建一个对象 (这个地方是需要注意的)

字符串类型转换成int类型的方法:

结果打印出来都是123456

将int类型转换成字符串类型:

最简单的一种方法是直接让i与一个空字符串连接

另外两种是分别调用Integer的toSring()的方法和调用 String的valueof()的方法

(想得到哪个类型的对象就调用其valueof()方法)

简单分析内部类:

类的内部可以定义属性方法也可以定义类

class Outer{ //外部类

class Inner{ //内部类

}

内部类可以被四种修饰符修饰也可以被static关键修饰

1:实例成员内部类

如上图所看看到的实例成员内部类有两种创建实例对象的方式

内部类可以无限制的访问外部类的成员

即使是私有的外部成员也是可以访问的:

因为在内部类种隐含了有一个外部内对象

(Outer.this.i )

但是外部类要想访问内部类的成员就要创建内部类的对象来访问

上面分析了实例成员内部类

总结一下:内部类可以无限制的访问外部类成员(尽管是private)

而外部类要想访问内部类的成员就必须要创建内部类对象来访问

很重要的一句话:内部类归外部类对象所有

很重要!很重要!很重要!(说三遍)

2.静态内部类:

也就是说用static关键字来修饰内部类

class Outer{ //外部类

static class Inner{ //内部类

}

被static修饰的内部类在创建对象的时候不依附于外部类对象

Outer.Inner inner = new Outer.Inner();

也不需要先创建外部类对象再来创建内部类对象

不能直接访问外部类非静态成员(但是可以通过创建外部类对象访问)

总结一下静态内部类:

不需要依附外部类的对象

不能访问直接外部非静态成员变量(需要创建对象)

3:局部内部类:

局部内部类可以访问局部变量

但是局部变量的值不能改变

4:匿名内部类:

匿名内部类要继承一个类 (可以是抽象类) 或者实现一个接口

先来看一下继承一个类的匿名内部类

打印结果是:父类的匿名方法

父类的方法

new TestOuter().outer.show():

这个show()方法是重写了父类的show();方法所以打印出来的是父类的匿名方法

new Outer().show();

这一个是新建了一个父类的匿名对象并没有重写父类的show()方法 ,所有调用的是父类的show()方法

还有另外一种方式来编写匿名内部类:

打印输出的结果跟上面的一样原因也是相同的,只不过是内部类的两种不同的表现形式

下面是匿名内部类实现一个接口

实现一个接口跟继承一个类是同理的

下面的例子是子类继承一个静态内部类和非静态内部类的例子

class Wai {
	Wai() {
		System.out.println("外部类的构造方法");
	}

	class Nei1 {
		public Nei1() {
			System.out.println("内部类的构造方法");
		}
	}

	static class Nei2 {
		public Nei2() {
			System.out.println("静态内部类的构造方法");
		}
	}
}

class A extends Nei2 {
	public A() {
		super();// 隐式的调用super();
		System.out.println("父类是静态内部类的子类的构造方法");
	}
}

class B extends Nei1 {
	public B(Wai l) {
		l.super();
		System.out.println("父类是内部类的子类的构造方法");
	}
}

public class TestLibary {
	public static void main(String[] args) {
		new A();
		new B(new Wai());
	}
}

打印结果分别是

静态内部类的构造方法
父类是静态内部类的子类的构造方法

外部类的构造方法
内部类的构造方法
父类是内部类的子类的构造方法

子类继承静态内部类:子类在创建对象的时候需要先调用父类的构造函数因为是静态的内部类不需要外部类对象来操作

所以就打印出来两个结果(子类的构造方法里隐式的调用了父类的构造函数)

子类继承非静态的内部类类在创建对象的时候需要先调用父类的构造函数因为式非静态的内部类需要外部类对象来操作

所以要先调用外部类的构造函数获得外部类对象再来调用内部类的构造函数打印出来三行语句

断断续续敲了一天整理一下内部类的知识点

尽管不是很全面也可能还有错误 (逼话少说) 继续努力努力再努力!!

简单整理一下内部类

猜你喜欢