面向过程

虚拟机的安装

电脑上能够运行java程序，必须要安装java虚拟机(jdk8.rar)
	1：下载jdk8.rar，解压：例如：F:\jdk8\jdk8
	2：配置电脑的环境变量：我的电脑上右键->属性->高级系统设置->高级选项卡->环境变量->系统变量：
		1：点击新建：
			变量名：java_home
			变量值：F:\jdk8\jdk8\jdk，确定
		2：点击path，点击编辑->点击新建->%java_home%\bin
		3：一路确定	
	3：测试，检查环境变量安装是否成功：
		win+r：输入cmd回车：dos命令框打开，
			1：输入javac回车，看到提示
			2：输入java回车，看到提示，
				如果提示是：不是内部或者外部命令，则环境变量配置失败	

第一个java程序

1：编写第一个java文件：新建文本文档，文件的后缀改为.java,文件名使用全英文
2：以记事本方式打开该文件：编写java基本结构：注意java严格区分大小写。
	public class 文件名{
		public static void main(String[] args){      //程序入口
			System.out.println(10);			//控制台打印信息，并换行
			System.out.print("hello");		//控制台打印信息，并不换行
			System.out.println("你好");		//控制台打印信息，并换行
		}
	}
3：运行：
	开发dos命令框，进入java源文件(aaa.java)所在目录:
		1:输入javac aaa.java			编译源文件，将aaa.java源文件编译成字节码文件(aaa.class)
		2：输入java aaa				执行字节码文件
4：解释：
	所有的我们编写的java文件称之为java源文件，源文件要运行，必须先编译(javac)后执行(java)

eclipse

​ 作业：编写并运行java程序，记事本编写太慢。

1：解压eclipse.zip,
2：双击打开eclipse.exe程序，出现select a directory  as  workspace:：选择一个工作空间：
											通过eclipse新建的文件默认保存的目录(workspace)
3：左上角file->new->Project->java project->next->输入project name(项目名)->完成
4：在src目录上右键新建->package(包)：a1
5：在a1包上右键新建->class:java源文件：
	输入Name:Test
	选中：public static void main(String[] args)		添加程序入口
	完成
6：点击绿箭头运行程序：

注释

单行注释：  //
	该符号后面一张行为注释作用
多行注释：  
	/*
		多行内容
	*/		
文档注释：	
	/**
		文档内容，多用于中文解释
	*/

定义变量

​ 变量：容器，存储不同类型的内容，是程序中的最小单元块。

语法结构：
	数据类型  变量名 = 数值;

数据类型

java数据类型：
	基本数据类型：
		byte			字节型				-128~127									1B
        short			短整型				-32768~32767								2B
        int				整型				-2147483648~2147483647						4B
        long			长整型				-9223372036854775808~9223372036854775807	8B
        float			单精度浮点型		1.4E-45~3.4028235E38						4B	
        double			双精度浮点型		4.9E-324~1.7976931348623157E308				8B
        boolean			布尔类型			true\false									1B
        char			字符型				0~65535的整数，或者单引号引起来一个任意内容		2B
				注意：字符串型：计算机在存储字符型时，底层存储的都是asc码，输出字符类型的变量时一定是字符
				asc码：国际把一个字符与一个数字固定定义标准对应，一定是一个字符对应一个数字,该数字称之为该字符的asc码
				'a'->97
				'A'->65
				'0'->48
				

	引用数据类型：很多
		String：字符串类型：属于引用数据类型，使用双引号包起来任意内容
		String s1 = "abc";
		String s2 = new String("abc");
		数组

赋值号：

=：赋值号，作用：将符号右边的数值赋值给左边的变量，要求赋值号两边的数据类型必须一致，如果不一致，则存在数据类型转换。

标识符命名规则：

给文件名、变量名、方法名、参数名、接口名等等起名字的规范叫做标识符命名规则：
	以美元符、下划线、字母开头，后面可以有数字。不能有特殊符号，不能是关键字，不能重名

变量改值

int a = 1;		//声明变量
a = 2;			//变量改值

作用域

​ 定义变量时，在哪个作用域(就是大括号，代码块)中定义，只能在哪个作用域中使用该变量

表达式

由变量和运算符组成的算式，称之为表达式，最简单的表达式就是一个变量，表达式不能单独存在，必须赋值或者输出。

数据类型转换：

自动转换：小转大，自动转换，小范围可以赋值给大范围的变量，数据类型小转大
强制转换：大转小，把大范围类型的变量，强制转成小范围的类型

操作符

​ 算术运算符 关系运算符 逻辑运算符 位运算符

算术运算符

​ + - * / % += -= *= /= %= ++ --

注意所有的算术运算符运算结果的数据类型：
	符号两边同时为int以下(包含)时，则结果为int类型，
	只要有一方为int以上，则结果的数据类型根据大范围的类型。
	在运算时，直接看到不带字母的整数默认为int类型，不带字母的小数为double类型

+：作用1：求和；作用2：拼接
求和：该符号两边同时是数字类型,结果为数字类型
拼接：该符号两边只要有一边为字符串类型，则拼接，结果的数据类型为字符串。


-：同数学
*：同数学
/：同数学，注意运算结果的数据类型。
%：求余，同数学，只运算整数


+=:先求和，后赋值，默认会自动强制转换
-=：逻辑同上    
*=：逻辑同上    
/=：逻辑同上     
%=：逻辑同上

++：
	可以写在变量前面：先自增1，后执行(除了++符号，其他还有什么运算就执行什么运算)
	可以写在变量后面：先执行(除了++符号，其他还有什么运算就执行什么运算)，后自增1

--：逻辑同上

关系运算符

>    <    >=    <=    ==     !=

		int a = 1;
		int b = 2;
		boolean c1 = a > b;
		boolean c2 = a < b;
		boolean c3 = a >= b;
		boolean c4 = a <= b;
		boolean c5 = a == b;
		boolean c6 = a != b;
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);
		System.out.println(c5);
		System.out.println(c6);
注意：
	1：不能连用：boolean d = c > b > a;  //不能连用
	2：可以与算术运算符混合使用，先算术，后关系
		boolean d = a + b > b - a;

逻辑运算符

&&    ||     ！
只能运算逻辑：true、false

&&：逻辑与，条件并且：符号两边只要有一方为假，结果为假，两边同时为真，结果为真；
||：逻辑或，条件或者：符号两边只要有一方为真，结果为真，两边同时为假，结果为假；
!：逻辑非：真变假，假变真，

注意：
	1：先执行非，再执行与，最后执行或
	2：先算术运算符、再关系运算符、最后逻辑运算符
	3：注意逻辑与和逻辑或有短路功能：
		逻辑与的左边如果为false，右边不执行
		逻辑或的左边如果为true，右边不执行

三目运算符

​ 三元运算符

表达式1?表达式2:表达式3；
	先执行表达式1，判断运行结果，
		如果表达式1的运行结果为true，则最终结果为表达式2
		如果表达式1的运行结果为false，则最终结果为表达式3

程序流程控制语句

根据不同的逻辑，不是每句命令都执行，根据不同的逻辑具体情况具体执行；

switch语句

switch(表达式){
case 数值1:语句;
case 数值2:语句;
default:语句;
case 数值3:语句;
case 数值4:语句;
......
}
先计算表达式的结果，
	1：找与之相等的case数值，从该case后面语句开始执行，执行到大括号结束
	2：如果没有找到与之相等的case数值，则先找default,从该default后面语句开始执行，执行到大括号结束
								如果没有找到default，则什么都不执行
	3：以上两种情况执行过程中，碰到break关键字，立刻结束switch语句
	
注意：
	1：所有的数值不能相同
	2：表达式的结果的数据类型只能是int、char、String

判断语句

if(逻辑表达式){
	语句;
}
判断表达式的结果，如果为true，则执行大括号里的语句；如果为false，什么都不执行


if(逻辑表达式){
	语句;
}else{
	语句;
}
判断表达式的结果，如果为true，则执行if大括号里的语句；如果为false，则执行else大括号里的语句；


if(逻辑表达式1){
	语句1;
}else if(逻辑表达式2){
	语句2;
}else if(逻辑表达式3){
	语句3;
}else if(逻辑表达式4){
	语句4;
}else{
	语句5;
}
判断表达式1的结果，如果为true，则执行语句1；
否则如果逻辑表达式2的结果为true，则执行语句2；
否则如果逻辑表达式3的结果为true，则执行语句3；
否则如果逻辑表达式4的结果为true，则执行语句4；
否则执行语句5;

注意：以上3种结构中，都可以不写大括号，那么只能有一句话属于判断语句;

循环语句

for(声明变量;循环条件;变量改值){
	循环语句;
}
	1：声明变量;
	2：判断循环条件：
			true：循环语句；->变量改值->判断循环条件
			false：循环结束

注意：
	1：可以没有声明变量，循环外面提前声明
	2：循环条件也可以没有，死循环，不是没有用处，后面经常使用
	3：也可以没有变量改值
	4：也可以没有大括号，只能有一句话属于循环语句；
	
声明变量;	
while(循环条件){
	循环语句;
	变量改值；
}	
1：声明变量;
2：判断循环条件：
			true：循环语句->判断循环条件
			false：循环结束
注意：逻辑与for完全一样，只是语法结构不同
	

do {
	循环题内容
}while(判断条件);
	
	与while循环的区别：
		1：while先判断，后执行；dowhile先执行，后判断
		2：dowhile循环至少会执行一次；while循环必须先判断；才能根据判断结果是否执行循环体
	

break/continue

break:可以结束switch,也代表结束循环，不是结束判断，不能出现在单独的判断中
continue：结束/跳过当次循环，直接进入下次循环

键盘输入

​ 需要用到jdk提供的类库方法

需要导入jdk提供的一个叫做Scanner的类，
在java源文件最上面导入：import java.util.Scanner;
Scanner s1 = new Scanner(System.in);  //获得键盘输入对象



//		System.out.println("请输入一个整数：");
//		Scanner s1 = new Scanner(System.in);//获得键盘输入对象
//		int a = s1.nextInt();   //获得键盘输入的整数，并赋值给变量a
//		System.out.println(a);
		
//		System.out.println("请输入一个小数：");
//		Scanner s1 = new Scanner(System.in);//获得键盘输入对象
//		float a = s1.nextFloat();
//		System.out.println(a);
		
//		System.out.println("请输入一个小数：");
//		Scanner s1 = new Scanner(System.in);//获得键盘输入对象
//		double a = s1.nextDouble();
//		System.out.println(a);
		
		System.out.println("请输入一个字符串：");
		Scanner s1 = new Scanner(System.in);//获得键盘输入对象
		String a = s1.nextLine();
		System.out.println(a+1);

随机数

需要导入jdk提供的一个叫做Random的类，
在java源文件最上面导入：import java.util.Random;

//		Random r1 = new Random();  //获得jdk提供的随机数对象
		//int a = r1.nextInt(N+1);     //获得[0,N]之间的随机整数
//		int a = r1.nextInt(5);     //获得[0,4]之间的随机整数


//		Random r1 = new Random();  //获得jdk提供的随机数对象
		//int b = r1.nextInt(N) + 1;     //获得[1,N]之间的随机整数
//		int b = r1.nextInt(20) + 1;		//获得[1,20]之间的随机整数
//		System.out.println(a);
//		System.out.println(b);


		Random r1 = new Random();
		//int a = r1.nextInt(65536);  //[0,65535];
		//int a = r1.nextInt(n-m+1) + m;  [m,n]
		int a = r1.nextInt(122-97+1) + 97;     //[97,122]
		System.out.println(a);
		char c1 = (char)a;
		System.out.println(c1);

拆数字

		int a = 16;
		int ge = a / 1 % 10;
		int shi = a / 10 % 10;    
		int bai = a / 100 % 10;
		int qian = a / 1000 % 10;

数组

​ 前面内容当中：定义一个变量，该变量能够存储一个内容，数组：一个变量能存储多个数据

声明1：
	数据类型[]   变量名 = new 数据类型[数字];
	int[] a = new int[5];
	
声明方式2:
	数据类型[]   变量名 = {数值1,数值2,数值3....}
	
	
特点：
	1：数组当中只能存储相同固定的数据类型。
	2：数组的长度是固定长度，长度不能直接增加或者减少，数组的长度为a.length
	3：数组中每一个内容都对应有一个固定的下标，下标从左到右，从0开始加1，语法：a[下标]，数组下标的最大值一定是：a.length - 1
	4：数组属于引用数据类型，不能直接输出数组内容
	5：数组有默认值：
		基本数据类型的数组默认:为0(boolean:false)
		String类型的数组默认值：null	
		
添加数字：数组扩容、缩容
	数组扩容：定义新数组，数组长度为老数组长度+1，将遍历老数组的数据赋值给新数组，新数组的内容前面与老数组一致，最后一个为null，只需要将新数据的最后一个位置添加内容
	
	数组缩容：
		将数组中要删除的数据与数组中最后一个元素换位置(两个变量互换内容)，直接调用扩容的方法，新长度为老长度-1
	
	
	

String

String s1 = "abc"
String s2 = new String("abc");
String s3 = "";    //空字符串
String s4 = null;	关键字null

//		String s1 = "张三";
//		int x = s1.length();  //获取字符串的长度

//		String s1 = "abcdadfsa";
		//int x = s1.indexOf(65);  //在字符串s1中找括号里的字符对应的下标，找不到返回-1
		//int x1 = s1.indexOf('x');	//在字符串s1中找括号里的字符对应的下标，找不到返回-1
		//int x1 = s1.indexOf("bd");	//在字符串s1中找括号里的字符串对应的下标，把字符串当成一个整体，找不到返回-1
		//int x1 = s1.indexOf(97,6);  //在字符串s1中从下标6开始往后找a的下标，找不到返回-1
		//int x1 = s1.indexOf('a',6);  //在字符串s1中从下标6开始往后找a的下标，找不到返回-1
		//int x1 = s1.indexOf("fs",6);  //在字符串s1中从下标6开始往后找fs的下标，找不到返回-1
		//System.out.println(x1);
		
		
		String s1 = "13576";
		char c1 = s1.charAt(100);  //根据下标找字符，下标不能越界   
		System.out.println(c1);
		
		String s1 = "abcdeab12";
		boolean b = s1.startsWith("ab");  //判断s1是否以ab开头
		boolean b1 = s1.endsWith("ba");	//判断s1是否以ba结束
		System.out.println(b);
		System.out.println(b1);
		
		String s1 = "abcdea";
		String s2 = s1.substring(3);  //将字符串s1从下标3开始截取到最后
		String s2 = s1.substring(2, 4);  //将字符串s1从下标2截取到下标4之前
		System.out.println(s2);
		
		String s1 = "abcdeabc";
		//String s2 = s1.replace('a', 'x'); //将字符窜s1中的字符a替换成字符x
		//String s2 = s1.replace("ab", "xxx");//将字符窜s1中的字符ab替换成字符xxx
		System.out.println(s2);
		
		
		String s1 = "abc";
		String s2 = "abc";
		String s3 = new String("abc");
		String s4 = new String("abc");
		
//		boolean b1 = s1 == s2;
//		boolean b2 = s3 == s4;
//		boolean b3 = s1 == s4;   //字符串使用==比较时，牵涉内存的比较，暂时不要使用
//		System.out.println(b1);
//		System.out.println(b2);
//		System.out.println(b3);
		
		boolean b1 = s1.equals(s2);  //比较两个字符串的内容是否一致
		boolean b2 = s3.equals(s4);
		boolean b3 = s1.equals(s4);
		boolean b4 = s1.equals("abc");
		System.out.println(b1);
		System.out.println(b2);
		System.out.println(b3);
		System.out.println(b4);
		
		String s1 = "abC";
		String s2 = new String("aBc");
		boolean b1 = s1.equals(s2);
		boolean b2 = s1.equalsIgnoreCase(s2);  //忽略大小写判断字符串内容是否一致
		System.out.println(b1);
		System.out.println(b2);
		
		
		String s1 = "123-张三-男-23-陕西";
		String[] s2 = s1.split("-"); //根据特殊字符-，将s1内容分割成数组  => String[] s2 = {"1","张三","男","23","陕西"}
		System.out.println("该学生的学号："+s2[0]);
		System.out.println("该学生的姓名："+s2[1]);
		System.out.println("该学生的性别："+s2[2]);
		System.out.println("该学生的年龄："+s2[3]);
		System.out.println("该学生的籍贯："+s2[4]);

Arrays

​ 数组工具类：定义了很多处理数组的方法，需要导入该类：import java.util.Arrays;

	创建一个新数组，长度为新长度，将老数组内容赋值到新数组中
数据类型[] 新数组 = Arrays.copyOf(原数组，新长度);

	将数组内容拼接成字符串
String ss = Arrays.toString(数组);

Integer:

​ int类型整数工具类

int a = Integer.MAX_VALUE;  //获得int最大值
int b = Integer.MIN_VALUE;	//获得int最小值

int c = Integer.parseInt(s1);   //将纯数字类型的字符串转换成int类型