Java入门1---关键字、标识符、变量、运算符、流程控制、数组

一、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）排序