一、java介绍：
1.java语言的特性
- 面向对象性
- 健壮性
- 跨平台性（write onece，run anywhere）-–JVM
JDK JRE JVM
河床好比操作底层，jdk好比是河水，java应用程序好比是船
注意事项
- 源文件以.java结尾1
- 源文件中可以有多个class声明的类
- 类中可以有主方法(即main()方法)，其格式是固定的：public static void main(String[] args ){}
- main()方法是程序的入口，方法内是程序的执行部分
- 一个源文件中只能有一个声明为public的类，同时要求此类的类名与源文件名一致
- 每个语句都已”;“结束
- 执行程序：编译：javac.exe 编译完：生成诸多个.class字节码文件；运行：java.exe
2.注释
单行：//
多行：/* 注释文字 */，多行注释不能嵌套
文档注释【java特有】：可以被javadoc解析
/**
*@author：NXF
*@version:V1.0
*@param:XX
*/
javadoc -d 文件名 -author -version Helloworld.java
二、关键字、标识符、变量、运算符、流程控制、数组
1.关键字
特点：所有字母都为小写
2.标识符
凡自己可以命名的地方都叫标识符
规则：26个英文字母大小写，0-9，_或$组成；数字不可以开头；不可以使用关键字和保留字，但能包含关键字和保留字；严格区分大小写，长度无限制；标识符不能包含空格。
java名称命名规范：
- 包名：多单词组成时所有字母都小写：xxyyzz
- 类名、接口名：多单词组成时，所有单词的首字母大写：XxYyZz
- 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxYyZz
- 常量名：所有字母都大写，多单词时每个单词用下划线连接：XX_YY_ZZ
3.变量
java中每个变量必须先声明 ，后使用
格式：数据类型 变量名=初始化值
作用域：一对{}内有效
3.1整型
byte b1= 12;
short s1 = 128;
int i1= 12;
long l1 = 21345612L;#定义long型变量，值的末尾加"L"或'l'，如果不加，会默认为int类型
3.2浮点型（带小数点的数值）
例：float 单精度 、double 双精度（默认类型）
float f1 = 12.3F;#如果不加F，则会被认为是double类型
double d1 = 12.3;
3.3字符型
char只能表示一个字符[英文、中文、标点符号、日文..…]；String表示多个字符
char c1 = 'a';
char c2 = '中';
String str1 = "ab";
String str2 = "中国";
//可以表示转义字符
char c3 = ' ';
char c4 = '
';
char c5 = 'u123'
3.4布尔类型
boolean只能够为true或false，不能取值null
boolean b1 = true;
if(b1){
System.out.println('XXX');
}else{
System.out.println('XXX');
}
3.5变量之间的运算
（不考虑boolean，剩下：char byte short int long float double）
3.5.1自动类型转换
当容量小的数据类型与容量大的数据类型做运算时，容量小的会自动转换为容量大的数据类型：char,byte,short=>int=>long=>float=>double
int i1 = 12;
short s1 = 2;
int i2 = i1 + s1;
float f1 = 12.3F;
float f2 = f1 + i2;
//float d1 = f2 + 12.3;
long l = 12L;
float f3 = l;
需要注意的：当char/byte/short之间做运算时，默认的结果为int类型
short ss1 = 12;
byte bb1 = 1;
char cc1 = 'a';
//short ss2 = ss1 + bb1;错误
int ii1 = ss1 + bb1;//正确
//char cc1 + bb1;错误
short ss2 = 11;//正确
//short ss3 = ss1 + ss2;错误
System.out.println('*'+' '+'*');//93
System.out.println("*"+" "+"*");//* *
3.5.2强制类型转换
容量大的转换成容量小的，要使用强制类型转换符:()
强制类型转换的问题：导致精度的损失
long l1 = 12345L;
int m1 = (int)l1;
byte by1 = (byte)m1;//高位截取
平时常用的字符串，也是一种数据类型：String
String nation = "我是NXF";
字符串与基本数据类型之间的运算：只能是连接运算+，得到的结果仍然是一个字符串
String str = "abc";
String str1 = str + m1;//abc12345
String st1 = 'hello'
int myInt1 = 12;
char ch1 = 'a'
System.out.println(st1 + myInt1 + ch1);//hello12a
System.out.println(myInt1 + ch1 + st1);//109hello
System.out.println(ch1 + st1 + myInt1);//ahello12
字符串的赋值可以为“字符串”，也可以是数字+“字符串”的形式；
String st2 = "12";
str2 = 12 + "";
练习题：
String str1 = 4; //错,4应该加引号
String str2 = 3.5f + "";//对
System.out.println(str2)//输出：3.5
System.out.println(3+4+"Hello!")//输出7Hello!
System.out.println("Hello!"+3+4)//输出Hello!34
System.out.println('a'+1+'Hello!')//输出98Hello!
System.out.println("Hello"+'a'+1)//输出Helloa1
4.运算符
4.1算术运算符
4.1.1除
//除:/
int i = 12;
int j = i/5;
double d = i/5;
double d1 = i/5.0;
double d2 = (double)i/5;
System.out.println(j);//2
System.out.println(d);//2.0
System.out.println(d1);//2.4
System.out.println(d2);//2.4
4.1.2取模
//取模：%取余数,结果的符号取决于被模数A:（A%B）
int i1 = 12 % 5;
int i2 = -12 % 5;
int i3 = 12 % (-5);
int i4 = -12 % (-5);
System.out.println(i1);//2
System.out.println(i2);//-2
System.out.println(i3);//2
System.out.println(i4);//-2
4.1.3前++、后++ | 前--— 后--—
//前++:先自增1,后做运算
//后++:先做运算,后自增1
int myInt1 = 10;
int myInt2 = myInt1 ++;
System.out.println(myInt1);//11
System.out.println(myInt2);//10
int myInt3 = 10;
int myInt4 = ++ myInt3;
System.out.println(myInt3);//11
System.out.println(myInt4);//11
//前++:先自减1,后做运算
//后++:先做运算,后自减1
int myInt11 = 10;
int myInt22 = myInt11 --;
System.out.println(myInt11);//9
System.out.println(myInt22);//10
int myInt33 = 10;
int myInt44 = -- myInt33;
System.out.println(myInt33);//9
System.out.println(myInt44);//9
4.2赋值运算符与比较运算符
4.2.1赋值运算符
+=
int i1 = 10;
i1 += 3;
short s = 10;
//s = s + 3;//编译不通过
s = (short)(s+1);//不建议如此实现
s += 1;//既可以实现运算，又不会更改s的数据类型
System.out.println(s);
区分好==和=的区别
if(b1=true)
System.out.println("结果为真");//输出
else
System.out.println("结果为假");
if(b1==true)
System.out.println("结果为真");
else
System.out.println("结果为假");//输出
*=
int i = 1;
i *= 0.1;//不会报错，会自动计算得到0.1,转成int之后，结果为0
System.out.println(i);//0
4.2.2比较运算符
if(i>1 && i<10){}
不能写为：if(1<i<10){}
4.2.3逻辑运算符
//& && | || ! ^
boolean a = true;
boolean b = false;
System.out.println(a & b);//true
System.out.println(a && b);//false
System.out.println(a | b);//true
System.out.println(a || b);//true
System.out.println(!a & b);//false
System.out.println(a ^ b);//true
&与&&的区别：
&:不管左端是true还是false,右端都会进行运算
&&:当左端为false时，右端不再进行运算
当左端为true时，&和&&都要进行运算
以后使用时，建议使用&&
int i1 = 10;
if (b & (i1++) >0){
System.out.println('A');
}else{
System.out.println('B');//B
}
System.out.println(i1);//11
int i2 = 10;
if (b && (i2++) >0){
System.out.println('A');
}else{
System.out.println('B');//B
}
System.out.println(i2);//10
| 与 ||的区别：
|：当左端为true时，右端照样做运算
||：当左端为true时，右端不再进行运算
当左端为false时，|和||都要计算右端
int i3 = 10;
if (a | (i3++) >0){
System.out.println('A');//A
}else{
System.out.println('B');
}
System.out.println(i3);//11
int i4 = 10;
if (a || (i4++) >0){
System.out.println('A');//A
}else{
System.out.println('B');
}
System.out.println(i4);//10
练习：
int x = 1;
int y = 1;
if (x++ == 2 & ++y == 2){
x = 7;
}
System.out.println("x="+x+",y="+y);//2,2
int x1 = 1;
int y1 = 1;
if (x1++ == 2 && ++y1 == 2){
x1 = 7;
}
System.out.println("x1="+x1+",y1="+y1);//2,1
int x2 = 1;
int y2 = 1;
if (x2++ == 1 && ++y2 == 1){
x2 = 7;
}
System.out.println("x2="+x2+",y2="+y2);//2,2
int x3 = 1;
int y3 = 1;
if (x3++ == 1 || ++y3 == 1){
x3 = 7;
}
System.out.println("x3="+x3+",y3="+y3);//7,1
4.2.4位运算符
两段是数值类型的数据
<< : 左移运算符，num << 1,相当于num乘以2
>> : 右移运算符，num >> 1,相当于num除以2
>>> : 无符号右移，忽略符号位，空位都以0补齐
交换两个数
//交换两个数
int m = 12;
int n = 5;
//方法1:提供一个临时变量
int tmp = m;
m = n;
n = tmp;
//方法2:当m和n很大时,有可能出现精度损失
m = m + n;//m = 12 + 5
n = m - n;//n = 17 - 5
m = m - n;//m = 17 - 12
//方法3:异或,优点:没有上面两种方法的缺点
m = m ^ n;
n = m ^ n;//(m^n)^n
m = m ^ n;//(m^n)^m
4.2.5三元运算符
格式：(条件表达式)?表达式1：表达式2；
要求：表达式1与表达式2为同种数据类型
既然是运算符，就一定会有运算的结果，结果的数据类型与表达式1,2的类型一致
三元运算符在一定程度上，可以与if-else互换。（三元一定可以转换为if-else,反之不成立）
int i = 10;
int j = 20;
int max = (i>j)?i:j;
String str = (i>j)?"i大":"j大";
//String str = (i>j)?i:"j大"；错误
String str1 = (i>j)?"i大":(i==j)?"相等":"j大"
练习：使用三元运算符，输出三个数中的最大值
//使用三元运算符，输出三个数中的最大值
int i = 10;
int j = 20;
int k = 30;
int max = (i>j)?((i>k)?i:k):((j>k)?j:k);
int max1 = (m>n)?m:n;
int max2 = (max1>k)?max1:k;
练习：手动的方式，从控制台输出60的16进制
//方法1：调包
int i = 60;
String binary = Integer.toBinaryString(i);//111100
System.out.println(binary);
String hex = Integer.toHexString(i);//3c
System.out.println(hex);
//方法2：
int j = i & 15;//获取到i的最低4位对应的值
String k1 = (j <= 9)?j+"":(char)(j-10+'a')+"";
i = i >> 4;
int z = i & 15;//高四位
String k2 = (z<=9)?z+"":(char)(z-10+'a')+"";
System.out.println(k2 + k1);
运算符优先级：
5.流程控制
5.1顺序结构
5.2分支结构：if..…else if..…else和switch
//创建一个Scanner类的对象
import java.util.Scanner;
Scanner s = new Scanner(System.in);
//调用此对象的相应的方法,完成键盘输入的值的获取
//next():表示从键盘获取一个字符串
String str = s.next();
//nextInt:从键盘获取一个整数
int score = s.nextInt();
注意：
1.一旦满足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其以下的条件结构语句。
2.如果诸多个条件表达式之间为“互斥”关系，多个结构可以上下调换顺序。
如果诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面。
switch..…case：
[1]根据变量的值，选择相应的case去判断，一旦满足case条件，就执行case的相应语句。如果没有break或者已经到结尾的话，会继续执行其下的case语句。
[2]default：是可选的，而且位置是灵活的，通常将其放在case语句之后。
[3]变量可以是哪些类型：char、byte、short、int、枚举、String(jdk1.7)
[4]case条件：条件只能是值，不能写取值范围
[5]若要判断的语句的条件满足switch变量的数据类型，且值不多的情况下，建议选择switch-case。除此之外，选择if-else。
int i = 2;
switch(i){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
default:
System.out.println("other");
break;
5.3循环结构
[1]for循环
格式：初始化条件+循环条件+迭代条件+循环体
for (int i=0;i<4;i++){
System.out.println(i);
}
for循环与while可以相互转换
[2]while循环
格式：初始化条件+循环条件+迭代条件+循环体
int i = 1;
while i <= 20{
System.out.println(i);
}
[3]do..…while
与while的区别：do..…while循环至少会执行一次
int i = 1;
do{
if(i%2 == 0){
System.out.println(i);
}
i++;
}while(i <= 100);
[4]嵌套循环
//100以内的所有质数
long start = System.currentTimeMillis();//获取系统当前的毫秒数
boolean flag = false;
for(int i=2;i<=10000;i++){
for(int j=2;j <= Math.sqrt(i);j++) {
if (i % j == 0) {
flag = true;
break;
}
}
if(!flag){//flag == false
//System.out.println(i);
}
flag = false;
}
long end = System.currentTimeMillis();
System.out.println("time:"+(end-start));
6.数组
数组是多个相同类型数据的组合，实现对这些数据的统一管理。
数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型。
数组属引用类型，数组型数据是对象，数组中的每个元素相当于该对象的成员变量。
6.1 一维数组
（1）初始化
int[] x或者int x[]
静态初始化：初始化数组与给数组元素赋值同时进行。
String[] names = new String[]{'X','Y','Z'};
动态初始化：初始化数组与给数组元素赋值分开进行。
int scores[] = new int[4]; scores[0] = 87; scores[1] = 89;
（2）引用
下角标从0开始到n-1结束，其中n为数组长度
（3）数组长度
names.length
数组一旦初始化，其长度是不可变的。
（4）遍历
for (int i=0;i<names.length;i++){System.out.println(names[i]);}
（5）数组元素的默认初始化值
- byte、short、int、long：默认值为0
- float、double：默认是0.0
- char：默认是空格
- boolean：默认是false
- 对于引用类型的变量（自定义类、String...）构成的数组而言，默认初始化值为null
举例：
/**
* 功能描述：从键盘读入学生成绩，找出最高分，并输出学生成绩等级
*/
import java.util.Scanner;
class TestTopScore {
public static void main(String[] args) {
// 1.创建Scanner的对象，并从键盘获取学生的个数n
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生的个数:");
int n = sc.nextInt();
// 2.根据输入的学生的个数n，创建一个长度为n的int型的数组
int[] scores = new int[n];
// 3.依次从键盘获取n个学生的成绩，并赋给相应的数组元素，并获取n个学生中的最高分
int maxScore = 0;
for(int i=0;i<n;i++){
int score = sc.nextInt();
scores[i] = score;
if(scores[i] > maxScore){
maxScore = scores[i];
}
}
System.out.println("最高分"+maxScore);
// 4.遍历学生成绩的数组，并根据学生成绩与最高分的差值，赋予相应的等级，并输出
for(int i=0;i<n;i++){
char level;
if(scores[i] >= maxScore-10){
level = 'A';
}else if(scores[i] >= maxScore-20){
level = 'B';
}else if(scores[i] >= maxScore-30) {
level = 'C';
}else {
level = 'D';
}
System.out.println("Student"+i+"score is"+scores[i]+"level"+level);
}
}
}
6.2多维数组
（1）初始化
int[][] y或者int[] y[] 或者int y[][]
静态初始化：
int[][] scores = new int[][]{{1,2,3},{3,4,5},{6}};
动态初始化：
names = new String[6][5] // 方法1;
names = new String[6][]; // 方法2
names[0] = new String[7];
names[1] = new String[2];
// 错误示范
names = new String[][];
names = new String[][5];
（2）引用
int[][] i = new int[3][2]; //int[] i[] = new int[3][2];
i[0][0] = 90;
i[2][1] = 100;
（3）数组的长度
names.length; names[0].length;
（4）遍历
for(int m=0;m<names.length;m++){
for(int n=0;n<names[0].length;n++){
...
}
}
（5）内存结构
一维数组：int[] x或者int x[]
二维数组：int[][] y或者int[] y[] 或者int y[][]
（6）异常
a.数组下标越界
// 1.数组下标越界 java.lang.ArrayIndexOutOfBoundsException
int[] i = new int[10];
i[0] = 90;
// i[100] = 2;
// 2.空指针异常 java.lang.NullPointerException
// （1）
boolean[] b = new boolean[3];
b = null; // 栈中b的地址被改为null，就没法指向堆中的数值
// System.out.println(b[0]);
// （2）
String[] str = new String[4];
// System.out.println(str[3].toString()); // 堆中的对象为null，没法调用方法
// （3）
int[][] j = new int[3][];
j[2][0] = 12; // 一维数组为null，没法找到地址赋值
6.3 数组常用算法
（1）最大值、最小值、平均数、总和
（2）复制、反转
（3）排序