第二章 Java 基础

一、标识符

1.1、标识符的概念

用来表示类名、变量名、方法名、类型名、数组名、文件名的有效字符序列；简单称为：标识符就是一个名字。

1.2、标识符的规则

1.2.1 基本规则

1：由数字、字母（大小写都可以）、下划线（"_"）、美元符号（“$”）组成，长度不受限制；
2：标识符的第一个字符不能为数字字符；
3：标识符不能为true、false、和null（尽管这三个字 符不是Java中的关键字，但却是是保留字）。

1.2.2 常见约定

在强制性的规则之外，开发过程中，一般需要遵循以下约定：
　　　　1：标识符要符合语义信息，即见名知意。
　　　　2：包名所有字母小写。
　　　　3：类名每个单词首字母大写，其它小写。
　　　　4：变量和方法的第一个单词小写，从第二个单词开始首字母大写。
　　　　5：类名和变量通常为名词或名词性短语，方法名通常为动词或动宾短语。
　　　　6：常量的所有字母大写，每个单词之间用下划线"_"连接。

1.2.3 Java中的关键字汇总

关键字是具有特定用途或者被赋予了特定意义的一些单词。

序号	关键字	描述
1	abstract	抽象方法，抽象类的修饰符
2	assert	断言条件是否满足
3	boolean	布尔数据类型
4	break	跳出循环或者label代码段
5	byte	8-bit 有符号数据类型
6	case	switch语句的一个条件
7	catch	和try搭配捕捉异常信息
8	class	定义类
9	const	未使用
10	continue	不执行循环体剩余部分
11	default	switch语句中的默认分支
12	do	循环语句，循环体至少会执行一次
13	double	64-bit双精度浮点数
14	else	if条件不成立时执行的分支
15	enum	枚举类型
16	char	16-bit Unicode字符数据类型
17	extends	表示一个类是另一个类的子类
18	final	表示一个值在初始化之后就不能再改变了,表示方法不能被重写，或者一个类不能有子类
19	finally	为了完成执行的代码而设计的，主要是为了程序的健壮性和完整性，无论有没有异常发生都执行代码。
20	float	32-bit单精度浮点数
21	for	for循环语句
22	goto	未使用
23	if	条件语句
24	implements	表示一个类实现了接口
25	import	导入类
26	instanceof	测试一个对象是否是某个类的实例
27	int	32位整型数
28	interface	接口，一种抽象的类型，仅有方法和常量的定义
29	long	64位整型数
30	native	表示方法用非java代码实现
31	new	分配新的类实例
32	package	一系列相关类组成一个包
33	private	表示私有字段，或者方法等，只能从类内部访问
34	protected	表示字段只能通过类或者其子类访问，子类或者在同一个包内的其他类
35	public	表示共有属性或者方法
36	return	方法返回值
37	short	16位数字
38	static	表示在类级别定义，所有实例共享的
39	strictfp	浮点数比较使用严格的规则
40	super	表示基类
41	switch	选择语句
42	synchronized	表示同一时间只能由一个线程访问的代码块
43	this	表示调用当前实例，或者调用另一个构造函数
44	throw	抛出异常
45	throws	定义方法可能抛出的异常
46	transient	修饰不要序列化的字段
47	try	表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码
48	void	标记方法不返回任何值
49	volatile	标记字段可能会被多个线程同时访问，而不做同步
50	while	while循环

二、基本数据类型

2.1、数据类型的概念

数据是描述客观事物的数字、字母以及能够输入到计算机中的符号。在Java中数据类型分为两大类：基本数据类型和引用数据类型。

2.2、基本数据类型

java的基本数据类型有8种，整型：byte,short,int,long;非整型：double,float;非数值型：char,boolean.

数据类型	占用空间	范围
boolean布尔型	1字节，8位	true或false
char字符型	2字节，16位	0~65535
byte字节型	1字节，8位	-2^7 ~2^7 - 1
short短整型	2字节，16位	-2^15 ~ 2^15 - 1
int整型	4字节，32位	-2^31 ~ 2^31 - 1
long长整型	8字节，64位	-2^63 ~2^63 -1
float浮点型（单精度）	4字节，32位	-3.403e38 ~ 3.403e38
double浮点型（双精度）	8字节，64位	-1.798e308 ~ 1.798e308

2.3、引用数据类型

java中除了8种基本数据类型之外，其余数据类型皆是引用数据类型。比如数组、字符串、接口、类等。（后续章节当中会详细介绍引用数据类型。）

三、字面量

字面量即字面值。

字面量类型	举例
整型字面量	10，12147483648L，0x64
浮点型字面量	3.14，3.14F
布尔型字面量	true，false
字符型字面量	‘a’，‘A’，’\u7C55’
字符串型字面量	“java”
Null型字面量	值为null，代表什么都没有

注意：

(1)、长整型（long）的字面量后面必须有字母l或L，为了和数字1区分，一般使用大写字母L。
(2)、单精度浮点型（float）的字面量后面必须有字母f或F，一般使用大写字母F。
(3)、字符型（char）的字面量必须使用单引号。
(4)、字符串型的字面量必须使用双引号。

四、变 量

4.1、变量的概念

概念：变量是指在程序运行过程中其值可以改变的量。本质上，变量就是计算机内存中存放数据的单元，定义变量的本质就是分配内存。当把数值赋给变量时，实际上就是将数值存储到变量代表的内存单元中。
简单的认为，所谓变量就是程序在运行的时候只可以改变的量；但是，变量必须是先声明，后初始化（使用）。

变量的命名规则同标识符的命名规则相同：
1、变量是由数字、字母(大小写皆可)、下划线("_")、美元("$")符组成；
2、变量不能以数字开头；
3、不能一关键字开头；
4、变量不能以保留字开头；

4.2、Java中的变量

声明变量并初始化语法格式：
[修饰符] 数据类型 变量名称 [= 值] [, 变量名称 [= 值] ...];

例1：

public class Test1 {
    
    
　　　　　	public static void main(String[] args) {
    
    
　　　　　		int num1 = 20, num2 = 30;
　　　　　		int num3 = num1 * num2;
　　　　　		String str = "Java";
　　　　　	}
　　　　　}

解释1：
变量必须先声明，然后初始化，最后才能使用；变量只在申明它的" {}"内有效。

例2：

public class Test2 {
    
    
　　　　　	public static void main(String[] args) {
    
    
　　　　　		int decimal = 100; // 十进制数100
　　　　　		int octal = 0144;  // 八进制数0144，即十进制数100
　　　　　		int hexa =  0x64;  // 十六进制数0x64，即十进制数100
　　　　　	}
　　　　　}

解释2：
初始化byte、int、long和short类型的变量时，均可以用八进制、十进制和十六进制的数字，前缀0表示 八进制数字，前缀0x代表 十六进制数字。

进制	英文单词	前缀
八进制	octal	0
十进制	decimal	无
十六进制	hexa	0x

例3：

public class Test3 {
    
    
　　　　　	public static void main(String[] args) {
    
    
　　　　　		char c1 = '汉';
　　　　　		char c2 = '字';
　　　　　		char c3 = '\u6C49'; //“汉”字的Unicode编码
　　　　　		char c4 = '\u5B57'; //“字”字的Unicode编码
　　　　　		char c5 = '\n';		// '\n'表示换行 (0x0a)
　　　　　		char c6 = '\t';		// '\t'表示制表符 (0x09)
　　　　　		char c7 = '\"';		// '\"'表示双引号" (0x22)
　　　　　		char c8 = '\'';		// '\''表示单引号' (0x27)
　　　　　		char c9 = '\\';		// '\\'表示斜杠\ (0x5c)
　　　　　		char c10 = 'A';
　　　　　		char c11 = 65;		// 表示字母A，使用十进制数字为char类型变量赋值
　　　　　		char c12 = 0101;	// 表示字母A ，使用八进制数字为char类型变量赋值
　　　　　		char c13 = '\101';	// 表示字母A ，使用\ddd的形式表示八进制数ddd
　　　　　		char c14 = 0x41;	// 表示字母A，使用十六进制数字为char类型变量赋值
　　　　　		char c15 = '\u0041';// 表示字母A，使用十六进制Unicode编码为char类型变量赋值
　　　　　		}
　　　　　	}

解释3：
char类型是一个单一的16位Unicode字符，可以保存一个字母或汉字等，最小值是\u0000（对应的10进制数字是0），最大值是\uffff（对应的10进制数字是65535），初始化char类型变量时，可以直接使用具体的字符，另外，也支持一些特殊字符序列。

五、常 量

常量即值不变的变量，通常用final修饰。
例：

public class Test4 {
    
    
	public static void main(String[] args) {
    
    
		public static final double E = 2.7182818;
		public static final double PI = 3.1415926;
	}
}

解释：其中e和pi都是数学当中的常见常量。

注意：基本数据类型当中的最值也都是以常量的形式存在（在包装类当中）。

序号	数据类型	包装类	最值(MIN / MAX)
1	byte	java.lang.Byte	Byte.MIN / MAX_VALUE
2	short	java.lang.Short	Short.MIN / MAX_VALUE
3	int	java.lang.Integer	Integer.MIN / MAX_VALUE
4	long	java.lang.Long	Long.MIN / MAX_VALUE
5	float	java.lang.Float	Float.MIN / MAX_VALUE
6	double	java.lang.Double	Double.MIN / MAX_VALUE
7	char	java.lang.Character	(int) Character.MIN / MAX_VALUE

六、表达式和运算符

6.1、表达式

表达式即运算符和操作数的组合。操作数可以是常量、变量、方法调用的返回值等。

6.2、运算符

运算符表示操作数之间如何操作的一种特殊符号。Java中运算符大致分为赋值运算符、算术运算符、关系运算符、逻辑运算符、位运算符、复合赋值运算符和条件运算符。

序号	运算符类型	运算符
1	赋值运算符	=
2	算术运算符	+、-、*、/、%、++、--
3	关系运算符	>、<、>=、<=、==、!=
4	逻辑运算符	&&、||、！
5	位运算符	&、|、^、~、<<、>>、>>>
6	复合运算符	+=、-=、*=、/=、%=
7	条件运算符	[数据类型 变量名称 = ](布尔表达式) ? 值 if true : 值 if false;

6.2.1：赋值运算符

赋值运算即给变量赋初值。

例1：

public class Text5 {
    
    
     public static void main(String[] args){
    
    
     int num1 = 110;  //将110赋值给变量num1;
     }
   }

6.2.2：算数运算符

算术运算是由数学当中的四则运算("+"、"-"、"*"、"/")和取余("%")、自增("++")、自减("--")组成的。

运算符	举例	解释
+	1+1=2	求俩操作数的和
-	2-1=1	求俩操作数的差
*	2*2=4	求俩操作数的积
/	4/2=2	求俩操作数的商
%	5%2=1	求俩操作数的余数
++	++2,2++	求操作数的自增
--	- -2,2- -	求操作数的自减

解释：
自增和自减运算符的位置在操作数的前后有很大的区别，如果在操作数的前面，则操作数先自增/减，后参与运算；如果在操作数的后面，则操作数先参与运算，后进行自增/减。

6.2.3： 关系运算符

关系运算就是对操作数之间进行比较。

运算符	举例	解释
>	num1 > num2	关系成立返回true，否则返回false
>=	num1 >= num2	关系成立返回true，否则返回false
<	num1 < num2	关系成立返回true，否则返回false
<=	num1 <= num2	关系成立返回true，否则返回false
==	num1 == num2	关系成立返回true，否则返回false
!=	num1 != num2	关系成立返回true，否则返回false

6.2.4：逻辑运算符

逻辑运算是对布尔类型的操作数进行与("&&")、或("||")、非("!")的运算。

运算符	举例	解释
&&	true &&true	只要两个操作数均为true,结果才是true,否则结果为false
||	true ||false	只要操作数有一个为true,结果就是true,否则结果就是false.
！	!(true )	!(true)的结果为false,!(false)的结果为true.

6.2.5：位运算符

位运算是对整数类型的操作数进行的二进制运算。有7种运算符，分别为位与("&")、位或("|")、位异或(^)、位反("~")、左位移("<<")、右位移(">>")和无符号右位移(">>>")。

运算符	解释
&	如果相对应位都是1，则结果为1，否则为0
|	如果相对应位都是0，则结果为0，否则为1
^	如果相对应位值相同，则结果为0，否则为1
~	按位取反运算符翻转操作数的每一位，即0变成1，1变成0
<<	左操作数按位左移右操作数指定的位数
>>	左操作数按位右移右操作数指定的位数
>>>	左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充

例：

public class Test6 {
    
    
	public static void main(String[] args) {
    
    
		int num1 = 60; /* 60 = 0011 1100 */
		int num2 = 13; /* 13 = 0000 1101 */
		int num3 = 0;
		num3 = num1 & num2;       /* 12 = 0000 1100 */
		System.out.println("num1 & num2 = " + num3 );
		num3 = num1 | num2;       /* 61 = 0011 1101 */
		System.out.println("num1 | num2 = " + num3 );
		num3 = num1 ^ num2;       /* 49 = 0011 0001 */
		System.out.println("num1 ^ num2 = " + num3 );
		num3 = ~num1;          /*-61 = 1100 0011 */
		System.out.println("~num1 = " + num3 );
		num3 = num1 << 2;     /* 240 = 1111 0000 */
		System.out.println("num1 << 2 = " + num3 );
		num3 = num1 >> 2;     /* 15 = 1111 */
		System.out.println("num1 >> 2  = " + num3 );
		num3 = num1 >>> 2;     /* 15 = 0000 1111 */
		System.out.println("num1 >>> 2 = " + num3 );
	}
}

6.2.6：复合赋值运算符

复合赋值运算是将算术运算和赋值运算同时进行的计算。

运算符	举例	等价式子
+=	num += 1	num = num + 1
-=	num += 1	num = num - 1
*=	num *= 2	num = num*2
/=	num /= 2	num = num/2
%=	num %= 3	num = num%3

6.2.7：条件运算符(三元运算符)

条件运算符也被称为三元运算符。该运算符有3个操作数，并且需要判断布尔表达式的值。该运算符的主要作用是决定哪个值应该赋值给变量。

条件运算的语法格式：
[数据类型 变量名称 = ](布尔表达式) ? num1 (if true ): num2 (if false);

例：

public class Text7 {
    
    
     public static void main(String[] args){
    
    
        int num1=110 , num2 =120;
        int num3 = (num1 <= num2 ) ? 110 : 120;
        System.out.println("num3 ="+num3); //结果：110
   }
}

6.3、运算符的优先级

运算规则：优先级高的先运算，优先级低的后运算，优先级相同的由结合性确定计算次序。

优先级	运算符	结合性
1	()、[]、.（点操作符）	从左向右
2	+（一元运算）、-（一元运算）、++、--、!、~	从右向左
3	*、/、%	从左向右
4	+、-	从左向右
5	>>、>>>、<<	从左到右
6	>、>=、<、<=	从左到右
7	==、!=	从左到右
8	&
9	^
10	|
11	&&
12	||
13	? :	从右到左
14	=、+=、-=、*=、/=、%=	从右到左

七、数据类型转换

混合运算中，不同类型的数据必须先转化为同一类型，然后进行运算。转换顺序从低级到高级。
低 --------------------------------------------------------------------> 高
byte,short,char—> int—> long—> float—> double

注意：
(1)、不能对boolean类型进行类型转换；
(2)、转换过程中可能导致溢出或损失精度；
(3)、浮点数到整数的转换是通过舍弃小数得到。
(4)、运算级低的转换成运算级高的，自动转换，运算级高的转换成运算级低的，强制转换。

7.1、自动类型转换

将运算级低的数据类型转换为运算级高的数据类型，系统会完成数据类型的自动转换。
例：

public class Text8 {
    
    
      public static void main(String[] args){
    
    
         char num1 = 'a'; //din
         int num2;
         num2 = num1;
         System.out.println("num2 = "+num2);
   }
}
结果：num2 = 97

7.2、强制类型转换

当将高级别的值赋给低级别的变量时，需要进行强制类型转换。
例：

public class Test9 {
    
    
	public static void main(String[] args) {
    
    
		float num1 = (float) 3.14; // 末尾没有字母f或F的浮点型字面量，会被当作double类型，赋值给float型的变量时，需要强制类型转换
		int num2 = (int) 3333333L; // 3333333L是一个long类型的整数，赋值给int类型的变量时，需要强制类型转换
		float num3 = 1.6F;
		int num4 = (int) num3; // 将float类型的变量num3的值赋值给int类型的变量num4,需要强制类型转换
	}
}

7.3、表达式返回结果的数据类型转换

<1>、表达式返回结果的数据类型一般由表达式中占用字节空间最大的类型决定。如果赋值给占用空间较小的数据类型则会报错。

public class Test10 {
    
    
	public static void main(String[] args) {
    
    
		int num1 = 2020;
		float num2 = 2020f; //float类型一定要后缀f或F；
		double num3 = 3.14; //double类型的后缀可加可不加。
		double result = num1 + num2 + num3; 
		System.out.println("result = " + result);
	}
}

<2>、字符串(String)与其他数据类型进行“+”运算时，都会将其他数据类型先转换为字符串(String)，然后两个字符串进行拼接。
例：

public class Test11 {
    
    
	public static void main(String[] args) {
    
    
		int num1 = 2020;
		float num2 = 13.14F;
		String str = "hello";
		System.out.println("(num1 + num2 + str) = " + (num1 + num2 + str);
	}
}

<3>、byte类型的变量值之间、short类型的变量值之间、或者byte类型的变量值和short类型的变量值，它们在进行运算时，结果为int类型。

public class Test {
    
    
	public static void main(String[] args) {
    
    
		byte num1 = 110;
		short num2 = 119;
		int num3 = num1 + num2;
		System.out.println("num3 = " + num3);
	}
}

八、Java语言程序结构

8.1、顺序结构

顺序结构，自然就是按照程序的先后顺序进行执行。

Public class Text12 {
    
    
    Public static void mian(String[] args){
    
    
     int num1 = 10;
     int num2 = 20;
     int num3,num4;
     num3 = num1 + num2;
     num4 = num3*2;
     System.out.println(“num3 = ”+num3);
     System.out.printlm(“num4 = ”+num4);
   }
}

8.2、分支结构

分支结构，是根据是否满足条件来执行对应的程序段。

8.2.1：单分支if语句

单分支if语句就是使用一个布尔表达式进行条件判断，如布尔表达式的值为true,则执行{}内的程序段。

单分支if语句的语法格式：

If(布尔表达式){
    
    
//布尔表达式的值为ture时执行的程序段。
}

例：

Ppublic class Text13 {
    
    
      Public static void main(String[] args){
    
    
      int num = 100;
      if(num <= 200){
    
    
      System.out.println(“布尔表达式的值为ture。”);
     }
   }
}

8.2.2：双分支if...else语句

双分支if…else语句就是使用一个布尔表达式进行条件判断，如果布尔表达式的值为true,则执行{}内的程序段，如果布尔表达式的值为false,则执行else后面{}内的程序段。

== 双分支==if…else语句的语法格式：

if(布尔表达式){
    
    
//布尔表达式的值为true时执行的程序段。
}else{
    
    
//布尔表达式的值为false时执行的程序段。
} 

例：

Public class Text14 {
    
    
   Public static void main(String[] args){
    
    
   Scanner input = new Scanner(System.in)；
   System.out.println(“请输入数据num:”);
   num1 = inpput.nextin();
   num2 = input.nextint();
   if(num1 <= num2){
    
    
      System.out.println(“布尔表达式的值为true。”);
   }else{
    
    
      System.out.println(“布尔表达式的值为false。”);
   }
 }
}

注意：条件运算符也可以实现双分支if…else语句。

Public class Text15 {
    
    
     Public static void main(String[] args){
    
    
     Scanner input = new Scanner(System.in)；
     System.out.println(“请输入数据num:”);
     num1 = inpput.nextin();
     num2 = input.nextint();
     num = (num1 <= num2) ? num1 : num2;
     System.out.println(“输出最小的num = ”+num);
     //如果布尔表达式(num1 <= num2)的值为true,输出num = num1,如果值为false则输出num = num2  ; 
    }
}

8.2.3：嵌套的if...else语句

嵌套if…else语句就是在一个if…else语句中，套入另外一个if…else语句

嵌套if…else语句的语法格式：

if(布尔表达式1){
    
    
   //布尔表达式的值为true.
 if(布尔表达式2){
    
    }else{
    
    }
}else{
    
    
    //布尔表达式1的值为false.
  if(布尔表达式3){
    
    }else{
    
    }
}

例：

Public class Text {
    
    
      Public static void main(String[] args){
    
    
      Scanner input = new Scanner(System.in)；
      System.out.println(“请输入数据num:”);
      int num1 = input.nextin();
      int num2 = input.nextint();
      if(num1 <= num2){
    
    
         System.out.println(“布尔表达式的值为true。”);
         if(num1 <= num2/2){
    
    
            System.out.println(“num1小于num2的一半。”);
         }else{
    
    
            System.out.println(“num1大于num2的一半。”);
         }
     }else{
    
    
        System.out.println(“布尔表达式的值为false。”);
        if(num2 <= num1/2){
    
    
           System.out.println(“num2小于num1的一半。”);
        }else{
    
    
           System.out.println(“num2大于num1的一半。”);
     }
   }
  }
}

8.2.4：多分支if...else if...else语句

多分支if…else if…else语句中含有多个判断条件，每个布尔表达式的值为true时才会执行，将所有的条件判断完之后，没有满足的条件才会执行else后{}中的程序段。

多分支if…else if…else语句的语法格式：

if(布尔表达式1){
    
    
//布尔表达式1的值为true.
}else if(布尔表达式2){
    
    
//布尔表达式2的值为true.
}else if(布尔表达式3){
    
    
//布尔表达式3的值为true.
} else{
    
    
//所有的布尔表达式的值皆为false时执行的程序段。
}

8.2.5：switch语句

switch…case语句也是有多个判断条件，但不同if…else if…else语句的是，switch…case语句的case值为确定值，而if…else if…else语句的布尔表达式取值是一个范围。

switch…case语句的表达式：

switch (表达式) {
    
    
	case 常量1:
		语句1;
		Break;
	case 常量2:
		语句2;
		Break;
	[...]
	[default:
		语句n;
}

8.3、循环结构

循环结构就是在条件允许的情况下重复执行某段程序段。Java中主要有三种循环结构，while循环，do…while循环，for循环；

8.3.1：while循环语句

while循环首先使用一个布尔表达式进行条件判断，如果布尔表达式的值为true，表示条件满足，则执行while语句后紧跟的{}中的代码块，这段代码即循环体，循环体执行完之后，再计算布尔表达式进行条件判断，如果布尔表达式的值仍然为true，便再次执行循环体，形成循环；当布尔表达式的值为false时，直接执行循环体之后的代码。

While循环语句的语法：

While(布尔表达式){
    
    
//循环体
}

特点：先判断后执行。

8.3.2：do...while循环语句

do-while循环的原理与while循环基本相同，不同的是，do-while循环先执行一遍循环体中的代码块，再计算布尔表达式进行条件判断，如果布尔表达式的值仍然为true，便再次执行循环体，形成循环；当布尔表达式的值为false时，直接执行循环体之后的代码.
do…while循环语句的语法格式：

do{
    
    
//循环体
}while（布尔表达式）；

特点：先循环后判断，循环体至少要执行一次。

8.3.3：for循环语句

for循环语句是程序中使用最多的循环结构。for循环语句使用三个表达式，分别用来初始化循环变量，判断循环执行条件，以及改变循环变量。

For循环懂得语法格式：

For(表达式1，表达式2，表达式3){
    
    
//循环体
}

注意：
	  表达式1：定义初值；
      表达式2：判断条件是否成立；
      表达式3：判断值的改变。
特点：已知循环次数。

8.3 4：break语句

Java中提供了break语句，可用于switch语句或while、do-while、for循环语句，如果程序执行到break语句，立即从switch语句或循环语句退出。

8.3.5：continue循环语句

continue语句可用于for、do-while、while语句的循环体中，如果程序执行到continue语句，则结束本次循环，回到循环条件处，判断是否执行下一次循环。

8.3.6：多重循环

如果循环语句的循环体中又包含循环语句，就形成了多重循环结构，称为循环嵌套。被包含的循环称为内循环，包含的循环称为外循环。常用的循环嵌套是二重嵌套和三重嵌套，更多重的=嵌套由于代码逻辑复杂，应当尽量避免使用。循环嵌套既可以是一种循环自身的嵌套，也可以是不同循环语句相互嵌套。

例：

public class Test {
    
    
	public static void main(String[] args) {
    
    
		// 使用双重for循环输出乘法口诀表
		for (int i = 1; i <= 9; i++) {
    
    
			for (int j = 1; j <= i; j++) {
    
    
				System.out.print(j + "x" + i + "=" + (j * i) + "\t");
			}
			System.out.println();
		}
	}
}