一、基本数据类型的包装类
Java语言针对所有的基本数据类型都提供了对应的包装类
包装类和基本类型
1、基本数据类型转换为包装类
Integer intValue = new Integer(21);
2、包装类转换成基本类型
Integer integerId = new Integer(25);
int intId = integerId.intValue();
自动装箱、拆箱
JDK5.0中为基本数据类型提供了自动装箱(boxing)、拆箱(unboxing)功能:
1、装箱:将基本数据类型包装为对应的包装类对象
2、拆箱:将包装类对象转换成对应的基本数据类型
注意:包装类并不是用来取代基本类型的
Integer intObject = 5;//装箱
int intValue = inObject;//拆箱
实例1:Integer包装类
package boxing;
public class IntegerDemo {
public static void main(String[] args) {
System.out.println("int的最大值:" + Integer.MAX_VALUE);
System.out.println("int的最小值:" + Integer.MIN_VALUE);
Integer a = 100;//自动装箱
int b = a;//自动拆箱
String str = "123";
int temp = Integer.parseInt(str);
System.out.println(temp+5);
}
}
运行结果:
int的最大值:2147483647
int的最小值:-2147483648
128
实例2:Character包装类
package boxing;
public class CharacterDemo {
public static void main(String[] args) {
Character c = 'a';//自动装箱
char s = c;//自动拆箱
System.out.println("变为大写:" + Character.toUpperCase('a'));
System.out.println("变为小写:" + Character.toLowerCase('Y'));
}
}
运行结果:
变为大写:A
变为小写:y
二、字符串相关类
1、String类
(1)String代表字符串类型,字符串的内容本身不可改变,字符串存储于“字符串常量池”中。
(2)String的两种实例化方式
a:直接赋值法
eg:String str = "Hello World";
b:通过new操作符实例化
eg:String str = new String("Hello World");
(3)一个字符串就是一个String类的匿名对象。
匿名对象就是在堆内存中开辟了空间,但在栈内存中并没有引用指向的对象。
(4)字符串常用方法、
实例1:String类
package string;
public class StringDemo {
public static void main(String[] args) {
String str = "hello";
change(str);
System.out.println(str);
}
public static void change(String str) {
str = "中国";
}
}
运行结果:
hello
实例2:String类的实例化方式
package string;
public class StringEquals {
public static void main(String[] args) {
String str1 = "hello";
String str2 = "hello";
System.out.println("str1与str2相等吗?" + (str1 == str2));
System.out.println("str1与str2相等吗?" + (str1.equals(str2)));
System.out.println("******************************");
String str3 = new String("hello");
System.out.println("str1与str3相等吗?" + (str1 == str3));
System.out.println("str1与str3相等吗?" + (str1.equals(str3)));
}
}
运行结果:
str1与str2相等吗?true
str1与str2相等吗?true
******************************
str1与str3相等吗?false
str1与str3相等吗?true
2、StringBuffer类
(1)StringBuffer类代表可变的字符序列。
StringBuffer称为字符串缓冲区,它的工作原理是:预先申请一块内存,存放字符数列,如果字符序列满了,会重新改变缓存区的大小,以容纳更多的字符序列。
(2)StringBuffer是可变对象,这个是与String最大的不同(如果连续操作String对象,则会产生大量的“垃圾”,而且“断开 - 连接”很频繁)。
3、StringBuilder类
StringBuilder和StringBuffer的功能几乎是一样的,只是StringBuilder是线程不安全的。
实例:StringBuffer类
package stringbuffer;
public class StringBufferDemo {
public static void main(String[] args) {
StringBuffer sb = new StringBuffer();
sb.append("hello");//向字符串常量池中添加字符串
long startTime = System.currentTimeMillis();
for (int i = 0; i < 10000; i++) {
sb.append(i);
}
long endTime = System.currentTimeMillis();
System.out.println("使用StringBuffer耗时:" + (endTime - startTime) + "毫秒");
System.out.println(sb.length());
}
}
运行结果:
使用StringBuffer耗时:2毫秒
38895
三、内部类
1、在类的内部定义另一个类。如果在类的Outer的内部再定义一个类Inner,此事Inner就称为内部类,而Outer就称为外部类。
2、内部类的定义格式
public class 外部类{
//外部类的成员
public class 内部类{
//内部类的成员
}
}
3、内部类在编译完成后也会产生.class文件,而文件名称则是“外部类名称$内部类名称.class”
使用内部类的原因
比如在一个大公司中,技术部是公司的一部分,但是一个技术部不能简单的用属性或方法表示,那是因为技术部也拥有自己的属性和行为,所以要在大公司的内部
好处:
1、可以方便地访问外部类的私有属性
2、减少了类文件编译后的产生的字节码文件的大小
缺点:使程序结构不清楚
1、成员内部类
(1)成员内部类中不能定义static变量
(2)成员内部类持有外部类的引用
(3)在文件管理方面,成员内部类在编译完成后也会产生.class文件,而文件名则是“外部类名称$内部类名称.class”
(4)外部实例化成员内部类的格式:
外部类.内部类 内部类对象 = 外部类实例.new 内部类();
实例:
package inner.member;
public class Outer {
private String name = "中国人";
//成员内部类
class MemberInner{
public void method() {
System.out.println("内部类可以访问外部类的私有属性:" + name);
}
}
public MemberInner getMemberInstance() {
return new MemberInner();
}
}
package inner.member;
public class TestMember {
public static void main(String[] args) {
Outer out = new Outer();
//通过外部类中的成员方法获取内部类对象
out.getMemberInstance().method();
//外部类.内部类 内部类对象 = 外部类实例.new 内部类()
Outer.MemberInner in = out.new MemberInner();
in.method();
}
}
运行结果:
内部类可以访问外部类的私有属性:中国人
内部类可以访问外部类的私有属性:中国人
2、静态内部类
(1)如果一个内部类使用static声明,则此内部类就称为静态内部类,其实也相当于外部类。可以通过外部类.内部类访问。
(2)静态内部类不会持有外部类的引用,创建时可以不用创建外部类对象
(3)静态内部类可以访问外部的静态变量,如果访问外部类的非static成员变量必须通过外部类的实例访问
(4)外部实例化静态内部类对象的格式:
外部类.内部类 内部类对象 = new 外部类.内部类
实例:
package inner.staticDemo;
public class Outer {
private String name = "中国人";
private static int population = 14;
static class StaticInner{
public void method() {
System.out.println("静态内部类直接访问外部类的static属性");
Outer out = new Outer();
System.out.println("在静态类内部中通过外部类对象访问非static属性:" + out.name);
}
}
public static StaticInner getStaticInner() {
return new StaticInner();
}
}
package inner.staticDemo;
public class TestStaticInner {
public static void main(String[] args) {
Outer.getStaticInner().method();;
System.out.println("********************");
Outer.StaticInner in = new Outer.StaticInner();
in.method();
}
}
运行结果:
静态内部类直接访问外部类的static属性
在静态类内部中通过外部类对象访问非static属性:中国人
********************
静态内部类直接访问外部类的static属性
在静态类内部中通过外部类对象访问非static属性:中国人
3、局域内部类
局域内部类是定义在一个方法中的内嵌类,所以类的作用范围仅限于该方法中,而类生成对象也只能在该方法中使用。
局域内部类不能包含静态成员
特别注意:局域内部类想要访问包含其他方法中的参数,则方法中的参数必须加上final关键字(JCK<=1.7)
实例:
package inner.local;
public class Outer {
private String name = "中国人";
public void function(int x) {
class LocalInner{
public void method() {
System.out.println("局域内部类访问外部类的属性:" + name);
System.out.println("局域内部类访问包含其方法的参数:" + x);
}
}
//在局域内部类所在的方法中实例化局域内部类对象并调用方法
new LocalInner().method();
}
}
package inner.local;
public class TestLocal {
public static void main(String[] args) {
Outer out = new Outer();
out.function(6);
}
}
运行结果:
局域内部类访问外部类的属性:中国人
局域内部类访问包含其方法的参数:6
4、匿名内部类
如果一个内部类在整个操作中只使用一次的话,就可以定义为匿名内部类
没有名字的内部类,这是Java为了方便我们编写程序而设计的一个机制,因为有时候有的内部类只需要创建一个它的对象就可以了,以后再不会用到这个类,这时候使用匿名内部类就比较合适。
实例:
package inner.anonymity;
public interface Jumping {
public void jump();
}
package inner.anonymity;
public class TestAnonymity {
public static void main(String[] args) {
Jumping j = new Jumping() {
@Override
public void jump() {
System.out.println("跳上太空...");
}
};
j.jump();
}
}
运行结果:
跳上太空...