Java基础之包装类、内部类及String类

一、基本数据类型的包装类

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();
	}
}

运行结果：

跳上太空...