1、关键字和保留字
-
关键字（keyword）的定义和特点
-
定义：被JAVA语言赋予了特殊含义，用作专门用途的字符串。
-
特点：关键字中所有字母都为小写。
-
2、标识符
3、变量
3.1 概念
说明:
- 变量必须先声明，并且赋值初始化，才能使用。
- 变量都定义在其作用域内，在作用域内，它才是有效的。出了作用域，就失效了。
- 同一作用域内，不可以声明两个同名的变量。
3.2 变量的分类
-
整型
说明： -
1byte = 8bit
-
byte范围：-128 ~ 127
-
声明long型变量，必须以“l”或“L”结尾
-
通常定义整型变量时，使用int
-
浮点型
//浮点型表示带小数点的数值。
//float表示数值的范围比long还大。
//通常，定义浮点型变量时，使用double类型。
double d1 = 123.3;
System.out.println(d1 + 1);
//定义float类型变量时，变量要以“f”或“F”结尾。
float f1 = 12.3F;
System.out.println(f1);
- 字符类型 char
//1、字符型：char（1字符 = 2字节）
//2、定义char型变量，通常使用一对’‘,内部只能写一个字符。
char c1 = 'a';
//c1 = 'AB'; 编译不通过
System.out.println(c1);
//表示方式：1.声明一个字符 2.转义字符 3.直接使用Unicode值来表示字符型常量
char c2 = '\n'; //换行符
char c3 = '\t'; //制表符
System.out.print("hello" + c2);
Ststem.out.println("world");
char c4 = '\u0043'; //0043代表C，此时输出的就是C
System.out.println(c4);
- 布尔类型
//布尔型：boolean
//只能取两个值：true和false
boolean b1 = true;
System.out.println(b1);
//常常在条件判断、循环结构中使用
boolean isMarried = true;
if(isMarried){
System.out.println("你就不能参加单身派对!");
}else{
System.out.println("你可以对谈谈女朋友");
}
4、基本数据类型转换
- 自动类型提升
//当容量小的数据类型与容量大的数据类型做运算时，结果自动提升为容量大的数据类型。
//byte、char、short < int < long < float < double
//特别的：当byte、char、short三种类型的变量做运算时，结果为int型
class VariableTest2{
public static void main(String[] args){
byte b1 = 2;
int i1 = 129;
//byte b2 = b1 + i1; 编译不通过,byte范围小
int i2 = b1 + i1;
System.out.println(i2);
float f = b1 + i1; //可以编译通过，在整数后加了个0
System.out.println(f);
char c1 = 'a'; //97
int i3 = 10;
int i4 = c1 + i3;
System.out.println(i4); //输出结果为107
}
}
- **强制类型转换
/*
它是自动类型提升的逆运算。
1.需要使用强转符：（）
2.注意：强制类型转换，可能导致精度损失。
*/
class VariableTest3{
public static void main(String[] args){
double d1 = 12.3;
//int i1 = d1; 运行报错
int i1 = (int)d1; //运行结果为12，截断操作，不要小数点后的（损失精度）
System.out.println(i1);
}
}
5、字符串类型：string
/*
1、String属于引用数据类型
2、声明String类型变量时，使用一对""
3、String可以和8种基本数据类型做运算，且运算只能是连接运算： +
4、运算结果仍然是String类型
*/
class StringTest{
public static void main(String[] args){
String s1 = "Hello World!";
System.out.println(s1);
//***********************
int number = 1001;
String numberStr = "学号：";
String info = numberStr + number; // +:连接运算
System.out.println(info); //输出结果：学号：1001
//练习1
char c = 'a'; //97 A:65
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); //hello10a
//练习2
//* * (打印出来)
System.out.println("* *"); //可以
System.out.println('*' + '\t' + '*'); //不可以
System.out.println('*' + "\t" + '*'); // 可以
System.out.println('*' + '\t' + "*"); //不可以
System.out.println('*' + ('\t' + "*")); //可以
}
}
6、进制之间转换
7、运算符
class AriTest{
public static void main(String[] args){
//除号：/
int num1 = 12;
int num2 = 5;
int result1 = num1 / num2;
System.out.println(result1); //结果为2
int result2 = num1 / num2 * num2;
System.out.println(result2); //结果为10
double result3 = num1 / num2;
System.out.println(result3); //结果为2.0
double result4 = num1 / num2 + 0.0; //结果为2.0
double result5 = num1 / (num2 + 0.0); //结果为2.4
double result6 = (double)num1 / num2; //结果为2.4
//取余运算：%
//结果的符号与被模数的符号相同,常使用%来判断能否被除尽的情况
int m1 = 12;
int n1 = 5;
System.out.println("m1 % n1 = " + m1 % n1); // 结果为m1 % n1 = 2
//（前）++：先自增1，在运算
//（后）++：先运算，后自增1
//不会改变变量本身的数据类型
int a1 = 10;
int b1 = ++a1;
System.out.println("a1 = " + a1 + ",b1 = " + b1); //a1 = 11,b1 = 11
int a2 = 10;
int b2 = a2++;
System.out.println("a2 = " + a2 + ",b2 = " + b2); //a2 = 11,b2 = 10
//（前）--：先自减1，后运算
//（后）--：先运算，后自减1
}
}
/*
1、逻辑运算符操作的都是boolean类型的变量
*/
class LogicTest{
public static void main(String[] args){
//区分& 与 &&
//相同点：两者运算结果相同；当符号左边是true时，二者都会执行符号右边的运算
//不同点：当符号左边是false时，& 继续执行符号右边的运算，&& 不执行
boolean b1 = true;
b1 = false;
int num1 = 10;
if(b1 & (num1++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num1 = " + num1);
boolean b2 = true;
b2 = false;
int num2 = 10;
if(b2 && (num2++ > 0)){
System.out.println("我现在在北京");
}else{
System.out.println("我现在在南京");
}
System.out.println("num2 = " + num2);
//区分| 与 ||
//相同点：两者运算结果相同；当符号左边是false时，二者都会执行符号右边的运算
//不同点：当符号左边是true时，| 继续执行符号右边的运算，|| 不执行
}
}
/*
1、条件表达式的结果为boolean类型
2、如果表达式为true，则执行表达式1；如果表达式为false，则执行表达式2
3、表达式1和表达式2要求是一致的（数据类型）
4、三元运算符可以嵌套使用
5、凡是可以使用三元运算符的地方，都可以使用 if-else 改写；反之不成立
6、如果程序既可以使用三元运算符，又可以使用if-else结构，优先选择三元运算符。原因：简洁、执行效率高
*/
class SanYuanTest{
public static void main(String[] args){
//获取两个整数的最大值
int m = 12;
int n = 5;
int max = (m > n)? m : n;
System.out.println(max); //输出12
}
}
8、程序流程控制
/*
如何从键盘获取不同类型的变量：需要使用Scanner类
具体实现步骤：
1、导包：import java.util.Scanner;
2、Scanner的实例化：Scanner scan = new Scanner(System.in);
3、调用Scanner类的相关方法，来获取指定类型的变量
注意：需要根据相应的方法，来输入指定类型的值，如果输入的数据类型与要求的类型不匹配时，会报异常，导致程序终止。
*/
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
int num = scan.nextInt();
System.out.println(num);
System.out.println("请输入你的姓名：");
String name = scan.next();
System.out.println(name);
System.out.println("请输入你的芳龄：");
int age = scan.nextInt();
System.out.println(age);
System.out.println("请输入你的体重：");
double weight = scan.next();
System.out.println(weight);
System.out.println("你是否相中我了呢？（true/false）");
Boolean islove = scan.nextBoolean();
System.out.println(islove);
//对于char型的获取，Scanner没有提供相关的方法，只能获取一个字符串
}
}
/*
编写程序：由键盘输入三个整数分别存入变量num1、2、3，对它们进行排序，从小到大输出。
说明：
1、if-else结构是可以互相嵌套的
2、如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略，但不建议省略
*/
import java.util.Scanner;
class IfTest2{
public static void main(String[] args){
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数：");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数：");
int num3 = scanner.nextInt();
if (num1 >= num2){
if(num3 >= num1){
System.out.println(num2 + "," + num1 + "," + num3);
}else if(num3 <= num2){
System.out.println(num3 + "," + num2 + "," + num1);
}else{
System.out.println(num2 + "," + num3 + "," + num2)
}
}else{
if(num3 >= num2){
System.out.println(num1 + "," + num2 + "," + num3);
}else if(num3 <= num1){
System.out.println(num3 + "," + num1 + "," + num2);
}else{
System.out.println(num1 + "," + num3 + "," + num2)
}
}
}
}
/*
说明：
1、根据switch表达式中的值，依次匹配各个case中的常量，一旦匹配成功，则进入相应的case结构中，调用其执行语句。当调用完执行语句以后，则仍然继续向下执行其他case结构中的执行语句，直到遇到break关键字或此switch-case结构末尾结束为止。
2、break可以使用在switch-case结构中，表示一旦执行此关键字，就跳出switch-case结构
3、switch结构中的表达式，只能是如下6种数据类型之一：byte、short、char、int、枚举类型（JDK5.0新增）、String类型（JDK7.0新增）
4、case之后只能声明常量，不能声明范围。
5、break关键字在switch结构中是可选的，非必须。但大多数情况加
6、default：相当于if-else结构中的else；default结构是可选的，位置是灵活的
7、如果switch-case结构中的多个case的执行语句相同，则可以考虑合并。
*/
class SwitchCaseTest{
public static void main(String[] args){
int number = 2;
switch(number){
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");
}
}
}
/* for循环
*/
class ForTest{
public static void main(String[] args){
for(int i = 1;i <= 500;i++){
System.out.println("Hello World!"); //输出500个Hello World!
}
//遍历100以内的偶数；输出所有偶数的和；输出偶数的个数
int sum = 0;
int count = 0;
for(int i = 1;i <= 100;i++){
if(i%2 == 0){
System.out.println(i);
sum += i;
count++;
}
}
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
}
}
/*while循环
Ⅰ
while(Ⅱ){
Ⅲ；
Ⅳ；
}
执行过程：Ⅰ > Ⅱ > Ⅲ > Ⅳ > Ⅱ > Ⅲ > Ⅳ > ... > Ⅱ
1、写while循环千万小心不要丢了迭代条件。丢了就会导致死循环
2、for循环和while循环可以相互转换
*/
class ForTest{
public static void main(String[] args){
//遍历100以内所有的偶数
int i = 1;
while(i <= 100){
if(i % 2 == 0){
System.out.println（i）;
}
i++;
}
}
}
/* do while循环
Ⅰ
do{
Ⅲ；
Ⅳ；
}while(Ⅱ);
执行过程：Ⅰ > Ⅲ > Ⅳ > Ⅱ > Ⅲ > Ⅳ > ... > Ⅱ
1、do-while至少会执行一次循环体
*/
class ForTest{
public static void main(String[] args){
//遍历100以内所有的偶数;并计算所有偶数和与个数
int i = 1;
int sum = 0;
int count = 0;
do{
if(i % 2 == 0){
System.out.println(i);
sum += i;
count++;
}
i++;
}
while(i <= 100);
System.out.println("总和为：" + sum);
System.out.println("个数为：" + count);
}
}
说明：
1、不在循环条件部分限制次数的结构：for(;😉 或者 while(true)
2、结束循环有几种方式？
方式一：循环条件部分返回 false
方式二：在循环体中，执行 break
/*
break和continue关键字的使用：
break:循环结构中；结束当前循环
continue:循环结构中；结束当次循环
关键字的后面不能有执行语句
*/
class BreakContinueTest{
public static void main(String[] args){
for(int i = 1;i <= 10;i++){
if(i % 4 ==0){
break; //输出123，到4时结束循环
continue; // 输出123567910...；到4的倍数时就跳过，结束当次循环，不执行输出语句
}
System.out.print(i);
}
}
}
class BreakContinueTest{
public static void main(String[] args){
label:for(int i = 1;i <= 4;i++){
for(int j = 1;j <= 10;j++){
if(j % 4 == 0){
//break label; 结束指定标识的一层循环结构
continue label; //结束指定标识的一层循环结构档次循环
}
System.out.print(j);
}
}
}
}
344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
