扩展概念

一、匿名内部类

接口与抽象类和匿名内部类的关系。

为什么需要存在有匿名内部类，下面通过一个简短的代码来观察此概念。

interface Message {
	public void print();
}

class MessageImpl implements Message {
	public void print() {
		System.out.println("Hello World!");
	}
}

public class Demo {
	public static void main(String args[]) {
		fun(new MessageImpl());
	}

	public static void fun(Message msg) {
		msg.print();
	}
}

正常的规律就是一个接口或者是抽象类需要有子类，子类要覆写所有的抽象方法。

可是如果说现在的MessageImpl子类只使用唯一的一次，那么还有必要将其单独定义为一个类吗？所以这个时候就可以采用匿名内部类的方式进行代码的简化。

interface Message {
	public void print();
}

public class Demo {
	public static void main(String args[]) {
		fun(new Message() {
			public void print() {
				System.out.println("Hello World!");
			}
		});
	}

	public static void fun(Message msg) {
		msg.print();
	}
}

使用匿名内部类的时候有一个前提：必须要基于接口或抽象类的应用。

但是需要强烈强调的是，如果匿名内部类定义在了方法里面，方法的参数或者是变量要被匿名内部类所访问，那么必须加上final关键字（JDK1.8之后此要求被改变）。

 

匿名内部类是在抽象类和接口的基础上发展的，匿名内部类的最大好处是帮助用户减少了类的定义。

---

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

1、认识包装类

Java在设计之初有一个基本原则：一切皆对象，一切的操作都要求用对象的形式进行描述。但是这里面就会出现一个矛盾，基本数据类型不是对象。那么为了符合于这种要求，所以最早的是可以采用人为的方式来解决此问题。

class MyInt {// 一个类
	private int num;// 这个类包装的基本数据类型

	// 构造的目的是为了将基本数据类型传递给对象
	public MyInt(int num) {// 将基本类型包装类
		this.num = num;
	}

	public int intValue() {// 将包装的数据内容返回
		return this.num;
	}
}

public class Demo {
	public static void main(String args[]) {
		MyInt mi = new MyInt(10);// 将int包装为类
		int temp = mi.intValue();// 将对象中包装的数据取出
		// 只有取出包装数据之后才可以进行计算
		System.out.println(temp * 2);
	}
}

因为这样的实现是比较容易的，所以在Java里面为了方便用户的使用，所以专门提供了一组包装类，来包装所有的基本类型： byte（Byte）、short（Short）、int（Integer）、long（Long）、float（Float）、double（Double）、char（Character）、boolean（Boolean）。

但是以上给出的包装类又分为两种子类型：

· 对象型包装类（Object直接子类）：Character、Boolean。

· 数值型包装类（Number直接子类）：Byte、Short、Integer、Long、Float、Double。

Number是一个抽象类，里面一共定义了六个操作方法：intValue()、doubleValue()、floatValue()、byteValue()、shortValue()、LongValue()。

---

2、装箱与拆箱操作

现在已经存在有基本数据类型与包装类，那么这两种变量间的转换就通过以下方式定义：

· 装箱操作：将基本数据类型变为包装类的形式；

      |-每个包装类的构造方法都可以接收各自数据类型的变量。

· 拆箱操作：从包装类之中取出被包装的数据；

     |-利用Number类中提供的一系列的XxxValue()方法完成。

范例：使用int和Integer

public class Demo {
	public static void main(String args[]) {
		Integer obj = new Integer(10);// 将基本数据类型装箱
		int temp = obj.intValue();// 将基本数据类型拆箱
		System.out.println(temp * 2);
	}
}

之前所编写的MyInt类，现在换成了Integer这个系统类。

范例：使用double和Double

public class Demo {
	public static void main(String args[]) {
		Double obj = new Double(10.2);// 将基本数据类型装箱
		double temp = obj.doubleValue();// 将基本数据类型拆箱
		System.out.println(temp * 2);
	}
}

范例：使用boolean和Boolean（不是Number子类）

public class Demo {
	public static void main(String args[]) {
		Boolean obj = new Boolean(true);// 将基本数据类型装箱
		boolean temp = obj.booleanValue();// 将基本数据类型拆箱
		System.out.println(temp);
	}
}

现在可以发现，所有的包装类都使用了同样形式的方法进行操作。

在JDK 1.5之前能够使用的操作都是以上形式的代码，但是从JDK 1.5之后，Java为了方便开发，提供了自动装箱与自动拆箱的机制，并且可以直接利用包装类的对象进行数学计算。

范例：观察自动装箱与自动拆箱

public class Demo {
	public static void main(String args[]) {
		Integer obj = 10;// 自动装箱
		int temp = obj;// 自动拆箱
		obj++;// 包装类直接进行数学计算
		System.out.println(temp * obj);
	}
}

如果可以直接使用包装类进行计算，就省略了手工的拆箱部分。

注意：在Integer类对象上发现可以直接赋予内容，也可以使用构造方法？

public class Demo {
	public static void main(String args[]) {
		Integer obja = 10;// 自动装箱
		Integer objb = 10;
		Integer objc = new Integer(10);
		System.out.println(obja == objb);// true
		System.out.println(obja == objc);// false
		System.out.println(obja == objc);// false
		System.out.println(obja.equals(objc));// true
	}
}

在使用包装类的时候很少会利用构造方法完成，几乎都是直接赋值（这一点与String相同），但是在判断内容是否相等的时候，请一定要记住使用equals()方法。

提示：此时Object可以统一天下了

Object可以接收一切的引用数据类型，但是由于存在有自动的装箱机制，那么Object也可以存在基本数据类型了。

· 流程：基本数据类型——>自动装箱（成为对象）——>向上转型为Object

public class Demo {
	public static void main(String args[]) {
		Object obj = 10;// 先包装再转换
		// Object不可能直接向下转型为int
		int temp = (Integer) obj;// 向下变为Integer而后自动拆箱
		System.out.println(temp * 2);
	}
}

范例：观察Double

public class Demo {
	public static void main(String args[]) {
		Double obj = 10.8;
		System.out.println(obj * 2);
	}
}

范例：观察Boolean

public class Demo {
	public static void main(String args[]) {
		Boolean flag = true;// 自动装箱
		if (flag) {// 直接拆箱判断
			System.out.println("Hello World!");
		}
	}
}

有了这一系列的自动装箱和拆箱的支持之后，在数据类型的选择上就方便了许多。

---

3、数据类型转换（核心）

使用包装类最多的情况实际上是它的数据类型转换功能上，在包装类里面提供有将String型数据变为基本数据类型的方法，使用几个代表的类做说明：

· Integer类：public static int parseInt(String s)；

· Double类：public static double parseDouble(String s)；

· Boolean类：public static boolean parseBoolean(String s)；

特别需要注意的是Character类里面并不存在有字符串变为字符的方法，因为String类有一个charAt()的方法可以根据索引取出字符内容。

范例：将字符串变为int型数据

public class Demo {
	public static void main(String args[]) {
		String str = "123";
		int temp = Integer.parseInt(str);
		System.out.println(temp * 2);
	}
}

此时实现了字符串变为基本数据类型的操作。但是在这样的转换过程之中请一定要注意：被转换为数字的字符串一定要由数字所组成。

范例：错误的代码

public class Demo {
	public static void main(String args[]) {
		String str = "123a";
		int temp = Integer.parseInt(str);
		System.out.println(temp * 2);
	}
}
Exception in thread "main" java.lang.NumberFormatException: For input string: "123a"

范例：观察double转换

public class Demo {
	public static void main(String args[]) {
		String str = "1.4";
		double temp = Double.parseDouble(str);
		System.out.println(temp * 2);
	}
}

范例：观察boolean转换

public class Demo {
	public static void main(String args[]) {
		String str = "true";
		Boolean flag = Boolean.parseBoolean(str);
		if (flag) {
			System.out.println("满足");
		} else {
			System.out.println("不满足");
		}
	}
}

在Boolean进行转换的过程里面，如果要转换的字符串不是true或者是false，那么将统一按照false进行处理。

现在既然实现了字符串变为基本数据类型的操作，那么也一定可以实现基本数据类型变为字符串的操作，对于此类操作有两种做法：

· 操作一：任何基本数据类型与字符串使用了“+”操作之后都表示变为字符串

public class Demo {
	public static void main(String args[]) {
		int num = 100;
		String str = num + "";// 变为String
		System.out.println(str.replaceAll("0", "."));
	}
}

这样的操作虽然可以简单的完成，但是会存在有垃圾问题。

· 操作二：public static String valueOf(数据类型 变量)；

public class Demo {
	public static void main(String args[]) {
		int num = 100;
		String str = String.valueOf(num);
		System.out.println(str.replaceAll("0", "."));
	}
}

这样的转换不会产生垃圾，所以在开发时往往会使用以上做法。