Java语言概述

1、关键字&标识符

关键字：被Java语言赋予了特殊含义，用作专门用途的字符串（单词）
标识符：凡是本身能够起名字的地方都叫标识符

1. 命名的规范（必定要遵照，不遵照就会报编译的错误）

• 由26个英文字母大小写，0-9 ，_或 $ 组成
• 数字不能够开头。
• 不可使用关键字和保留字，但能包含关键字和保留字。
• Java中严格区分大小写，长度无限制。
• 标识符不能包含空格。

2. Java中的名称命名规范：（不遵照，也不会出现编译的错误）

• 包名：多单词组成时全部字母都小写：xxxyyyzzz
• 类名、接口名：多单词组成时，全部单词的首字母大写：XxxYyyZzz
• 变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每一个单词首字母大写：xxxYyyZzz
• 常量名：全部字母都大写。多单词时每一个单词用下划线链接：XXX_YYY_ZZZ

3. 注释:用于说明代码的用途和做用,方便读写和维护

• HTML注释:
• Java注释:
• //单行注释
• /* 多行注释 */
• /** 文档注释 */

2、变量

变量是java程序中最基本的存储单元,能够存储一个数据
java中变量按照数据类型来分类：基本数据类型 vs 引用数据类型(数组 类 接口)

1. 基本数据类型

• 整型：byte（8 bit） short int（默认类型） long
• 浮点型：float double (默认类型) float类型的数据: 必须在小数末尾添加上"F"或"f"
• 字符型：char（‘ ’）(1字符=2字节)
• 布尔类型： boolean（只能取值为true 或false，不能取null）
• 补充：按照在类中存在的位置的不一样：成员变量 vs 局部变量

2. 局部变量

• 局部变量必须编写在方法体中
• 局部变量只能在当前方法体中被访问
• 局部变量在使用以前,必须被赋值

3. 成员变量

• 全局变量只能编写全部方法体以外
• 全局变量能够在任何方法体中被访问
• 全局变量在使用以前若是没有赋值,系统将自动赋予默认值
• 全局变量的操做,会应用其余引用了该变量的代码

4. 基本数据类型的默认值

• 整数: 0
• 小数: 0.0
• 字符: 空格 或 0
• 布尔: false

3、变量的运算

1. 自动类型转换

容量小的数据类型自动转换为容量大的数据类型，

此时的容量大小指的是数的范围的大小

byte、char、short、--->int --->long --->float --->double

short s = 12;
int i = s + 2;
注意：byte short char之间作运算，结果为int型！

2. 强制类型转换

将取值范围大/精度高的数据类型 转为 取值范围小/精度低的数据类型

• 是①的逆过程。使用“（）”实现强转
• 强制类型转换可能精度损失

double d1 = 12.9;
int t1 = (int)d1;//截断操做
System.out.println(t1);

3. 练习

char c = 'a';
int num = 10;
string str = "hello";
System.out.println(c + num + str); //107hello
System.out.println(c + str + num); //ahello10
System.out.println(c + (num + str)); //a10hello
System.out.println((c + num) + str); // 107hello
System.out.println(str + num + c); // helloa10

4、运算符

运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等

1. 算术运算符

+ - + - * / % ++ -- +

1. /: int i = 12; i = i / 5;
2. %：最后的符号只跟被模数相同
3. 前++：先+1，后运算 后++：先运算，后+1
4. +：String字符串与其余数据类型只能作链接运算，且结果为String类型。sysout('' + '\t' + ''); vs sysout("" + '\t' + '')

2. 赋值运算符

= += -= *= /= %=

int i= 12；
i  = i * 5;
i *= 5;//与上一行代码一样的意思
//【特别地】
short s = 10;
s = s + 5;//报编译的异常
s = (short)(s + 5);
s += 5;//s = s + 5，可是结果不会改变s的数据类型。

int m = 2;
int n = 3;
n *= m++;
Sysout(m);// 3
Sysout(n);// 6

int n = 10;
n += (n++) + (++n); //32

变量A++ 与 ++变量A的区别

• 变量A++ / ++变量A: 变量A+1,将结果赋给变量A
• 变量A-- / --变量A: 变量A-1,将结果赋给变量A
• 变量A=变量B++/--:先将变量B的值赋给变量A,而后执行变量自增或自减1 ,先赋值,后自增/自减
• 变量A=++/--变量B:先执行变量B自增或自减1,而后将变量B的值赋给变量A ,先自增/自减,后赋值

3. 比较运算符

== > < >= <= instanceof

【注意】区分== 与 = 区别。
进行比较运算操做之后，返回一个boolean类型的值
4>=3 表达的是4 > 3或者 4 = 3.结果是true。

if(i > 1 && i < 10){ }
不能写为：if(1 < i < 10){}

4. 逻辑运算符（运算符的两端是boolean值）

& && | || ^ !

【注意】区分 & 与 && 的区别，以及 | 与 || 的区别咱们使用的时候，选择&& ， ||

| || ,& &&区别

• &:分别比较先后两个条件,当先后两个条件都为true时,总体为true,不然为false.
• &&[短路与]:当先后两个条件都为true时,总体为true,不然为false. 若是第一个为false时,将再也不判断以后的条件,将直接返回false
• |:分别判断先后两个条件,至少有一个为true时,总体为true,不然为false.
• ||[短路或]:当先后两个条件至少有一个为true时,总体为true,不然为false. 若是第一个条件为true时,将再也不判断以后的条件,直接返回true.

5. 位运算符(两端是数值类型的数据)

<< >> >>> & | ^ ~

• << 在必定范围内，每向左移动一位至关于 * 2

【例子】1.如何交换m = 12和n = 5的值
2.将60转换为十六进制输出。

m = m + n;
n = m - n;
m = m - n;
// 好处不用定义变量，但有局限性，只能用数值类型

6. 三元运算符:(条件表达式)？ 表达式1 ： 表达式2

1. 既然是运算符，必定会返回一个结果，而且结果的数据类型与表达式1，2的类型一致
2. 表达式1与表达式2 的数据类型一致
3. 使用三元运算符的，必定能够转换为if-else。反之不必定成立

5、流程控制

1. 分支结构

1. 条件判断

三种格式

①if(条件表达式){   }

②if(条件表达式){
    //执行的语句1；
  }else{
    //执行的语句2；
  }

③if(条件表达式1){
    //执行的语句1；
  }else if(条件表达式2){
    //执行的语句2；
  }else if( 条件表达式3){
    //执行的语句3；
  }...
  }else{
    //执行的语句；
  }

注意：

• 一旦知足某个条件表达式，则进入其执行语句块执行，执行完毕，跳出当前的条件判断结构，不会执行其如下的条件结构语句
• 若是诸多个条件表达式之间为“互斥”关系，多个结构能够上下调换顺序
• 若是诸多个条件表达式之间为“包含”关系，要求条件表达式范围小的写在范围大的上面

2. 选择结构

switch(变量){
    case 值1:
        
    break;
	case 值2:
        
	break;
	...
	default:

	break;
}

注意：

• 变量能够为以下的数据类型：byte short int char 枚举 String
• case后只能填写变量的值，不能写范围
• default是能够省略的。而且其位置也是灵活的，可是一般将其放在case语句以后
• 一旦知足某个case语句，则进入执行其操做。直至遇到break或者程序终止
• 若要判断的语句的条件知足switch变量的数据类型，且值很少的状况下，建议选择switch-case,除此以外，选择if-else.

2. 循环结构

1. 三种格式

①初始化条件
②循环条件 boolean类型
③迭代部分
④循环体

for(①;②;③){
    ④
}
①
while(②){
    ④
    ③
}

①
do{
    ④
    ③
}while(②);

// 遍历100之内的偶数
for(int i = 1; i<100; i++){
	if(i % 2 == 0){
		System.out.println(i);
    }
}

注意：

• 不一样的循环结构之间能够相互转换
• while和do-while的区别：do-while程序至少会执行一次

2. 嵌套循环

循环结构还能够声明循环。让内层循环结构总体充当外层循环的循环体。
若外层循环执行m次，内层循环执行n次，整个程序执行m*n次

//题目
******
******
******
for(int i = 0;i < 3;i++){
    for(int j = 0;j < 6;j++){
        System.out.print("*");
    }
    System.out.println();
}
//说明：外层循环控制行数，内层循环控制列数

3. 无限循环结构

for(;;){
   ...
   if(  ){
    break;
   }
   ...
}
//或者
while(true){
   ...
   if(  ){
    break;
   }
   ...
}

每每咱们在无限循环结构内部提供循环的终止条件，使用break关键字。不然，此循环将无限制的执行下去，造成死循环,死循环是咱们要避免的

4. break & continue

• break:

  使用switch-case结构或者循环结构中

  在循环结构中，一旦执行到break，就跳出当前循环。

• continue:使用在循环结构中

  • 一旦执行到continue，就跳出当次循环。

for(int i = 1;i <= 10;i++){
    if(i % 4 == 0){
        //break; //123
        continue;  //123567910
    }

    System.out.print(i);
}

在嵌套循环中，使用带标签的break和continue

label:for(int i = 1;i < 5;i++){
    for(int j = 1;j <= 10;j++){
        if(j % 4 == 0){
            //break;
            //continue;
            //break label;
            continue label;
        }
        System.out.print(j);
    }
    System.out.println();
}

6、例题

1. 最大公约数和最小公倍数

/*
题目：输入两个正整数，求最大公约数和最小公倍数
好比：12和20的最大公约数是4，最小公倍数是60
*/
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int m = scan.nextInt();
System.out.println("请输入第二个正整数：");
int n = scan.nextInt();
// 获取这两个数中的最小值
int min = (m <= n) ? m : n;
for(int i = min; i > 0; i--){
    if(m % i == 0 && n % i == 0 ){
        System.out.println("最大公约数为："+i);
        break;
    }
}

// 获取这两个数中的最大值
int max = (m <= n) ? n : m;
for(int i = max; i <= n*m; i++){
    if(i % m == 0 && i % n == 0 ){
        System.out.println("最小公倍数为："+i);
        break;
    }
}

2. 质数

//100之内的质数的输出
boolean isFlag = true;

for(int i = 2; i <= 100; i++){
	for(int j = 2; j < i; j++){
        if(i % j == 0){
            isFlag = False;
            break;
        }
	}
    if(isFlag == ture){
		System.out.println(i);
    }
    isFlag = true;
}


// 优化
 
boolean isFlag = true;

for(int i = 2; i <= 100; i++){
    // j < i的开方
	for(int j = 2; j <= Math.sqrt(i); j++){
        if(i % j == 0){
            isFlag = False;
            break;
        }
	}
    if(isFlag == ture){
		System.out.println(i);
    }
    isFlag = true;
}