JAVA的基础知识

JAVA基础知识

关键字：

Java关键字是Java语言保留供内部使用的,如class用于定义类。 关键字也可以称为保留字,它们的意思是一样的。

				关键字基本都是由小写字母组成。 		
			    Java语言规定关键字不能作为标识符。 		 
			   目前共有50个Java关键字。
               其中，"const"和"goto"这两个关键字在Java语言中并没有具体含义。
               Java语言把它们列为关键字。
               只是因为"const"和"goto"是其他某些计算机语言的关键字。

---

标识符：

​ 标识符:Java对包、类、方法、参数和变量等要素命名时使用的字符序列称为标识符。
​ 简而言之就是给类,接口,抽象类,接口的实现类,常量,变量,方法等元素取名字。

/*规则:必须准守
	1.由字母,数字,下划线_,美元符号$组成
	2.不能以数字开头
	3.Java对于大小写严格区分
	4.不能是Java中的关键字
	
规范: 
	1.见名知意
	2.不允许使用中文和拼音
	3.满足驼峰命名法(待会讲)
	4.命名的长度最好不要超过31个字符

提供一套开发中标准规范:
包,类,抽象类,接口,接口的实现类,变量,方法,常量
包(文件夹) 
	1.一般都是公司的域名反写
	2.所有单词使用.隔开
	3.每个单词都是小写组成
	eg: www.sxt.com  com.sxt  www.baidu.com  com.baidu.test
类(满足抬头骆驼) class
	1.所有单词的首字母大写,其他字母小写
	eg: HelloWorld IdentifiedDemo
接口: (满足抬头骆驼) interface
	1.所有单词的首字母大写,其他字母小写
	2.一般会在第一个单词的前面加上一个大写的I 
	eg: IStudent ITeacher
接口的实现类 (满足抬头骆驼)
	1.所有单词的首字母大写,其他字母小写
	2.一般都会在最后一个单词后面加上 Impl  implements
	eg: StudentImpl
抽象类(满足抬头骆驼)
	1.所有单词的首字母大写,其他字母小写
	2.在单词的开头一般都会加上 Abs abstract
	AbsStudent
枚举和注解: 和类一模一样
====================================
变量 (满足低头骆驼)
	1.第一个单词首字母小写,其他单词首字母大写
	2.一般都是名词
	eg: studentName studentScore  score  totalScore
方法(满足低头骆驼)
	1.第一个单词首字母小写,其他单词首字母大写
	2.一般都是动词
	eg: getTotalScore getAverageScore getMaxValue getMinValue main
=====================================
常量: 
	1.所有单词都是大写
	2.每一个单词都使用_隔开
	eg: MAX_VALUE  MIN_VALUE PI JAVA_HOME
	
面试题: 说一说你Java的命名规范
*/

---

注释：

单行注释 // (绿色)
多行注释 /* / (绿色)
注意：多行注释不能嵌套
文档注释 /* */ (蓝色)
注意：1、文档注释可以使用javadoc工具来生成API，后续会讲解。
2、初学者一定要养成良好的习惯，先写注释，再写代码。
3、在开发当中注释不能随便删。

​ 注释: 为程序进行解释说明,不会被JVM执行
​

/*
注释分类:
	1.单行注释  
		// 
	2.多行注/x x/
	3.文档注释(后面在讲解面向对象的时候详细讲解) javadoc
		/xx  x/
	
注意: 
	1.注释不能够嵌套
	2.注释不要随意的删除
	3.养成一个好的习惯,先写注释,再写代码,
	能够培养一个程序员的逻辑思维,以及代码的可读性
		
注释的好处:
	1.能够提高程序的可读性释	
	2.开发中工作的交接 (文档注释)
	3.程序调试 (后期还会使用Debug断点调试)
	
调试错误的方式
	1.看错误日志 (后面讲解异常的时候详细讲解 Throwable类)
	2.Debug调试
	3.添加测试语句 System.out.println("");
	4.注释
	5.百度、Google
	*/
	// 这个类是一个注释的测试案例
public class ZhuShi {
/*
	1.该方法是主方法
	2.作为程序的入口
	3.当我们使用java命令工具的时候，该方法被JVM直接调用执行
*/
public static void main(String[] args) {
	// 向控制台输出一句字符串 HelloWorld
	/*System.out.println("HelloWorld1");
	System.out.println("HelloWorld2");*/
	// System.out.println("HelloWorld3");
	// System.out.println(10/0);
	System.out.println("HelloWorld4");
	System.out.println("HelloWorld5");
	
    }
}

常量和变量：

一. 常量变量定义。

在程序中存在大量的数据来代表程序的状态，其中有些数据在程序的运行过程中值会发生改变，有些数据在程序运行过程中值不能发生改变，这些数据在程序中分别被叫做变量和常量。
变量举例：
在2D游戏程序中，需要代表人物的位置，则需要2个变量，一个是x坐标，一个是y坐标，在程序运行过程中，这两个变量的值会发生改变
常量举例：
代表常数，便于程序的修改（例如：圆周率的值）
增强程序的可读性（例如：常量UP、DOWN、LEFT和RIGHT分辨代表上下左右，其数值分别是1、2、3和4）
在实际的程序中，可以根据数据在程序运行中是否发生改变，来选择应该是使用变量代表还是常量代表。

二. 常量

/*
	为什么需要有常量?	
		PI 一周有7天 
	常量: 在程序的执行过程中,其值不会发生改变的量
	常量的分类:
	一、字面值常量
		整型常量  进制转换(课后自学)
			二进制 由0,1组成,由0b开头 0101010101 也可以使用下划线分割数字
			八进制 由0~7组成,由0开头 37  
			十进制 由0~9组成,默认就是十进制
			十六进制 由0~9,A,B,C,D,E,F 组成,由0x开头
			
			计算器可以实现四种进制的转换
			Integer类可以实现计算机能够表示范围内(36进制)的进制转换
			自己手动计算可以计算任意范围的进制转换
			
		小数常量
			0.2F float类型的小数常量
			0.2D double类型的小数常量
			后面讲解数据类型的时候介绍float和double
		布尔常量 (表示现实世界两种对立的状态)
			只能取两个值 
			true false 
			0000 0000
			0000 0001 
		字符常量
						今晚攻打高老庄 -> 20 61 31 45 71 28 33-> 10101010 二进制  密码表（编码表 UTF-8 GBK ISO-8859-1 ...）
			什么是字符?字符的本质是什么？数字 整数   a 97 0 48 A 65	今晚攻打高老庄  27 48 65 32 89 98 36		
			什么是字节?字节本质是什么? 数字 数据传输的最基本单位 
			a 1 张 换行 制表符 都是字符 65535   
			1字符 在 GBK a 97 1个字节
			1字符 在 GBK 中 2个字节
			1字符 在 UTF-8 中 占3个字节
			
			字符在计算机中存储本质还是数字
			
			1byte = 8bit  0001 0001
			1kb = 1024byte 
			1mb = 1024kb
			1gb = 1024mb
			1tb = 1024gb
			0000 0000
			0  0 1 2
			00 00 01 10 11 4
			000 8
			00000000  256 ASCII码表
			00000000 00000000 65536
			
			2个字节足够表示全世界所有的字符 
			
			11 00 10 01
			1bit 能够表示多少种状态 2种  0 1   
			2bit 4  10 01 11 00
			3bit 8   
			8bit 256
			16bit 65536  
			16bit = 2byte
			
			Java使用2个字节表示一个字符
			0000 0000 0000 0000 65536
			
			一般2个字节表示一个汉字GBK
			GBK UTF-8 Unicode ISO-8859-1 ASCII  
			普通字符
			0  48
			A  65
			a  97
			转义字符 			
			\n 换行
			\r
			\r\n
			\t
			
			1.字符常量由 '' 包裹
			2.里面只能够有一个字符
			3.转义字符可以由两个字符组成,第一个是\
			\uffff
			
			先记住常见的字符编码:
				a 97  b 98
				A 65  B
				0 48
				
				\t 制表
				\n 换行
				\r\n 换行
				\'
				\\
				\"
				
		字符串常量
			1.由双引号包裹
			2.里面可以有一个字符也可以有多个字符
			3.字符串里面可以是空串
		null常量
			表示的是引用类型的常量,会在后面讲解面向对象的时候详细讲解
			
		二、自定义常量 后面讲解面向对象的时候讲解 (使用 frinal 关键字修饰的 变量 称为常量)
		
	注意:
		1.System.out.println();输出的都是数值的十进制
		2.默认整型常量默认是 int 类型,并且只能够是int类型
		3.默认小数类型就是 double 类型
		4.字符的数量不会超过65535
		5.windows系统的换行符是 \r\n \n \R 
		6.计算机最多能表示36进制 (Integer类可以轻易地实现进制转换)
	
	补充知识点:
	进制转换的5种情况  3 ——> 9
	1.其他进制 -> 十进制
	2.十进制 -> 其他进制
	3.X进制 -> Y进制
	4.十进制和二进制的快速转换 8421BCD码  
	5.二进制和八进制和十六进制之间的快速转换法 拆分分组法
*/
public class ConstantDemo {
	
	// 自定义常量 后面讲
	public static final int MAX_SCORE = 100;
	
	public static void main(String[] args){
		System.out.println(10);
		System.out.println(0b1001);
		System.out.println(0b1001_1100_0010_1010);
		System.out.println(037);
		System.out.println(0xFFFF);
		
		System.out.println(2.5);
		System.out.println(2.5F);
		
		// System.out.println(true + 1);
		System.out.println('a');
		System.out.println('0');
		System.out.print('A');
		System.out.print('\t');
		System.out.print('C');
		System.out.print('\'');
		System.out.print('\\');
		System.out.println('\uAA61');// 0000 0000 0000 0000
		// System.out.print('');
		
		System.out.println("");
		System.out.println("HelloWorld");
		
		System.out.println("\"");
		System.out.println("'");
	}
	
}

三. 变量。

/*
	变量: 在程序的执行过程当中,其值可以发生改变的量,类似于数学的未知数X
	
	变量的本质 : 就是一个地址
	
	变量的内存分配
		int x = 10;
		int x; // 1.声明
		x = 10; // 2.赋值
		System.out.println(x); // 3.使用
	
	变量的定义:
		变量的三要素:
			1.声明
			2.赋值
			3.使用
		注意:
			1.变量一定要先声明再赋值再使用
			2.变量不能够重复定义
			3.变量不能够连续定义 int a = b = c = 10; 
			4.建议一行只写一条语句
			
	数据类型: Java是一门强类型语言,针对每一种数据都提供了对应的类型
				int x; byte short int long
				float f;
			  JavaScript是一门弱语言类型,只有一种数据类型的声明,就是var
				var x;
				var f;
				
	数据类型的分类:
		数值的表示方式:
			65536
			0000 0000
			最高位是符号位: 1表示负数，0表示整数
			其他位是数值位: 
		八大基本数据类型
			整数类型			字节数				取值范围
				byte			  1					0000 0000 -128~127 
				short			  2					0000 0000 0000 0000 -32768 ~ 32767
				int 			  4					-2^31 ~ 2^31 - 1
				long			  8					-2^63 ~ 2^63 - 1
			小数类型
				float			  4					-3.403E38 ~ 3.403E38
				double			  8					-1.798E308~1.798E308
				
				0000 0000 0000 0000 0000 0000 0000 0000 
				注意: 
					1.虽然小数表示的范围特别大,但是永远不能够存储所有的小数,因为小数存在无限不循环小数
					2.同样是4/8个字节的小数类型取值范围大于整数类型,原因是小数和整数的存储形式不一样
					3.在处理金融相关项目的时候,小数的计算要求精度非常高,那么使用float或者double来表 					示会出现精度问题,后期考虑使用BigDecimal来处理 
			布尔类型
				boolean			  1					0000 0000 false / 0000 0001 true 
			字符类型
				char			  2					0 ~ 65535 Java使用Unicode编码的范围
		引用数据类型 后面讲解面向对象详细说明
			类 (class) 
			接口 (interface)
			数组 ([])
			
		面试题: 
			1.String是基本数据类型吗？ 引用数据类型
			2.说一说Java的数据类型   
			3.数组是什么类型?
	
*/

四. 数据类型转换：

/*
	数据类型转换
	
	类型转换的依据: 取决数据的取值范围
	
	byte -> short -> int -> long -> float -> double
			char  ->
			
	注意:
		1.boolean类型不能够参与类型转换
		2.char和byte/short只有交集关系,没有子集关系
		
	1.自动类型转换
		将小类型的数据转换成大类型数据,系统会自动转换
	
	2.强制类型转换
		将大类型的数据转换成小类型的数据,会编译报错
		解决办法: 强制类型转换	
		格式:
			目标类型 变量名 = (目标类型) 被转换的类型;
		强制类型转换会出现的问题:
			1.精度的丢失
			2.数据的溢出
			
	3.byte/short/char特例
	
	4.byte/short 和 char 参与转换,都需要强制类型转换
	
	5.表达式类型提升
		当表达式的运算符两边类型不一致的时候,结果的类型会自动向高类型转换
		
	6.当byte short char 之间参与运算的时候,底层都会转换成int类型来计算
	
	7.boolean类型不能够参与运算和转换
	
	8.字符串在参与运算中的转换问题,字符串相加是拼接操作
	
	9.变量计算和常量计算问题
		变量相加,系统无法判断具体的结果
		常量相加,在编译时期,系统就会运算结果	
*/
public class DataTypeConvertDemo {
	public static void main(String[] args){
		
		//25是int类型，可以转float类型。
		float f = 25;
		System.out.println(f);
		
		//225属于int类型，转byte类型需要加（byte）
		/* byte b =225;
		System.out.println(b); */
		
		//3.5f属于float类型，可以转double类型。
		double d = 3.5f;
		System.out.println(d);
		
		//（float）4.5可以强转double类型。
		float f2 =(float)4.5;
		System.out.println(f2);
		
		//(int)2.5可以强转double类型，精度会丢失。
		int i =(int)2.5;
		System.out.println(i);
		
		//(byte)130可以强转int类型，会导致数据溢出。
		byte b =(byte)130;
		System.out.println(b);
		
		//32768默认是int类型，需要强转，而且超出了short范围（-32768——32767）
		/* short s =(32768);
		System.out.println(s); */
		
		//当byte short char 之间参与运算的时候,底层都会转换成int类型来计算，97在char中刚好是a。
		byte b2 = 97;
		char ch =(char)b2;
		System.out.println(ch);
		
		//'1'属于char字符，可与byte之间强转，'1'在char中是49，所以最终输出49。
		char ch2 ='1';
		byte b3 =(byte)ch2;
		System.out.println(b3);
		
		//当表达式的运算符两边类型不一致的时候,结果的类型会自动向高类型转换。i+d属于double类型，转int需要强转。
		/* int i2 = 25;
		double d2 = 6.5;
		int i3 =i2+d2;
		System.out.println(i3); */
		
		//b属于变量，不确定值得大小,不可运行。
		/* byte b4 = 97;
		char ch3 = b4 + 1;
		System.out.println(ch3); */
		
		//不可以，先输入在运算，不知道63.5*2是否超出byte范围。
		/* byte b5 = 63.5 * 2;
		System.out.println(b5); */
		
		//boolean类型不能够参与运算和转换
		/* boolean bool = false;
		int i4 = (int)bool;
		System.out.println(i4); */
		
		//字符串在参与运算中的转换问题,字符串相加是拼接操作。可将'-'改为'+'。
		/* String str ="2"- 1;
		System.out.println(str); */
		
		//字符串在参与运算中的转换问题,字符串相加是拼接操作。
		System.out.println(22 + 2 + "2" + 2 ); 
		
		//当byte short char 之间参与运算的时候,底层都会转换成int类型来计算,b6+s属于同类型转换。
		byte b6 = 10;
		short s = 20;
		int i5 = b6 + s;
		System.out.println(i5);
		
		//int转byte需要强转。
		/* int b7 = 10;
		int b8 = 20;
		byte b9 = b7 + b8;
		System.out.println(b9); */
		
		//当byte short char 之间参与运算的时候,底层都会转换成int类型来计算,bb+ss属于int类型。
		/* byte bb = 65;
		short ss = 1;
		char ch4 = bb + ss; 
		System.out.println(ch4); */
		
		long a ='\u00FF';
		System.out.println(a);
		
		double d3 = 0.7E-3;
		System.out.println(d3);
		
		/* short s2 = 1;s2 = s2 + 1;
		System.out.println(s2);  */
		
		short s2 = 1;s2 += 1;
		System.out.println(s2); 

		char ch5 = '中';
		System.out.println(ch5);
	}
}

---

运算符：

一. 分类。

• Java 语言支持如下运算符：
  算术运算符: +，-，，/，%，++，–
  赋值运算符 =
  扩展赋值运算符:+=，-=，=，/=
  关系运算符: >，<，>=，<=，==，!=
  逻辑运算符: &&，||，!
  位运算符: &，|，^，~ ， >>，<<，>>> (了解！！！)
  条件运算符（三目运算符） ？ ：

二. 算术运算符: （+，-，*，/，%，++，–）

/*
	自增自减运算符
		
	++ -- 属于单目运算符
	
	++ 表示自增1
	-- 表示自减1
	
	分为
		单独使用
			表示自增或者自减,没有任何区别
		参与运算
			如果++放在操作数的左边,就表示先自增再参与运算
			如果++放在操作数的右边,就表示先参与运算,再自增或者自减1
			
	8.请计算：
	a=3，b=4；
	(1):(a++)/3+(--b)*2-(a--)%6+(b++)*3-(b--)
	a=3,b=4
	
	(2):(++b)*2-(a--)%4+(a++)*5-(--b)/2+(--a)
	a=3,b=4
	a=2 3 2
	b=5 4
	结果=5*2-3%4+2*5-4/2+2=10-3+10-2+2=17
	
	(3):(a--)*6+(b++)/3-(--a)*2-(--b)*2+(++a)
	a=3 2 1 2
	b=4 5 4
	结果=3*6+4/3-1*2-4*2+2=18+1-2-8+2=11
	
	int x = 3;
	int res = (x++)%(++x);
	请推断res,x此时的值。
	x=3 4 5
	res=3
	
	练习：
     1.int n = 5;n = ++n + ++ n;求n=?
	 n=5 6 7
	 结果n=6+7=13
     2.int n = 3;n = ++n + n ++;求n=?
	 n=3 4 5
	 结果n=4+4=8
	 
*/

三. 赋值运算符：（=） 和扩展赋值运算符:（+=，-=，*=，/=）

   /*
	赋值运算符
	
	= : 这个等于号在Java中表示赋值的意思,真正数学意义上的相等是 ==,在JavaScript中还有===

	扩展赋值运算符:
		+= -= *= /= %= 
		
	面试题:short s1 = 1;?s1 = s1 + 1;有什么错? short s1 = 1; s1 += 1;有什么错??
	前者编译失败,short和int类型计算结果是int类型,将int类型赋值给short类型,需要强制类型转换
	后者编译通过,因为使用扩展赋值运算符系统会自动帮我们强制类型转换
	
	技巧: 如何交换两个数?
	int x = 10;
	int y = 20;
	1.定义中间变量temp
	2.使用异或来进行交换两个数的位置  (位运算符学习)
*/

四. 关系运算符: >，<，>=，<=，==，!=

运算符	含义	示例
==	等于	a==b
!=	不等于	a!=b
>	大于	a>b
<	小于	a<b
>=	大于或等于	a>=b
<=	小于或等于	a<=b

五. 逻辑运算符: （&&，||，! ）

运算符	含义	示例
&	逻辑与	A & B
|	逻辑或	A | B
^	逻辑异或	A ^ B
!	逻辑反	! A
||	短路或	A || B
&&	短路与	A && B

/*
	逻辑运算符
		作用: 连接多个boolean类型的表达式  
			boolean类型的表达式1 逻辑运算符 boolean类型的表达式2 逻辑运算符 boolean类型的表达式3
	
	& 按位与
	| 按位或
	^ 异或
	
	&& 短路与
	|| 短路或
	
	！ 非
	
	与: 有一个为false结果为false
		如果都为true结果才为true
		
	或: 有一个为true结果为true
	    如果两个都为false结果才为false
	
	面试题: & 和 && 的区别
		& 表示按位与,无论什么情况都会同时计算运算符两边的表达式
		&& 表示短路与, 如果前面的表达式为false,那么无论后面结果如何,都不会去计算后面表达式的值
		&&开发中使用,&基本不用
		&常用于位运算,位运算的效率比普通运算要高很多 
		1001 & 0110 = ？
			1 0 0 1
		&	0 1 1 0
		-----------
			0 0 0 0
			
		1001 | 0110 = ？
			1 0 0 1
		|	0 1 1 0
		-----------
			1 1 1 1
			
	^ : 相同为false,不同为true
	
		1001 ^ 0110 = ？
			1 0 0 1
		^	0 1 1 0
		-----------
			1 1 1 1
			
	! : 取反
		当!的个数是奇数个的时候,结果相反
		当!的个数是偶数个的时候,结果不变
	
*/

六. &，|，^，~ ， >>，<<，>>> (了解！！！)

位运算符是对操作数以二进制比特位为单位进行操作和运算，操作数和结果都是整型数。
如果操作的对象是char、byte、short，位移动作发生前其值会自动晋升为int，运算结果也为int。

运算符	含义	示例
~	按位非（NOT）/取反	b = ~a
&	按位与（AND）	c = a & b
|	按位或（OR）	c = a | b
^	按位异或(相同为0相异为1)	c = a ^ b
>>	右移；左边空位补最高位即符号位	b = a >> 2
>>>	无符号右移，左边空位补0	b = a >>> 2
<<	左移；右边空位以补0	b = a << 1

七. x ? y : z

/*
	条件运算符(三目运算符) ？:
	
	格式: X ? Y : Z
		  X表达式必须是boolean类型的表达式
		  执行流程:
			首先计算X表达式的结果, 如果X的结果为true, 那么整个表达式的结果就是Y的值
								   如果X的结果为false,那么整个表达式的结果就是Z的值
	
	1.关于三目运算符嵌套的问题
	2.关于三目运算符值的类型问题
	
*/

八. 表达式与运算符优先级。

/*
	表达式: 符合一定语法规则的运算符和操作数的式子
	
	运算符: 算数运算符,赋值运算符,关系运算符,逻辑运算符,位运算符(了解), 三目运算符
	操作数: 变量或者常量
	
	a + b  a * 6 4 - 3 int a = 10; 
	表达式的分类:
		按照复杂程度来分:
			简单表达式: 只有一个运算符的表达式 a + b  a * 6 4 - 3
			复杂表达式: 两个或者两个以上的运算符组成的表达式 a > b && a < b
			如果复杂表达式就必须要知道运算符的优先级
		
		按照运算符两边的操作数来分
			单目 双目 三目
			+5 3+a x?y:z
			
		按照名称来分
			a + b 算数表达式
			
	表达式的值: 整个表达式的结果
				int a = 30; int b = 40; a * b
	表达式的值的类型: 
				int a = 30; int b = 40; a * b
			
	学习复杂表达式:
		(a - b) * c - 4     
		i < 30 && i % 10 != 0 
	
	运算符的优先级
		1.有括号先计算括号里面的
		2.单目运算符 > 双目运算符 > 三目运算符
		3.算数运算符(* / % > + -) > 关系运算符(> <... > == !=) > 逻辑运算符(&& > ||) > 条件运算符 > 赋值运算符
		4.如果运算符的优先级相同,从左至右即可
		5.+ - > ++ -- !
	技巧: 如果针对特别复杂的表达式,可以根据运算符的优先级规律,然后使用()改变优先级,提高程序的可读性
*/

---

交换两个数图解：

练习：

/*
	练习1：银行账户存储1000元，年利率是0.05，计算一年后账户余额？
	(小数是double类型)
	要  求：使用变量保存数据

	注意:
		+ 号拼接任意类型的数据结果都是字符串类型
*/
public class Practice01 {
	public static void main(String[] args) {
		double account = 1000.0;
		double rate = 0.05;
		account = account + account * rate;
		System.out.println("一年后账户余额: " + account);
	}
}

/*
	练习2：使用变量存储数据，实现个人简历信息的输出:
	姓名，年龄，工作年限，技术方向、兴趣爱好。
	要 求： 使用变量保存数据
*/
public class Practice02 {
	public static void main(String[] args) {
		String name = "隔壁老王";
		int age = 38;
		int workYears = 5;
		String techDirection = "Java工程师";
		String hobby = "写代码";
		
		// 方式一: 单个输出
		System.out.println(name);
		System.out.println(age);
		System.out.println(workYears);
		System.out.println(techDirection);
		System.out.println(hobby);
		
		// 方式二: 拼接输出
		System.out.println("大家好我叫" + name + ",我今年" + age + "岁了,我的工作年限" + workYears);
		
		// 方式三: 格式化输出 格式化占位符 %s 字符串 %d 整数 %f 小数 %b boolean %c 字符 %n 换行
		System.out.format("大家好我叫%s,我今年%d岁了,我的工作年限是%d年了,我的技术方向是%s,我的兴趣爱好是%s%n",name,age,workYears,techDirection,hobby);
	}
}