java基础

1.java编程语言：

前端语言：WEB、PHP
后端语言：C： 面向过程、
	JAVA现象对象
	C、C++
特点：开源的，跨平台性
一次编译，到处运行。

2.JDK的安装

2.JDK的安装：运行程序Jdk1.8，一直下一步，下一步完成。
在C:\Program Files\Java存在jdk1.8,jre1.8。
1…配置环境变量：我的电脑-》鼠标右键-》属性-》高级系统设置-》系统变量
动态部署：
1.JAVA_HOME: C:\Program Files\Java\jdk1.8.0_221
2.PATH： %JAVA_HOME%\bin;%JAVA_HOME%\jre\bin
3.CLASSPATH: .;%JAVA_HOME%\lib;%JAVA_HOME%\lib\tools.jar
2.验证配置是否成功
1.win+R:输入CMD，进入dos命令
2.输入java -version,查看Java程序的版本
3.输入javac -version,查看javac程序的版本
3.JDK目录结构：
1.bin： 存放可执行文件
2.lib: 引入的第三方jar包
3.jre： java的运行环境
4.src: java的源码
4.JDK、JRE和JVM的关系
1.JDK：JAVA的开发环境，包含了jre,java工具和java类库
2.JRE：JAVA的运行环境，包含了JVM和JAVA类库
3.JVM：JAVA虚拟机，是实现整个java跨平台的核心部分，能运行java程序
程序员win开发的java程序-》客户：苹果电脑-》安装mac版本的jre

3.Eclipse开发工具

3.Eclipse开发工具
1.下载安装，直接解压缩
2.运行eclipse.exe程序
3.workspace: 工作空间，项目存放的位置
要求：1.不能有中文
2.不能有空格

4.项目搭建

4.项目搭建
1.新建项目：file->new->java project->项目名称：tsb
2.新建包：在src目录下鼠标右键->new->package->包名：cn.tedu.day01
注意：1.src目录：存放java源代码的目录
2.包名要求：
1.域名反写。 www.tedu.cn ->cn.tedu.day01
2.包名建议小写
3.创建类：在day01包下鼠标右键->new->class->类名：HelloWorld
注意：1.类名首字母大写
2.驼峰命名法

5.编写第一程序HelloWorld

1.在类中，编写main（）方法
2.在main()方法种编写输出语句:System.out.println(“Hello,World”);
3.鼠标右键->run as->java application
4.设置字体大小：Ctrl+"+"

6.编译运行的原理

HelloWorld.java文件->编译器编译->HelloWorld.class字节码文件->run as运行->JVM运行的是HelloWorld.class
.java：源文件  用于程序员开发的
.class：字节码文件  用于给计算机去读使用的

基础知识：

1.注释

1、作用：它不参与编译，只是作为代码的提示说明，用于开发人员或者客户知道当前代码的含义。
2.分类：
1.单行注释：// 范围：只注释一行
2.多行注释：以/开头，/结尾的内容，/…/ 范围：注释多行
3.文档注释：以/开头，*/结尾的， /…*/ 范围：注释多行,描述整个类、方法、常量是干什么的。一般放在类、方法上。
2.可以生成javadoc文档。

2.标识符：

1.概念：java中，我们需要表示代码的很多元素，比如：类名，方法名，字段，变量，包名，我们把这些统称为标识符。
2.要求：
1.只能以字母，数字，_,$来表示
2.不能以数字开头
3.严格区分大小写
4.命名最好做到见名知意
5.关键字不能作为标识符

3.关键字：

在Java中已经提前预定义好的特殊字符

4.变量：

1.概念：可以改变的量，相当于一个容器，用于存放数据。
2. 使用：
1、定义时候同时赋值：数据类型 变量名称=数值；int x=10;
2、先定义，在赋值：数据类型 变量名称；int age;
变量名称=数据； age=10;
3.注意事项：
1.变量名不允许重复定义。
2.一条语句中可以定义多个变量，但需要使用逗号分割。
3.变量在使用之前一定要进行赋值。
4.定义float和long类型变量的时候注意：
1.定义long类型的变量，需要在数值后边加上L的标识符，大小写都行。
2.定义float类型的变量，需要在数值后边加上F的标识符，大小写都行。
5.变量的作用域：只在它所在的{}中生效。

5.数据类型

1.概念：用于定义不同类型的变量。
2.分类
1.基本数据类型（8种）
1.整数类型：(4种)
byte: 字节型，占一个字节，0000 0000；2^8 =256种状态，-128~127； 0也算一种状态；
short: 短整型，占两个字节，0000 0000 0000 0000；2^16种状态，-2^15~2^15-1;
int: 整型，占四个字节，2^32种状态，-2^31~2^31-1;
long: 长整型，占用八个字节，2^64种状态，-2^63~2^63-1;
2.浮点型：
float: 单精度型，占四个字节，对小数部分的精度要求不高。 在定义使用后的时候，需要在数值后加上f。
double: 双精度类型，占用八个字节，对小数部分的精度要求很高。
3. 字符型：char
用于接收单个字符。 占用2个字节，2^16种状态,0~65535
a~b，1~10，汉字字符，别的国家语言的字符。
4.布尔型：boolean
结果只有true和false;
2.引用数据类型：比如对象，String(字符串)，数组，接口…
1.特点:变量里存储的是一个地址值，去映射到堆内存中真实存在的对象。
2.对象：通过new实例化出来的。 月饼，模子-》一个个月饼；

1.数据类型转换：

1.自动转换：小转大
	1.概念：当左边的数据类型>右边的数据类型会，右边的数据类型会自动转换成左边的数据类型。
	byte a=10;int b=a;//a的值=>int类型的，在赋值给了b;
2.强制转换：大转小
	1.概念：当左边的数据类型<右边的数据类型会,在右边的数据上加上(左边的数据类型)
	2.格式：小数据类型 变量名=(小数据类型)值；  int a=10;byte b=(byte)a;
	3.缺点：
		1.精度缺失：double a=3.14;int b=a;//b=3
		2.数据溢出: byte a=(byte)128;//a=-128;

2.项目导入导出

1.导入项目：File->import->General->Existing project->select arhcive file->browser
2.导出项目：File->export->General->arhcive file->browser
  注意事项：导入项目，又可能会因编码集格式不同，造成中文乱码问题。
  编码集格式：
  	1.GBK:WIN系统的编码集
  	2.UTF-8：JAVA采用的编码集

3.调整代码格式：

1.ctrl+A:全部选中2.ctrl+i:调整代码格式

1.引用数据类型：

字符串：
	1.String类，格式："字符串的内容";
	System.out.println("Hello,World");//里边的内容会原样打印。 Hello,World
	2.字符串的拼接:字符串+任意类型数据=新的字符串;

2.运算符：

1.算数运算符：+，-，*，/,%,++,--；
	1.+，-，*跟数学里运算方式一样。
	2./:整数相除，结果只能得到整数。int a=10,b=20; System.out.println(a/b); //0
		如果想要得到带有小数的结果，必须加入小数。System.out.println(10.0/b);// 0.5
	3.%(取模)：取余数
	4.自增自减运算
		1."++"：自增运算，变量自身+1;
		 注意事项：
		 	1.单独使用的时候，++在前和++在后没有任何区别，都是自增1；
		 	2.混合使用的时候：
		 		1.++在前，先自增1，后参与运算;//System.out.println(++a+3);//a=a+1=4;4+3=7;
		 		2.++在后，先参与运算，在自增1;//System.out.println(3+a++);//7  3+a=3+4=7;a=a+1=4+1=5;
		 2."--"运算：自减运算，变量自身-1
		 注意事项：
		 	1.单独使用的时候，--在前和--在后没有任何区别，都是自减1；
		 	2.混合使用的时候：
		 		1.--在前，先自减1，后参与运算;
		 		2.--在后，先参与运算，在自减1;

1.运算符：

2.比较运算符：==，！=
	注意事项：
		1.==：在比较基本数据类型的时候，相当于我们数学里边的“=”，比较数值是否相等。
		2.!=: 在比较基本数据类型的时候，相当于我们数学里边的“=”，比较数值是否相等。

3.赋值运算符：=，+=，-=，*=，/=

	1.= 将右边的数据赋值给左边
	2.+=：将符号左右两边的数据进行加法运算，结果赋值给左边。
	3.-= 将符号左右两边的数据进行减法运算，结果赋值给左边。
	4.*=，/=类似;

4.逻辑运算符：&，|，&&，||，

	1.&：与运算:就是并且的意思。一假为假，全真为真。
	2.|：或运算:就是或者的意思。全假为假，一真为真 
	3.&&：短路与：
		1.当左边的结果已经可以决定最终结果的时候，那么右边将不在执行。达到一个短路效果。
		2.当左边的结果决定不了最终结果的时候，那么右边将继续执行。
	4.||：短路或
		1.当左边的结果已经可以决定最终结果的时候，那么右边将不在执行。达到一个短路效果。
		2.当左边的结果决定不了最终结果的时候，那么右边将继续执行。

5.三元运算符

	1.格式：表达式？表达式1：表达式2;
	2.先判断表达式，结果为true，执行表达式1;
				      结果为false,执行表达式2;
	3.注意事项：表达式1和表达式2数据类型必须一致；

1.键盘输入
步骤： 1.导包：import java.util.Scanner;
2.使用Scanner类创建一个对象，对象名字：scan
Scanner scan=new Scanner(System.in);
3.使用Scanner类里的一个方法,获取键盘输入的整数，并且进行接收
int a=scan.nextInt();

1.流程控制语句：

1.顺序语句：

	代码是从上往下执行的。

2.分支语句：

	1.if()语句
		1.if(条件1){语句体1}语句：当条件1满足的时候，执行if里的语句体1；
		2.if(条件1){语句体1}else{语句体2}：(2选1)当条件1满足的时候，执行if里的语句体1；如果条件1不满足，语句体2;
		3.if(条件1){语句体1}else if(条件2){语句体2}else{语句体3}：(3选1)
	2.switch()语句：
		1.格式；switch(表达式){case 值1：语句体1;break;case 值2：语句体2;break;case 值3：语句体3;break;default:语句体n;break;}
		2.含义：多选1，通过表达式里的数值，与case里边的相匹配，如果匹配上，执行它那行的代码；
															如果匹配不上，执行default里边的内容
		3.注意事项：如果switch语句中，case后边省略了break语句，那么case就会穿透。直到遇到下一个break或者程序结束为止。

1.循环语句：解决重复代码操作

	1.for():for循环
		1.格式：for(初始化语句1;条件判断语句2;条件控制语句4){循环体3}
		2.执行过程：
			1.初始化语句1,条件判断语句2,循环体3,条件控制语句4
			2.条件判断语句2是否成立，如果成立，循环体3,条件控制语句4
			3.条件判断语句2是否成立，如果成立，循环体3,条件控制语句4
			....
			4.条件判断语句2是否成立，如果不成立，循环结束。

		 * 第一遍：i=1,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
	 	* 第二遍：i=2,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
	 	* 第三遍：i=3,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
		 * 第四遍：i=4,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
	 	* i=5,判断i<5?结束循环；
	 	* */
		for(int i=1;i<5;i++) {
			System.out.println("HelloWorld");
		}
	2.while()循环：
		1.格式：初始化语句1;while(条件判断语句2){循环体3;条件控制语句4}
		2.执行过程：
			1.初始化语句1,条件判断语句2,循环体3,条件控制语句4
			2.条件判断语句2是否成立，如果成立，循环体3,条件控制语句4
			3.条件判断语句2是否成立，如果成立，循环体3,条件控制语句4
			....
			4.条件判断语句2是否成立，如果不成立，循环结束。

	 	* 第一遍：int i=1,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
		 * 第二遍：i=2,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
		 * 第三遍：i=3,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
	 	* 第四遍：i=4,判断i<5?如果小于，执行循环体System.out.println("HelloWorld");i++;
	 	* i=5,判断i<5?结束循环；
	 	* */
		int i=1;
		while(i<5) {
			System.out.println("HelloWorld");
			i++;
		}
	3.do....while()循环：
		1.格式：初始化语句1;do{循环体3;条件控制语句4;}while(条件判断语句2);
		2./*
	 	* 1.初始化语句1：int i=1;执行循环体语句3：System.out.println("HelloWorld");执行条件控制语句4;
	 	* 执行条件判断语句2，如果成立；进行下一轮循环
	 	* 2.执行循环体语句3：System.out.println("HelloWorld");执行条件控制语句4;
	 	* 执行条件判断语句2，如果成立；进行下一轮循环
	 	* ...
	 	* n.执行循环体语句3：System.out.println("HelloWorld");执行条件控制语句4;
	 	* 执行条件判断语句2，如果不成立，循环结束
	 	*/
		int i=1;
		do {
			System.out.println("HelloWorld");
			i++;
		}while(i<5);
 注意事项：1.do...while()循环无论条件是否满足，都至少执行一次
 		 2.for()循环和while()循环都是先判断，后执行循环体；
 		   do..while()循环先执行循环体，后进行判断
 		 3.有限次数循环优先使用for()循环，无限次或者大批次优先使用while()循环;
 		 4.do...while()循环不推荐使用，除非特定需求。
 		 5.尽量避免死循环;
 		  死循环一般用于不确定需要循环多少次，在他的内部加上结束死循环的条件。
2.contiune和break关键字
	1.break：就是结束语句体的标志；在循环结构中用于结束循环。
	2.continue:结束当前循环，进行下一轮循环。

1.双层for循环：

1.特点：外层控制行，内层控制列。
2.例子：for(int i=1;i<=2;i++){//外层for
			for(int j=1;j<=2;j++){//内层for
				System.out.print("* ")
			}
			System.out.println()
  		}
  执行过程：1.先执行外层for,int i=1;在判断i<=2;如果满足，执行内层for
  		  	1.执行内层for,int j=1;在判断j<=2;如果满足，执行内层for的循环体内容；执行：System.out.print("* ")
  		  	2.内层j++;在判断j<=2;如果满足，执行内层for的循环体内容；执行：System.out.print("* ")
  		 	3.内层j++;在判断j<=2;如果不满足，内层for结束，程序往下执行，执行System.out.println()
  		  2.执行外层for,i++;在判断i<=2;如果满足，执行内层for
  		  	1.执行内层for,int j=1;在判断j<=2;如果满足，执行内层for的循环体内容；执行：System.out.print("* ")
  		  	2.内层j++;在判断j<=2;如果满足，执行内层for的循环体内容；执行：System.out.print("* ")
  		 	3.内层j++;在判断j<=2;如果不满足，内层for结束，程序往下执行，执行System.out.println()
  		  3.执行外层for,i++;在判断i<=2;如果不满足，外循环for结束。

2.数组：

1.概念：固定长度的容器，用来存放同一种类型的数据。
    1.注意事项：数组在定义的时候，必须确定它的长度。
2.定义格式：
	1.数据类型[] 数组名=new 数据类型[数组长度];定义数组，确定它的长度，没有初始化。
	2.数据类型[] 数组名={值1，值2，值3};在定义数组的同时，直接给它赋值。

3.数组的访问：下标

	1.通过下标去访问。
		1.下标：即索引，就是数组中每一个数组位置的标记。是从0开始的。
	2.格式：数组名[下标]

4.数组在内存中存储

	1.栈内存：方法运行时使用的内存，比如main方法。
		1.特点：先进后出，压栈操作。
		2.比如main方法里定义的基本数据类型变量，都在栈内存中。
	2.堆内存：用于存储对象或者数组。
		特点：1.凡是new出来的东西，都在堆内存中存在。
	3.例子：
		int[] a=new int[2];
		a[0]=10;
		1.在栈内存中定义一个数组类型的对象，对象名叫做a
		2.在堆内存中创建一个真实的数组对象，它的长度是2;初始值是0;把它的地址值赋值给了a;
		3.通过a找到那个真实的对象，通过下标，去修改第一个数值为10;
5.数组中常见的异常(Exception)
	1.异常：程序出错，报错来的错误，是可以通过代码修改来避免或者解决的。
	2.分类：
		1.ArrayIndexOutOfBoundsException:数组下标越界异常
		      1.意思：访问数组时，下标超出了数组的下标范围。
		      2.解决:修改数组下标
		2.NullPointerException:空指针异常
			  1.意思：就是数组对象里存储的地址值为null,找不到堆内存中真实存在的那个对象了
			  2.解决：查看数组对象是否为null,代码修改。

6.数组的遍历：

	1.概念:访问数组里的每一个元素。
	2.访问要求：
		1.通过索引访问。
		2.通过循环结构
		3.通过数组的长度去限定下标的范围。
			1.数组长度：array1.length;	
	 		注意事项：int a=10;a就是int类型的变量
	 		         int[] a=new int[2];a是一个数组对象名。  

1.方法：

1.概念：将具有独立功能的代码组织成一个整体，使其具有独立功能的代码集。
2.方法的分类
	1.按照参数来看：
		1.无参数方法
			1.方法定义：public static void 方法名(){方法体}  比如：public static void getPrint(){for循环} 
			2.方法使用(调用)：在main方法中，直接编写：方法名(); 比如：getPrint();
		2.有参数的方法
			1.方法定义：public static void 方法名(参数){方法体} ;public static void getPrint(int num){for循环}
			参数：数据类型 变量名; 比如：(int num)
			作用：就是用来传递数值的。
	2.按照返回值类型
		1.无返回值：void
			1.public static void  方法名(){}
		2.有返回值:数据类型 方法名();
			1.public static 数据类型  方法名(){return 数据值}
			注意：return处理的数值必须和方法上的定义的数据类型保持一致。
2.方法调用：在main方法中，直接编写：方法名(数值); 比如：getPrint2(10);
	
3.注意事项：
	1.一个类中，各个方法的定义都是并列关系。	
	2.程序执行的时候，先main方法，如果main方法里有其他方法调用，再会去执行其他方法。
							       如果main方法里没有其他方法调用，不去执行其他方法。
	3.一个类中各个方法定义的先后顺序没有要求，它一定先执行main方法。
4.方法的参数使用
	1.参数是基本数据类型
		方法调用时，传递获取的就是数值。 sum(1,2);
	2.参数是引用数据类型
		方法调用时，传递获取的就是地址值。
5.方法重载
	1.概念：同一个类中，方法名相同，参数列表不同。
	2.参数列表不同：
		1.个数不同
		2.数据类型不同
		3.数据类型顺序不同

1.面向对象

1.类：
	1.定义：对生活中一类具有共同属性和行为的事物的抽象。
	2.组成：
		1.属性：事物的特征，通过成员变量来实现。比如：小狗的年龄，姓名，体重
				成员变量：在类当中，方法外边；
		2.行为：事物的动作。通过成员方法来实现。比如：小狗：sleep();eat();
				成员方法：和之前定义的方法一样，但是要去掉static;
						public void getSum(){};
	3.类和对象的关系
		类相当于模板，对象是一个具体的事物。比如：类：模子;对象：一块月饼。
	4.类的使用：通过创建对象来使用
		1.对象的创建：类名 对象名=new 类名称();  Dog tom=new Dog();
		2.成员变量的访问：对象名.变量名;  tom.age;tom.weight;
		3.成员方法的访问：对象名.方法名;  tom.sleep();tom.eat();tom.getSum();
5.对象的内存结构
	1.创建对象时候，真实的对象在堆内存中，栈内存中对象里存储的是地址值。 Student stu=new Student();
	2.堆内存中，真实的对象里的方法其实是地址值，映射到方法区里字节码文件里的真实的方法，把这个方法加载进栈内存。stu.study();
6.成员变量和局部变量
	区别：
		1.位置不同：
			1.成员变量：在类当中，方法外边
			2.局部变量：在方法里边。
		2.内存中存储不同：
			1.成员变量：跟着对象走的，在堆内存中。
			2.局部变量：跟着方法走的，在栈内中。
		3.生命周期不同：
			1.成员变量：跟着对象走的，当对象被gc回收机制销毁的时候，成员变量跟着销毁了。
			2.局部变量：跟着方法走的，当方法出栈，局部变量跟着销毁。
		4.初始化不同
			1.成员变量：在使用的时候如果没有初始值，系统默认给它初始值。
			2.局部变量：在使用的时候，必须初始化。不然程序报错。
		5.权限修饰符不同：
			1.成员变量：可以定义成员变量时，指定权限，使用修饰符：public、default、protected、private
			2.局部变量：只能被default 和final修饰。
			注意：final修饰的时候：
				1.成员变量：final修饰成员变量，该变量必须在创建对象之前进行赋值，否则编译失败。
							1)创建成员变量的时候手动赋值
							2)利用构造器进行赋值
							3)利用set方法进行赋值(不行，因为是通过对象去调用的。)
				2.局部变量：变量是基本类型:数据值不能发生改变
         				      变量是引用类型:地址里面的内容可以发生改变，但是地址是不能改变的
	1.private：
	1.概念：是一个修饰符，私有的。
	2.使用：修饰成员(成员变量，成员方法)。
	3.特点：被它修饰的成员，只能在本类中直接方法。在外部访问，只能通过它提供的Get和Set方法去访问。
			间接的保护了被修饰的成员变量和成员方法。
2.就近原则：
	1.当成员变量和局部变量重名的时候，作用域里优先考虑理它最近的变量。
3.this
	1.概念：代表当前对象，被它修饰的变量就是成员变量。
	2.作用：主要作用就是为了区分成员变量和局部变量；
	3.用法：
		3.1)this.成员变量名----------访问成员变量
		3.2)this.方法名()--------------调用方法（一般不用）
		3.3)this()------------调用构造方法(一般不用)
        4.封装思想
	1.是Java三大特性之一。(封装、继承、多态)
	2.将某些信息隐藏到类的内部，不允许外界直接访问，只能通过该类提供的方法来对隐藏信息的访问。
				 private实现的隐藏，					Get()和Set()方法
	3.好处：
		1.把代码进行封装，提高代码复用性。
		2.通过隐藏信息，提高代码安全性。
	4.例子：方法就算一种封装，封装了一个独立功能的代码块。
		        类也算一种封装，封装了属性和行为。
5.构造方法：
	1.概念：用来创建对象的方法。
	2.格式：public 类名称(){}  //当前类里：public static void get(){}   模板类：(成员方法)public void get(){}
	
	3.使用：就是在创建对象的时候，通过调用构造方法来实现创建对象。new Student();
	4.分类：
		1.无参构造：没有参数
		2.有参构造：有参数
		
	5.注意事项：
		1.方法名和类名相同
		2.没有返回值类型，也没有void.
		3.没有返回值
		4.如果一个类里没有构造方法，java会默认提供一个无参构造。
					  有构造方法，    java将不在提供。
		5.在创建对象时候,被自动调用。
6.JAVABean类：标准的模板类，用来封装数据;
	包含：
		1.私有属性
		2.构造方法
		3.Get()和Set()方法。
		4.toString()方法	  

2.常用API
1.概念：
1.Application Programing interface:应用程序接口
2.JAVA中的API:各种功能的类，这些类将底层封装起来，我们不需要关注这些类如果实现的，
只需要学些这些类怎么使用即可。我们可以使用API文档学习使用

2.Scanner类：键盘输入类
	1.java.util包下
	2.构造方法:new Scanner(System.in)
	3.方法：
		1.public int nextInt():键盘接受一个整数，并且进行返回。
		2.public String nextLine()：键盘接受一行字符串，并且进行返回。它结束的标志：回车符;
		3.public String next():键盘接受一行字符串，并且进行返回.它遇到空格，停止接收数据。
							      它结束的标志：回车符(Enter);

2.常用API

3.Sting类    
	1.它是引用数据类型
	2.字符串是常量，它们的值创建出来不允许修改。
	3.构造方法：
		1.public String():创建一个空字符串；
		2.public String(char[] value)：根据字符数组，来创建字符串对象。
		3.public String(String original):根据字符串，来创建字符串对象。
		4."123213"							:直接赋值的形式创建；
		注意事项：通过构造方法创建和直接赋值创建的区别
					1.通过构造方法创建：每次new都会申请一个内存空间，这些对象地址值不同。
					2.直接赋值的方式方式创建：只要字符序列相同（大小和顺序）,内存里只会创建一个String对象。
	5.常用的方法：
			1.public int length()：返回此字符串的长度
			2.public boolean equals(Object anObject)：比较字符串内容是否相同
				注意：
					1.equals()和==的区别：
						1.==：
							1.当比较基本数据类型的时候，比较的是内容；
							2.当比较引用数据类型的时候，比较的是地址值
						2.equals():
							1.比较的是引用数据类型的内容。
			3.public char charAt(int index):返回字符串中指定索引的字符。
			4.public String substring(int beginIndex):从beginIndex开始截取返回的内容。[beginIndex,最后]
			5.public String substring(int beginIndex,int endIndex):[beginIndex,endIndex);[beginIndex,endIndex)
			6.public String replace(char oldChar,char newChar):一个字符串中newChar替换oldChar,进行返回。
			7.public String replace(CharSequence target,CharSequence replacement):用新的字符串替换旧的字符串。
			7.public String[] split(String regex):一个字符串按照regex进行切割，返回的是字符串数组。