Java读书笔记二（封装类）

   

 1.介绍

都知道java中基本数据类型有非常多，比方string，int……，可是基本数据类型与对象之间是不同的。但非常多情况下，我们希望将基本数据类型当作对象使用，这时候就须要用到封装类。

 2.封装类对象基本知识

2.1.首先封装类对象有自己的几个特性。

1.对象不可变，是属于final类型的对象

2.不同意继承

2.2.怎样创建封装类对象

在java中每种数据类型都由其相应的封装类。

每种封装类都有其各自的构造器。

<span style="font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.Fengzhuanglei;

public class Sample12_1 {
	public static void main(String[] args)
	{
		//Character类构造器	
		Character c1=new Character('H');
		//打印Character对象
		System.out.println("Character封装类对象封装的值为："+c1+"。");
		//Boolean类构造器
		Boolean b1=new Boolean(true);
		Boolean b2=new Boolean("TRUE");
		Boolean b3=new Boolean("FaLsE");
		Boolean b4=new Boolean("HaHa!!!");
		//打印4个Boolean对象
		System.out.print("Boolean封装类对象封装的值为"+b1);
		System.out.print("、"+b2);
		System.out.print("、"+b3);
		System.out.println("、"+b4+"。");
		//Float类构造器
		Float f1=new Float(12.56f);
		Float f2=new Float(12.56);
		Float f3=new Float("12.56f");
		//打印3个Float对象
		System.out.print("Float封装类对象封装的值为："+f1);
		System.out.print("、"+f2);
		System.out.println("、"+f3+"。
");
		//其它类型构造器
		Integer i1=new Integer(50);
		Integer i2=new Integer("50");
		System.out.print("Integer封装类对象封装的值为："+i1);
		System.out.println("、"+i2+"。");
		Integer i3=new Integer("qq50");
	}
}
</span></span>

也能够採用静态工厂的方法来创建

<span style="font-size:18px;"><span style="font-family:SimSun;font-size:18px;">package com.Fengzhuanglei;

public class Sample12_8 {
	public static void main(String[] args)
	{
		//将字符串转换为基本数据类型
		double d1=Double.parseDouble("36.8");
		System.out.println("将字符串形式转换为double值，其值为："+d1);
		//用基本数据类型创建对象
		Double d2=Double.valueOf(36.8);
		System.out.println("用double值创建了Double对象，其值为："+d2);
		//用字符串类型创建对象
		Double d3=Double.valueOf("36.8");
		System.out.println("用字符串创建了Double对象。其值为："+d3);
		//将字符串以三进制形式转换为基本数据类型值
		int i1=Integer.parseInt("1011010",3);
		System.out.println("将字符串以三进制形式转换为int值，其值为："+i1);
		//用字符串以三进制形式创建对象
		Integer i2=Integer.valueOf("1011010",3);
		System.out.println("用字符串以三进制形式创建Integer对象，其值为："+i2);
	}
}
</span></span>

 3.数据类型之间的转换

3.1.基本数据类型→→→→→→字符串

非静态方法

我们经经常使用到的非静态方法莫过于ToString方法。该方法没有參数，返回值为String类型的字符串操作

<span style="font-size:18px;">package com.Fengzhuanglei;

import java.math.BigInteger;

public class Sample12_14 {
	public static void main(String[] args) {
		// 创建了两个BigInteger对象bi1与bi2
		BigInteger bi1 = new BigInteger("111119223372036854775808");
		BigInteger bi2 = new BigInteger("111110000000000000000000");
		// 声明了一个BigInteger引用bi3
		BigInteger bi3;
		System.out.println("bi1 = " + bi1 + "。bi2 = " + bi2 + "。");
		// 使用加操作
		bi3 = bi1.add(bi2);
		System.out.println("bi1 + bi2 = " + bi3);
		// 使用减操作
		bi3 = bi1.subtract(bi2);
		System.out.println("bi1 - bi2 = " + bi3);
		// 使用乘操作
		bi3 = bi1.multiply(bi2);
		System.out.println("bi1 * bi2 = " + bi3);
		// 使用除操作
		bi3 = bi1.divide(bi2);
		System.out.println("bi1 / bi2 = " + bi3);
		// 使用求余操作
		bi3 = bi1.mod(bi2);
		System.out.println("bi1 % bi2 = " + bi3);
		// 使用取负数操作
		bi3 = bi1.negate();
		System.out.println("-bi1  = " + bi3);
		// 取bi1的符号
		if (bi1.signum() == 1) {
			System.out.println("bi1 为正数。其符号为'+'！
！
！");
		}
		// 比較bi1与bi2的大小
		if (bi1.compareTo(bi2) > 0) {
			System.out.println("bi1 大于 bi2 。。！
");
		}
	}
}
</span>

静态方法

静态方法就是採用不可变的封装类对象自身的方法，详细例如以下

<span style="font-size:18px;">package com.Fengzhuanglei;

public class Sample12_5 {
	public static void main(String[] args)
	{
		//声明原始值
		boolean bl=false;
		byte b=-23;
		char c='G';
		short s=128;
		int i=20;
		long l=49L;
		float f=32.3F;
		double d=46.5;
		//打印转换前的原始值
		System.out.println("=======================转换前的"
		                                      +"原始值=========================");
		System.out.println("bl="+bl+", b="+b+", c="+c+", s="+s+", i="+i+", l="+l+", f="+f+", d="+d);		
		//声明5个字符串引用
		String s1,s2,s3,s4,s5;
		//Boolean封装器提供的静态转换字符串方法
		System.out.println("=======================Boolean"
		                                      +"封装类=========================");
		s1=Boolean.toString(bl);
		System.out.println("bl转换后的结果为："+s1);
		//Byte封装器提供的静态转换字符串方法
		System.out.println("=======================Byte"
		                                   +"封装类============================");
		s1=Byte.toString(b);
		System.out.println("b转换后的结果为："+s1);
		//Short封装器提供的静态转换字符串方法
		System.out.println("=======================Short"
		                                    +"封装类===========================");
		s1=Short.toString(s);
		System.out.println("s转换后的结果为："+s1);
		//Character封装器提供的静态转换字符串方法
		System.out.println("=======================Character"+
		                                         "封装类=======================");
		s1=Character.toString(c);
		System.out.println("c转换后的结果为："+s1);
		//Integer封装器提供的静态转换字符串方法;
		System.out.println("=======================Integer"+
		                                       "封装类=========================");
		s1=Integer.toString(i);
		//将i值以四进制输出
		s2=Integer.toString(i,4);
		s3=Integer.toBinaryString(i);
		s4=Integer.toOctalString(i);
		s5=Integer.toHexString(i);
		System.out.println("i转换后为"+s1+" 转换为四进制后为"
		                                             +s2+" 转换为二进制后为"+s3);
		System.out.println("转换为八进制后为"+s4+" 转换为十六进制后为"+s5);
		//Long封装器提供的静态转换字符串方法
		System.out.println("=======================Long"
		                                   +"封装类============================");
		s1=Long.toString(l);
		//将l值以四进制输出
		s2=Long.toString(l,7);
		s3=Long.toBinaryString(l);
		s4=Long.toOctalString(l);
		s5=Long.toHexString(l);
		System.out.println("l转换后为"+s1
		                   +" 转换为七进制后为"+s2+" 转换为二进制后为"+s3);
		System.out.println("转换为八进制后为"+s4+" 转换为十六进制后为"+s5);
		//Float封装器提供的静态转换字符串方法
		System.out.println("=======================Float"
		                                   +"封装类===========================");
		s1=Float.toString(f);
		s2=Float.toHexString(f);
		System.out.println("f转换后为"+s1+" 转换为十六进制后为"+s2);
		//Double封装器提供的静态转换字符串方法
		System.out.println("=======================Double"
		                                    +"封装类==========================");
		s1=Double.toString(d);
		s2=Double.toHexString(d);
		System.out.println("d转换后为"+s1+" 转换为十六进制后为"+s2);
	}
}
</span>

3.2.字符串→→→→→→基本数据类型

相同字符串与基本数据类型之间的转换也能够採用静态和非静态方法来操作

非静态方法

须要将封装类对象的值提取时。一般採用的是xxxValue中的一系列方法，详细例如以下。

<span style="font-size:18px;">package com.Fengzhuanglei;

public class Sample12_6 {
	public static void main(String[] args) {
		// 将封装的int值转换为其它数值类型
		Integer integer = new Integer("52");
		
		byte b = integer.byteValue();
		double d = integer.doubleValue();
		System.out
				.println("将字符串“52”转换为byte值以及double值，其值为：" + b + "、" + d + "。");
		// 将封装的float值转换为其它数值类型
		Float floatF = new Float("25.5");
		float f = floatF.floatValue();
		d = floatF.doubleValue();
		System.out.println("将字符串“52”转换为float值以及double值。其值为：" + f + "、" + d
				+ "。");
	}
}
</span>

静态方法

假设採用静态方法的话。一般採用parseXXX类似的方法。详细例如以下。

<span style="font-size:18px;">package com.Fengzhuanglei;

public class Sample12_7 {
	public static void main(String[] args) {
		// 将字符串转换为基本数据类型boolean
		boolean b = Boolean.parseBoolean("FaLse");
		System.out.println("将字符串“FaLse”成功转换为boolean值，其值为：" + b);
		// 将字符串转换为基本数据类型double
		double d = Double.parseDouble("35.8");
		System.out.println("将字符串“35.8”成功转换为double值，其值为：" + d);
		// 将字符串中的数字依照二进制的方式解析，并转换为int基本数据类型
		int i = Integer.parseInt("10010111", 2);
		System.out.println("将字符串“10010111”成功依照二进制形式转换int值，其值为：" + i);
		// 将字符串中的数字依照三进制的方式解析，并转换为long基本数据类型
		long l = Long.parseLong("10010111", 3);
		System.out.println("将字符串“10010111”成功依照三进制形式转换long值，其值为：" + l);
	}
}
</span>

 4.大型数值计算

在我们寻常的开发中可能有时算数的范围超过了int或者long的范围，此时该怎么办？在java中专门为我们提供了用来进行不大小限制计算的类。

1.BigInteger：用来计算整数之间的操作

<span style="font-size:18px;">package com.Fengzhuanglei;

import java.math.BigInteger;

public class Sample12_14 {
	public static void main(String[] args) {
		// 创建了两个BigInteger对象bi1与bi2
		BigInteger bi1 = new BigInteger("111119223372036854775808");
		BigInteger bi2 = new BigInteger("111110000000000000000000");
		// 声明了一个BigInteger引用bi3
		BigInteger bi3;
		System.out.println("bi1 = " + bi1 + "，bi2 = " + bi2 + "。
");
		// 使用加操作
		bi3 = bi1.add(bi2);
		System.out.println("bi1 + bi2 = " + bi3);
		// 使用减操作
		bi3 = bi1.subtract(bi2);
		System.out.println("bi1 - bi2 = " + bi3);
		// 使用乘操作
		bi3 = bi1.multiply(bi2);
		System.out.println("bi1 * bi2 = " + bi3);
		// 使用除操作
		bi3 = bi1.divide(bi2);
		System.out.println("bi1 / bi2 = " + bi3);
		// 使用求余操作
		bi3 = bi1.mod(bi2);
		System.out.println("bi1 % bi2 = " + bi3);
		// 使用取负数操作
		bi3 = bi1.negate();
		System.out.println("-bi1  = " + bi3);
		// 取bi1的符号
		if (bi1.signum() == 1) {
			System.out.println("bi1 为正数。其符号为'+'！！
！
");
		}
		// 比較bi1与bi2的大小
		if (bi1.compareTo(bi2) > 0) {
			System.out.println("bi1 大于 bi2 ！！！");
		}
	}
}
</span>

2.BigDecimal：用来精确的计算浮点数之间的操作

<span style="font-size:18px;">package com.Fengzhuanglei;
import java.math.*;
public class Sample12_16
{
	public static void main(String[] args)
	{
		//分别创建值为3.8与0.7的BigDecimal对象bd1与bd2
		BigDecimal bd1=new BigDecimal("3.8");
		BigDecimal bd2=new BigDecimal("0.7");
		//创建值为3.800的BigDecimal对象bd3
		BigDecimal bd3=new BigDecimal("3.800");
		//声明一个BigDecimal类型的引用bd4
		BigDecimal bd4;
		//打印对象bd1、bd2与bd3中封装的值
		System.out.println("bd1 = "+bd1+"，bd2 = "+bd2+"。bd3 = "+bd3+"。");
		//使用加操作
		bd4=bd1.add(bd2);
		System.out.println("bd1 + bd2 = "+bd4);
		//使用减操作
		bd4=bd1.subtract(bd2);
		System.out.println("bd1 - bd2 = "+bd4);
		//使用乘操作
		bd4=bd1.multiply(bd2);
		System.out.println("bd1 * bd2 = "+bd4);
		//使用除操作
		bd4=bd1.divide(bd2,BigDecimal.ROUND_HALF_DOWN);
		System.out.println("bd1 / bd2 = "+bd4);
		bd4=bd3.divide(bd2,BigDecimal.ROUND_HALF_DOWN);
		System.out.println("bd3 / bd2 = "+bd4);		
		//将bd1与bd2进行比較
		bd2=new BigDecimal("3.800");
		if(bd1.compareTo(bd2)==0)
		{
			System.out.println("bd1 = "+bd1+" bd2 = "+bd2+" 则bd1与bd2是相等的！
！");
		}			
	}
}
</span>

 5.总结

本篇主要介绍了java中基本数据类型之间的转换，通常是通过封装类来进行相互之间的转换。另外在做数据算法时。java也为我们提供了方面的函数进行操作。