Java基础（学习笔记非本人纯原创）

标签：语句 Java int System 笔记 println 本人 public out

Java学习

Java基础语法

一、注释：

注释的说明：

1、注释是在程序指定位置添加的说明信息（例如衣服的吊牌等）

2、注释不参与程序运行，仅起到说明作用

注释的分类：

// 单行注释

/*
多行注释
*/

/**
文档注释	（目前知道就行，后续进行讲解）
*/

二、关键字

关键字概述：

1、具有特定含义的合法标识符

关键字的特点：

1、关键字的字母全部是小写（java）

2、常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观

public class HelloWorld{
    public static void main(String[] args){
        System.out.println("HelloWorld");
    }
}

三、常量

常量的概述：

1、常量：在程序运行的过程中，其值不可以发生改变的量

常量的分类：

常量类型	说明	举例
字符常量	用英文双引号括起来的内容	“张三”
整数常量	不带小数的数字	666，-999
小数常量	带小数的数字	3.14，-6.18
字符常量	用单引号括起来的内容	’A‘，'a'，'0'
布尔常量	布尔值，表示真假	只有两个值：true（真），false（假）
空常量	一个特殊值，空值	值是：null

代码示例：

public class constant{
	public static void main(String[] args){
		//字符串常量
		System.out.println("张三");
		System.out.println("-----------");
		
		// 整数常量
		System.out.println(666);
		System.out.println(-999);
		System.out.println("-----------");
		
		//小数常量
		System.out.println(3.14);
		System.out.println(-6.18);
		System.out.println("-----------");
		
		//字符常量
		System.out.println('A');
		System.out.println('a');
		System.out.println('0');
		System.out.println("-----------");
		
		//布尔常量
		System.out.println(true);
		System.out.println(false);
		System.out.println("-----------");
		
		//空常量
		//空常量是不能直接输出的 后续解释
		//System.out.println(null);
		
	}
}

四、数据类型

计算机存储单元：

1、位（bit）简写b | 字节（byte）简写B | 1位 = 8字节

2、1KB = 1024B 1MB = 1024KB 1GB = 1024MB 1TB = 1024GB

数据类型：

1、Java是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以他们表示的数据大小也是不一样的

2、数据类型的分类：

数据类型内存占用和取值范围：

数据类型	关键字	内存占用（字节）	取值范围（E+38表示乘以10的38次方，同样E-45表示乘以10的负45次方）
	byte	1	-128 ~ 127
整数（前四行）	short	2	-32768 ~ 32767
（给个整数默认是int）	int	4	-2的31次方 ~ 2的31次方-1
	long	8	-2的63次方 ~ 2的63次方-1
浮点数	float	4	负数：-3.402823E+38 ~ -1.401298E-45 正数：1.401298E-45 ~ 3.402823E+38
（给个浮点数默认double）	double	8	负数：-1.797693E+308到-4.9000000E-324 正数：4.9000000E-324 ~ 1.797693E+308
字符	char	2	0 ~ 65535
布尔	boolean	1	true，false

五、变量

变量概述：

1、变量：就是在程序运行过程中，其值可以发生改变的量，是一个内存暂存位置的名字

2、变量使用时需要：表明数据类型、变量名、变量值

3、格式：数据类型变量名 = 变量值;

变量的使用：

1、变量的使用：取值和修改值分别的格式：变量名和变量 = 变量值

代码示例：

public class variate{	
    //以整型变量的使用为例
	public static void main(String[] args){
		//整型定义变量
		int a = 10;
		
		//输出整型变量
		System.out.println(a);
		
		//修改整型变量
		a = 20;
		System.out.println(a);
	}
}

变量使用的注意事项：

1、同一作用域下变量名不能进行重定义（即类中变量名不能重复）

2、变量未作赋值，不能使用

3、long类型变量定义时，为了防止整数过大，后面要加L

4、float类型定义的时候，为了防止类型不兼容，后面要加F

5、代码示例：

public class variate02{
	public static void main(String[] args){
		//定义byte类型的变量
		byte b = 10;
		System.out.println(b);
		
		//定义short类型变量
		short s = 100;
		System.out.println(s);
		
		//定义int类型的变量
		int i = 10000;
		System.out.println(i);
		
		//定义char类型的变量
		char c = 'a';
		System.out.println(c);
		
		//定义boolean类型的变量
		//boolean b = true;			//不能在一个类中（在一个作用域中）对一个变量进行重定义
		//System.out.println(b);
		boolean bb = true;
		System.out.println(bb);
		System.out.println("----------");
		
		//定义long类型的变量
		//long l;	定义变量时一定要初始化 （c中有些会自动给初始值0）
		//long l = 10000000000;		//！！此处注意：左边虽然表示的是long类型 但是右边它却自动识别为int类型 所以赋值越界了
		long l = 100000000000L;
		System.out.println(l);
		System.out.println("----------");
		
		//定义float类型的变量
		//float f = 13.14;		//右边浮点数默认位double类型 在转换为 左边float类型是会有数据丢失 必须指明其为F
		float f = 13.14F;
		System.out.println(f);
		
	}
}

可以自己了解以下Java中的变量类型转换和变量类型查看

六、标识符

标识符概述：

1、标识符：就是给类、方法、变量起名字的符号

标识符定义规则：

1、由数字、字母、下划线(_)和美元($)组成

2、不能以数字开头

3、不能是关键字

4、区分大小写

常见命名约定：

1、小驼峰命名法：（针对方法和变量）

标识符是一个单词的时候，首字母小写例如：name

标识符由多个单词组成的时候，第一个单词小写，其它单词首字母大写例如：firstName

2、大驼峰命名法：（针对类）

标识符是一个单词的时候，首字母大写例如：Student

标识符由多个单词组成的时候，第一个单词小写，其它单词首字母大写例如：GoodStudent

七、类型转换

类型转换分类：

1、自动类型转换：

把一个表示数据范围小的数值或者变量给另一个表示数据范围大的变量，代码示例：

public class ConversionType{
    //注释：没有数据损失且数据类型可以兼容就可以自动类型转换 char->int 是因为ASCLL码 但是byte 和 short字节<=char不行
	public static void main(String[] args){
		//自动类型转换
		double d = 10;
		System.out.println(d);
		
		//定义byte类型的变量
		byte b = 10;
		short s = b;	
		int i = b;
		
		//类型不兼容
		//char c = b;
		
	}
}

2、强制类型转换：

把一个表示数据范围大的数值或者变量赋值给另一个表示数据范围小的变量

格式（与C语言类似）：目标数据类型变量名 = (目标数据类型)值或者变量;

代码示例：

public class ConversionType{
	public static void main(String[] args){
		//强制数据类型转换
		int k = (int)88.88; //虽然可以做 但是会发生数据损失
		System.out.println(k);
	}
}

运算符

一、算数运算符

运算符和表达式：

1、运算符：对常量或者变量进行操作的符号

2、表达式：用运算符把常量或者变量连接起来符合Java语法的式子就可以称为表达式。不同运算符连接的表达式体现的式不同类型的表达式。

3、举例说明：

int a = 10;

int b = a + b;

int c = a + b;

其中： +：是运算符，并且是算数运算符 | a + b：是表达式，由于+是算数运算符，所以这个表达式叫算数表达式

符号	作用	说明
+	加
-	减
*	乘
/	除	（整数相除只能得到整数，除数与被除数中含浮点数才会得到小数）
%	取余	（结果是取得的余数）

4、代码示例：

public class OperationCount{
	public static void main(String[] args){
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//测试对应的算数运算
		System.out.println(a + b);
		System.out.println(a - b);
		System.out.println(a * b);
		System.out.println(a / b);	//整数相除只能得到整数
		System.out.println(a % b);	//除法得到的是商，取余取到的是余数
		
		//除法要得到小数需要浮点数加入
		System.out.println(6.0 / 4);
		System.out.println(6 / 4.0);
	}
}

字符的“+”操作：

1、表达式含多个类型的提升规则：
byte类型，short类型和char类型将被提升到int类型
整个表达式的类型自动提升到表达式中最高等级操作数同样类型
等级顺序：byte,short,char->int->long->float->double

2、代码示例：

public class OperationAdd{
	public static void main(String[] args){
		//定义两个变量
		int i = 10;
		//往后每一位加一	数字：0~9		大小写：a~z	A~Z
		char c = 'A';	//65	
		char c2 = 'a';	//97	小写更大 字母大小写相差32
		char c3 = '0';	//48
		
		//字符的“+”操作
		System.out.println(i + c);	//从结果75中可以得到'A' = 65	是其对应的ASCLL码值
		System.out.println(i + c2);
		System.out.println(i + c3);
		
		System.out.println("以上是输出i + c几的操作，以下是用一个变量来接收这些值");
		
		//char ch = i + c1;	//报错：不兼容的类型
		//原因：一个算数表达式中包含多个数据类型时。整个算数表达式的类型会向变为更高容量的类型
		
		//char类型会被自动提升为int类型
		int j = i + c;
		System.out.println(j);
		
		double d = 10 + 13.14;
		
		float f = 60 + 3.14F;
	}
}

字符串的”+“操作：

1、规则：当操作中前一个为字符串时就执行拼接操作，而当前面没有字符串且连续两个都没有遇到字符串 >时就是算术操作

2、代码示例：

public class OperationAdd02{
	public static void main(String[] args){
		//字符串的 + 操作就是拼接字符串
		System.out.println("it" + "heima");
		
		//字符串与int类型的 + 操作也是拼接操作
		System.out.println("itheima" + 666);
		
		//也是拼接操作
		System.out.println(666 + "itheima");
		
		//逐渐拼接
		System.out.println("黑马" + 6 + 66);
		
		//先做了整型的加法运算 在进行拼接
		System.out.println(1 + 99 + "年黑马");
	}
}

赋值运算符：

符号	作用(除了=都隐含了强制转换)	说明
=	赋值	a = 10，将10赋值给变量a
+=	加后赋值	a += b，将a + b的值给a
-=	减后赋值	a -= b，将a - b的值给a
*=	乘后赋值	a = b，将a b的值给a
/=	除后赋值	a /= b，将a / b的值给a
%=	取余后赋值	a %= b，将a % b的值给a

代码示例：

public class Assignment{
	public static void main(String[] args){
		//把10赋值给int类型的变量
		int i = 10;
		System.out.println("i:" + i);
		
		// += 把左边和右边的数据做加法操作，结果赋值给左边
		//i += 20;
		i = i + 20;	//对于（int）这两个操作结果 就是同样的作用不同的写法
		System.out.println("然后i += 20 = " + i);
		
		//注意：+=的操作底层中隐含了强制转换
		short s = 10;
		//s += 20;		
		s = (short)(s + 20);	//表达式的 + 操作提升	在这个表达式中short类型会提升为int 但是结果却赋值给了short可能存在数据损失
		System.out.println("s:" + s);
	}
}

二、自增自减运算符

1、运算符介绍：

符号	作用	说明
++	自增	变量值加一
--	自减	变量值减一

2、注意事项：

++ 和 --既可以放在变量前面也可以放在变量后面
单独使用时，无论是放在前面还是放在后面，结果都是一样的
参与操作时侯，如果放在前面，是先加加或者减减再参与操作

参与操作时侯，如果放在后面，是先参与操作再加加或者减减

常见使用：都是单独使用

3、代码示例：

public class IncreaseDecrease{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		System.out.println("i:" + i);
		
		//自增的单独使用 ++
		//i++;	一般来说这个常用
		//++i;
		//System.out.println("i:" + i);
		
		//自增的操作使用
		//int j = i++;	
		int j = ++i;
		System.out.println("i:" + i);
		System.out.println("j:" + j);
		
	}
}

三、关系运算

1、关系运算符介绍：

符号	说明
==	a == b，判断a和b的值是否相等，成立为true，不成立为false
!=	a != b，判断a和b的值是否不相等，成立为true，不成立为false
>	a > b，判断a是否大于b，成立为true，不成立false
>=	a >= b，判断a是否大于等于b，成立为true，不成立false
<	a < b，判断a是否小于b，成立为true，不成立为false
<=	a <= b，判断a是否小于等于b，成立为ture，不成立为false

2、代码示例：

public class ConcernOperation{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 10;
		
		// 测试 == 关系运算符
		System.out.println(i == j);
		System.out.println(i == k);
		System.out.println("----------");
		
		// 测试 != 关系运算符
		System.out.println(i != j);
		System.out.println(i != k);
		System.out.println("----------");
		
		//测试 > 
		System.out.println(i > j);
		System.out.println(i > k);
		System.out.println("----------");
		
		//测试 >= 
		System.out.println(i >= j);
		System.out.println(i >= k);
		System.out.println("----------");
		
		//测试 < 
		System.out.println(i < j);
		System.out.println(i < k);
		System.out.println("----------");
		
		//测试 <= 
		System.out.println(i <= j);
		System.out.println(i <= k);
		System.out.println("----------");
		
		//注意：在使用==时将其写成了=	(不会报错只是会将其当作赋值符号来使用)
		System.out.println(i = j);
		
	}
}

四、逻辑运算符

基本罗杰运算符：

1、逻辑运算符概述:

在数学中，一个数据x，大于3，小于6，我们可以这样进行表示：3<x<6

在java中，需要把上面的式子先进行拆解，在进行合并表达

//例如：
//x > 3 与 x < 6 -> x > 3 & x < 6

其中&&就是一个逻辑运算符，我们可以这样说，逻辑运算符是用来连接关系表达式的运算符

当然逻辑运算符也可以是直接连接布尔类型的常量或者变量

2、逻辑运算符介绍：

符号	作用	说明
&	逻辑与	a&b，a和b都是true,结果为true，否则为false
\|	逻辑或	a\|b，a和b都是false,结果为false，否则为true
^	逻辑异或	a&b，a和b结果不同为true，相同为false
!	逻辑非	!a，结果和a的结果正好相反

3、代码示例：

public class LogicOperation{
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		//语句后面的true与false是指的表达式的结果
		
		//&		有false就false
		System.out.println((i > j) & (i > k));	//false & false
		System.out.println((i < j) & (i > k));	//trur & false
		System.out.println((i > j) & (i < k));	//false & true
		System.out.println((i < j) & (i < k));	//true & true
		System.out.println("----------");
		
		//|		有true就true
		System.out.println((i > j) | (i > k));	//false | false
		System.out.println((i < j) | (i > k));	//trur | false
		System.out.println((i > j) | (i < k));	//false | true
		System.out.println((i < j) | (i < k));	//true | true
		System.out.println("----------");
		
		//^		相同为false 不同为true
		System.out.println((i > j) ^ (i > k));	//false ^ false
		System.out.println((i < j) ^ (i > k));	//trur ^ false
		System.out.println((i > j) ^ (i < k));	//false ^ true
		System.out.println((i < j) ^ (i < k));	//true ^ true
		System.out.println("----------");
		
		//!		
		System.out.println(!(i > j));			//!false
		System.out.println(!!(i < j));			//!!trur
		System.out.println(!!!(i > j));			//!!!false
		System.out.println(!!!!(i < j));		//!!!!true
		System.out.println("----------");
	}
}

短路逻辑运算符：

1、短路逻辑运算符介绍：

符号	作用	说明
&&	短路与	作用与&相同，但是有短路效果（即在得到左边表达式为false后直接停止执行并得出结果false）
\|\|	短路或	作用与\|相同，但是有短路效果（即在得到左边表达式为true后直接停止执行并得出结果true）

2、代码示例：

public class LogicOperation{
	//使用时 注意++运算的 前置和后置的优先级
	public static void main(String[] args){
		//定义变量
		int i = 10;
		int j = 20;
		int k = 30;
		//语句后面的true与false是指的表达式的结果
		
		//&&		有false就false
		System.out.println((i > j) && (i > k));	//false && false
		System.out.println((i < j) && (i > k));	//trur && false
		System.out.println((i > j) && (i < k));	//false && true
		System.out.println((i < j) && (i < k));	//true && true
		System.out.println("----------");
		
		//||		有true就true
		System.out.println((i > j) || (i > k));	//false || false
		System.out.println((i < j) || (i > k));	//trur || false
		System.out.println((i > j) || (i < k));	//false || true
		System.out.println((i < j) || (i < k));	//true || true
		System.out.println("----------");
		
		//&&与&区别	运算结果一样 只是对于&&（短路与）左边表达式结果一旦为false 就会定义执行直接判断结果为false
		//System.out.println((i++ > 100) & (j++ > 100));	//false & false
		//System.out.println((i++ > 100) && (j++ > 100));	//false && false
		//System.out.println("i:" + i);
		//System.out.println("j:" + j);
		
		
		//||与|区别	运算结果一样 只是对于||（短路与）左边表达式结果一旦为true 就会定义执行直接判断结果为true
		//System.out.println((++i > 10) | (++j > 20));	//true | true		前置先运算所以比较数使用 10 和 20
		System.out.println((i++ > 9) || (j++ > 19));	//true || true
		System.out.println("i:" + i);
		System.out.println("j:" + j);
	}
}

3、注意：对于&与|而言无论左边真假都要执行后面语句，而&&与||而言左边一旦可以判断结果就不在执行

五、三元运算符

1、格式：关系表达式? 表达式1: 表达式2;

范例：a > b ? a : b;

2、计算规则：

首先计算关系表达式的值

当结果为true时，表达式1的值就是运算结果

当结果为false时，表达式2的值就是运算结果

3、代码示例：

public class TernaryOperation{
	public static void main(String[] args){
		//定义两个变量
		int a = 10;
		int b = 20;
		
		//获取两个数中的较大值
		int max = a > b ? a : b;
		
		//输出结果
		System.out.println("max:" + max);
	}
}

六、运算符案例

三元运算符案例之两只老虎：

public class TwoTiger{
	public static void main(String[] args){
		//定义两个变量存储两只老虎的体重单位kg
		int weight1 = 180;
		int weight2 = 200;
		
		//使用三元运算符判断两只老虎体重是否相等
		boolean b = (weight1 == weight2) ? true : false;
		
		System.out.println("b:" + b);
	}
}

三元运算符之三个和尚：

public class ThreeMonk{
	public static void main(String[] args){
		//定义三个变量接收三个和尚的身高单位cm
		int height1 = 150;
		int height2 = 210;
		int height3 = 165;
		
		int tempHeight = height1 > height2 ? height1 : height2;
		int maxHeight = tempHeight > height3 ? tempHeight : height3;
		
		System.out.println("maxHeight:" + maxHeight);
	}
}

数据输入

一、Scanner类

1、导包

import java.util.Scanner;

导包操作必须出现在类定义的上边

2、创建对象

Scanner sc = new Scanner(System.in);

上面这个格式里面，只有sc是变量名，可以变，其它的都不允许变

3、接收数据

int i = sc.nextInt();

上面这个格式里面，只有i是变量名可以改变，其它都不允许变

4、代码示例：

//导包
import java.util.Scanner;

public class Intput{
	public static void main(String[] args){
		//创建对象
		Scanner sc = new Scanner(System.in);
		
		//接收数据
		int x = sc.nextInt();
	
		//输出数据
		System.out.println("x:" + x);	
	}
}

二、数据输入案例

数据输入案例三个和尚：

//导包
import java.util.Scanner;

public class Intput2{
	public static void main(String[] args){
		//创建Scanner对象
		Scanner sc = new Scanner(System.in);	//类比C++有参构造函数
		
		//定义三个变量来接收三个和尚的身高数据
		System.out.println("请输入第一个和尚的身高：");
		int height1 = sc.nextInt();
		System.out.println("请输入第二个和尚的身高：");
		int height2 = sc.nextInt();
		System.out.println("请输入第三个和尚的身高：");
		int height3 = sc.nextInt();
		
		//比较身高
		int tempHeight = height1 > height2 ? height1 : height2;
		int maxHeight = height3 > tempHeight ? height3 : tempHeight;
		
		//输出数据
		System.out.println("这三个和尚中身高最高的是:" + maxHeight);
	}
}

分支语句

一、流程控制

前面使用的就是从上到下的执行流程。

顺序结构：

1、顺序结构简述：顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，

程序中大多数代码都是这样执行的。

2、参考代码：

public class ProcessControl{
	public static void main(String[] args){
		System.out.println("开始");
		
		System.out.println("语句A");
		System.out.println("语句B");
		System.out.println("语句C");
		
		System.out.println("结束");
	}
}

分支结构（if,switch）：

1、if语句：

1.1格式一：
if(关系表达式){
语句体;
}

1.1执行流程:

先计算关系表达式的值

是true执行里面的语句块，是false就跳过

继续执行后面的语句内容

1.1参考代码：

public class ProcessControl2{
	public static void main(String[] args){
		System.out.println("开始");
		
		//定义两个变量
		int a = 20;
		int b = 30;
		
		//需求：判断a和b的值是否相等，如果相等，就在控制台输出：a等于b
		if(a == b){
			System.out.println("a等于b");
		}
		
		int c = 20;
		if(a == c){
			System.out.println("a等于c");
		}
		
		System.out.println("结束");
	}
}

1.2格式二

if(关系表达式){

语句体1;

}

else{

语句体2;

}

1.2执行流程：

先计算关系表达式的值

是true执行if里面的语句块，是false就执行else中的语句块（只会执行其中之一）

继续执行后面的语句内容

1.2参考代码：

public class ProcessControl3{
	public static void main(String[] args){
		System.out.println("开始");
		
		//定义两个变量
		int a = 10;
		int b = 20;
		//重新赋值b
		b = 5;
		
		//需求：判断a是否大于b，如果是，在控制台输出：a的值大于b，如果不是，在控制台输出：a的值不大于b
		if(a > b){
			System.out.println("a的值大于b");
		}
		else{
			System.out.println("a的值不大于b");
		}
		
		
		System.out.println("结束");
	}
}

1.3格式三

if(关系表达式1){

语句块1;

}

else if(关系表达式2){

语句块2;

}

...

else{

语句块n + 1;

}

1.3执行流程：

依次计算关系表达式的值

若关系表达式1为真，执行语句块1，停止执行后续判断

若关系表达式2为真，执行语句块2，停止执行后续判断

若关系表达式3为真，执行语句块3，停止执行后续判断

...

上述表达式都为假，执行语句块n + 1

1.3参考代码：

//导包
import java.util.Scanner;

public class ProcessControl4{
	public static void main(String[] args){
		System.out.println("开始");
		
		//需求：键盘录入一个星期数（1，2，3...7），输出对应星期一，星期二，星期三...星期日
		
		//创建Scanner对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请你输入一个星期数（1~7）：");
		int week = sc.nextInt();
		if(week == 1){
			System.out.println("星期一");
		}
		else if(week == 2){
			System.out.println("星期二");
		}
		else if(week == 3){
			System.out.println("星期三");
		}
		else if(week == 4){
			System.out.println("星期四");
		}
		else if(week == 5){
			System.out.println("星期五");
		}
		else if(week == 6){
			System.out.println("星期六");
		}
		else if(week == 7){
			System.out.println("星期日");
		}
		else{
			System.out.println("你输入的数据不符合要求");
		}
		
		System.out.print("结束");
	}
}

if语句案例：

1、判断奇偶数代码示例：

//导包
import java.util.Scanner;

public class IfTest{
	public static void main(String[] args){
		System.out.println("请输入一个整数：");
		
		//创建对象
		Scanner sc = new Scanner(System.in);
		//接收数据
		int num = sc.nextInt();
		//判断
		if(num % 2 == 0){
			System.out.println("该整数是偶数");
		}
		else{
			System.out.println("该整数是奇数");
		}
	}
}

2、考试奖励代码示例：

//导包
import java.util.Scanner;

public class ScoreAward{
	
	public static void main(String[] args){
		System.out.println("请输入小明考试的成绩：");
		
		//创建Scanner对象
		Scanner sc = new Scanner(System.in);
		
		//接收变量
		int score = sc.nextInt();
		
		//判断并进行数据测试：正确数据，边界数据，错误数据
		if(score > 100 ||score < 0){
			System.out.println("你输入的数据有误");
		}
		else{
			if(score >= 95 && score <= 100){
			
				System.out.println("山地自行车一辆");
			}
			else if(score >= 90 && score <= 94){
				System.out.println("游乐场游玩一次");
			}
			else if(score >= 80 && score <= 89){
				System.out.println("变形金刚玩具一个");
			}
			else{
				System.out.println("胖揍一顿");
			}
		}
    }
}

switch语句:

1、格式：

switch(表达式){

case 值1:

语句体1;

break;

case 值2:

语句体2;

break;

...

default:

语句体n + 1;

[break;] //表示可写可不写

}

2、格式说明:

表达式：取值为：byte、short、int、char，JDK5以后可以是枚举，JDK7后可以是String

case：后面跟的是要和表达式进行比较的值

break：表示中断

default：表示所有情况都不匹配的时候，就执行该处的内容，和if语句中的else相似

3、代码示例:

//导包
import java.util.Scanner;

public class SwitchTest{
	public static void main(String[] args){
		System.out.println("开始");
		
		//创建Scanner对象
		Scanner sc = new Scanner(System.in);
		
		System.out.println("请输入星期天数（1~7）：");
		//接收数据
		int week = sc.nextInt();
		
		//switch 测试		输入星期天数 int类型	输出对应星期天
		switch(week){
			case 1:
			System.out.println("星期一");
			break;
			case 2:
			System.out.println("星期二");
			break;
			case 3:
			System.out.println("星期三");
			break;
			case 4:
			System.out.println("星期四");
			break;
			case 5:
			System.out.println("星期五");
			break;
			case 6:
			System.out.println("星期六");
			break;
			case 7:
			System.out.println("星期日");
			break;
			default :
			System.out.println("你输入的数据有误！");
		}
		
		System.out.println("结束");
	}
}

4、switch案例春夏秋冬:

注意：在switch语句中，如果case控制的语句后面不写break,将出现穿透现象，在判断下一个case值得情况，向下运行直到遇到break，或者switch语句停止。

//导包
import java.util.Scanner;

public class SwitchMonth{
	public static void main(String[] args){
		//创建Scanner对象
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入对应的月份数（1~12）：");
		//接收月份数据
		int month = sc.nextInt();
		
		//switch判断：春：3，4，5		夏：6，7，8		秋：9，10，11		冬：12，1，2
		/*
		switch(month){
			case 1:
			System.out.println("现在是冬天");
			break;
			case 2:
			System.out.println("现在是冬天");
			break;
			case 3:
			System.out.println("现在是春天");
			break;
			case 4:
			System.out.println("现在是春天");
			break;
			case 5:
			System.out.println("现在是春天");
			break;
			case 6:
			System.out.println("现在是夏天");
			break;
			case 7:
			System.out.println("现在是夏天");
			break;
			case 8:
			System.out.println("现在是夏天");
			break;
			case 9:
			System.out.println("现在是秋天");
			break;
			case 10:
			System.out.println("现在是秋天");
			break;
			case 11:
			System.out.println("现在是秋天");
			break;
			case 12:
			System.out.println("现在是冬天");
			break;
			default :
			System.out.println("你输入的数据有误！");
			//dreak;
		}
		*/
		
		//case穿透	case语句中没有break会 执行下一个case语句
		switch(month){
			case 1:
			case 2:
			case 12:
				System.out.println("现在是冬天");
				break;
			case 3:
			case 4:
			case 5:
				System.out.println("现在是春天");
				break;
			case 6:
			case 7:
			case 8:
				System.out.println("现在是夏天");
				break;
			case 9:
			case 10:
			case 11:
				System.out.println("现在是秋天");
				break;
			default :
				System.out.println("你输入的数据有误！");
		}
	}
}

循环结构：(for,while,do...while)

循环整体介绍：

1、循环结构得特征：重复做某件事情，具有明确的停止标志

2、循环结构组成：

初始化语句：用于便是循环开启时得状态，简单说就是循环开始的时候什么样（只执行一次）

条件判断语句：用于表示循环反复执行的条件，简单来说就是判断循环是否能一直执行下去

循环体语句：用于表示循环反复执行的内容，简单来说就是循环反复执行的事情

条件控制语句：用于表示循环执行中每次变化的内容，简单来说就是控制循环是否能够执行下去

3、对应语法：

初始化语句：这里可以是一条或者多条语句，这些语句可以完成一些初始化操作

条件判断语句：这里使用一个结果值为boolean类型的表达式，这个表达式能决定是否执行循环体。例如：a < 3

循环体语句：这里可以是任意的语句，这些语句将反复执行

条件控制语句：这里通常使用一条语句来改变变量的值，从而达到控制循环是否继续向下执行的效果，常见i++, i--这样的操作

1、for循环语句：

1、格式：

for(初始化语句; 条件判断语句; 条件控制语句){

循环语句体;

}

2、执行流程

先执行初始化语句->再执行条件判断语句，看其结果是true还是false，如果是true继续执行，false循环结束—>执行循环体语句->执行条件控制语句->回到条件判断继续判断

3、代码示例：

public class ForCirculation{
	public static void main(String[] args){
		//需求，在控制台输出5次"HelloWorld"
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		System.out.println("HelloWorld");
		//使用分割线隔开两次操作
		System.out.println("----------");
		
		//用循环语句改进
		for(int i = 0; i < 5; i++){
			System.out.println("HelloWorld");
		}
	}
}

4、for循环案例输出数据

public class ForTest{
   //要求输出1~5 和 5~1 
	public static void main(String[] args){
		//使用for循环输出1~5
		for(int i = 1; i <= 5; i++){
			System.out.println(i);
		}
		
		System.out.println("----------");
		
		//使用for循环输出5~1
		for(int i = 5; i >= 1; i--){
			System.out.println(i);
		}
	}
}

5、for循环案例求和

public class ForTest{
    //要求保存并输出1~5的和
	public static void main(String[] args){
		//定义一个变量接收保存数据
		int sum = 0;
		
		//使用for循环计算1~5之间的数据和
		for(int i = 1; i <= 5; i++){
			//写好循环结构后 通过i来依次获取1~5的数据 并一个一个将其加到sun变量中 
			sum += i;
		}
		
		//输出数据
		System.out.println("1~5之间的数据和：" + sum);
	}
}

6、for循环案例求偶数和

public class ForTest{
    //要求得到1~100的偶数和
	public static void main(String[] args){
		//定义一个变量
		int sum = 0;
		
		//使用for循环获取数据
		for(int i = 1; i <= 100; i++){
			//使用if语句对数据进行判断是否符合偶数
			if(i % 2 == 0){
				//符合则累加
				sum += i;
			}
		}
		
		//输出求和结果
		System.out.println("1~100的偶数和为：" + sum);
	}
}

7、for循环案例水仙花：

public class ForTest{
    //要求输出三位水仙花数
	public static void main(String[] args){
		/*
		任意数字的指定位数的数值如何获取：先整除要求的数字将其移到个位上，再使用取余操作取出最后一位上的值
		*/
		
		//通过for循环获得所有三位数
		for(int i = 100; i <= 999; i++){
			//先获取三位数的每个位数
			int a = i % 10;				//获取个位
			int b = (i / 10) % 10;		//获取十位
			int c = i / 100;			//获取百位
			
			//再判断是否符合水仙花数的条件
			if(i == a*a*a + b*b*b + c*c*c){
				System.out.println(i);
			}
			
		}
	}
}

8、for循环案例统计

public class ForTest{
    //要求统计三位水仙花数个数
	public static void main(String[] args){
		//定义一个变量统计个数
		int count = 0;
		
		//通过for循环获得所有三位数
		for(int i = 100; i <= 999; i++){
			//先获取三位数的每个位数
			int a = i % 10;				//获取个位
			int b = (i / 10) % 10;		//获取十位
			int c = i / 100;			//获取百位
			
			//再判断是否符合水仙花数的条件
			if(i == a*a*a + b*b*b + c*c*c){
				count++;
			}
		}
		
		//输出水仙花数个数
		System.out.println("三位水仙数个数为：" + count);
	}

2、while循环语句：

1、格式：

while(条件判断语句){

循环体语句;

条件控制语句;

}

2、流程：先执行初始化语句->再执行条件判断语句，看其结果是true还是false，如果是true继续执行，false循环结束—>执行循环体语句->执行条件控制语句->回到条件判断继续判断

3、代码示例

public class WhileCirculation{
	public static void main(String[] args){
		//需求：在控制台输出5次"HellWorld"
		 
		//初始化语句
		int i = 1;
		
		while(i <= 5){	//()内的是条件判断语句
			//循环体语句
			System.out.println("HelloWorld");
			
			//条件控制语句（注意不要漏写会进入死循环）
			i++;
		}
	}
}

4、while循环案例珠穆朗玛峰

public class WhileTest{
	public static void main(String[] args){
		//定义一个变量记录次数
		int count = 0;
		
		//初始化语句
		double paper = 0.1;
		
		while(paper <= 8844430){	//此处paper是double类型	但是8844430是int类型 能够判断是因为 <= 隐含强制转换
			count++;
			
			//条件控制语句
			paper *= 2;
		}
		
		//输出结果
		System.out.println("需要折叠的次数是：" + count + "次");
		
	}
}

3、do...while循环语句：

1、格式：

do{

循环语句;

条件控制语句;

}while(条件判断语句);

2、流程：先执行初始化语句->执行循环体语句->执行条件控制语句->再执行条件判断语句，看其结果是true还是false，如果是true继续执行，false循环结束->回到条件判断继续判断即循环至少执行一次

3、代码示例：

public class DoWhileCirculation{
	public static void main(String[] args){
		//do while循环演示
		int i = 1;
		
		do{
			//感觉这条语句会多输出一次
			System.out.println("HelloWorld");
			//但是循环条件控制语句也在 循环判断语句之前所以还是执行五次	（从2开始判断但至少执行一次相互抵消）
			i++;
		}while(i <= 5);
	}
}

4、三种循环的区别：

1、代码示例：

public class ThreeCirculation{
	public static void main(String[] args){
		/*区别一
		//for循环
		for(int i = 3; i < 3; i++){
			System.out.println("我爱Java");
		}
		System.out.println("----------");
		
		//while循环
		int j = 3;
		while(j < 3){
			System.out.println("我爱Java");
			j++;
		}
		System.out.println("----------");
		
		//do...while循环	发现do...while即使条件第一次为false还是至少会执行一次
		int k = 3;
		do{
			System.out.println("我爱Java");
			k++;
		}while(k < 3);
		*/
		
		//------------------------------------------------
		
		/*区别二
		//for循环
		for(int i = 1; i < 3; i++){
			System.out.println("我爱Java");
		}
		System.out.println("----------");
		//System.out.println("i：" + i);		//在for循环括号中定义的初始条件for结束后无法使用（被自动销毁了）
		
		//while循环
		int j = 1;
		while(j < 3){
			System.out.println("我爱Java");
			j++;
		}
		System.out.println("----------");
		System.out.println("j：" + j);
		*/
		
		//-----------------------------------------------
		
		//三种死循环 Ctrl+C结束死循环
		/*for循环的死循环
		for(;;){
			System.out.println("for");
		}
		*/
		
		/*while循环的死循环
		while(true){
			System.out.println("while");
		}
		*/
		
		/*do...while循环的死循环
		do{
			System.out.println("do...while");
		}while(true);
		*/
		
	}
}

5、控制跳转语句（continue与break）：

1、概述：

continue：用在循环体中，基于条件控制，跳过某次循环体内容执行，继续下一次的执行

break：用在循环体中，基于条件控制，终止循环体内容执行，也就是说结束当前的整个循环

2、代码示例：

public class FlowControl{
	public static void main(String[] args){
		for(int i = 1; i <= 5; i++){
			//条件判断为true就执行if内语句 
			if(i % 2 == 0){	
				//continue;
				break;
			}
			
			System.out.println(i);
		}
	}
}

6、循环嵌套：

1、语句结构：

顺序结构以分号结尾，表示一句的结束
分支语句一对大括号表示if的整体结构，整体描述一个完整的if语句

一对大括号表示switch的整体结构，整体描述一个完整的switch语句
循环语句一对大括号表示for的整体结构，整体描述一个完整的for语句

一对大括号表示while的整体结构，整体描述一个完整的while语句

do...while以分号结尾，整体描述一个完整的do...while语句

任何语句对外都可以看成是一句话，一句代码（一个语句块）

2、代码示例：

/*
	循环嵌套：
		循环语句中包含循环语句
	需求：
		在控制台输出一天的小时和分钟
			分钟：0 <= minute <60
			小时：0 <= hour <24
*/
public class CirculationNest{
	public static void main(String[] args){
		/*
		System.out.println("0时0分");
		System.out.println("0时1分");
		System.out.println("0时2分");
		System.out.println("0时3分");
		System.out.println("----------");
		System.out.println("1时0分");
		System.out.println("1时1分");
		System.out.println("1时2分");
		System.out.println("1时3分");
		System.out.println("----------");
		System.out.println("2时0分");
		System.out.println("2时1分");
		System.out.println("2时2分");
		System.out.println("2时3分");
		*/
		
		/*
		//循环改进
		for(int minute = 0; minute < 4; minute++){
			System.out.println("0时" + minute + "分");
		}
		System.out.println("----------");
		
		for(int minute = 0; minute < 4; minute++){
			System.out.println("1时" + minute + "分");
		}
		System.out.println("----------");
		
		for(int minute = 0; minute < 4; minute++){
			System.out.println("2时" + minute + "分");
		}
		*/
		
		//循环嵌套改进	外循环控制小时	内循环控制分钟
		for(int hour = 0; hour < 3; hour++){
			for(int minute = 0; minute < 4; minute++){
				System.out.println(hour + "时" + minute + "分");
			}
			
			if(hour < 2){
				System.out.println("----------");
			}
		}
	}
}

7、Random：

1、Random的作用和使用步骤

作用：用于产生一个随机数

2、使用步骤：

导包：

import java.util.Random;

创建对象

Random r = new Random();

获取随机数

int number = r.nextInt(10); //获取数据的范围：[0, 10) 包括0，不包括10

3、代码示例：

//导包
import java.util.Random;

public class RandomTest{
	public static void main(String[] args){
		//创建Random对象
		Random r = new Random();
		
		//用循环获取10个随机数
		for(int i = 0; i < 10; i++){
			//接收数字
			int number = r.nextInt(10);
		
			//输出数字
			System.out.println("number:" + number);
		}
		
		//需求 获取一个1~100之间的随机数
		int x = r.nextInt(100) + 1;
		System.out.println(x);
	}
}

4、Random案例猜数字

1、代码示例：

//1、导包
import java.util.Random;
import java.util.Scanner;

public class RandomTest2{
	public static void main(String[] args){
		//提示语：
		System.out.println("现在进行一个猜数字游戏，请你输入一个整型数据（1~100）：");
		
		//创建对象
		Random r = new Random();
		Scanner sc = new Scanner(System.in);
		
		//设置变量接收数字，并限定范围
		int number = r.nextInt(100) + 1;
		
		while(true){
			
			//定义变量接收输入数字
			int element = sc.nextInt();
			
			if(element < 1 || element > 100){
				System.out.println("你输入的数据不在规定范围内");
				System.out.println("请再次输入数据：");
			}
			
			else{
				if(element > number){
					System.out.println("你猜的数据大了");
					System.out.println("请再次输入数据：");
				}
				else if(element < number){
					System.out.println("你猜的数据小了");
					System.out.println("请再次输入数据：");
				}
				else{
					System.out.println("恭喜你猜对了");
					//程序结束
					break;
				}
			}
		}
		
	}
}

标签：语句,Java,int,System,笔记,println,本人,public,out
From： https://www.cnblogs.com/fragmentary/p/16722168.html

Java基础（学习笔记非本人纯原创）

Java学习

Java基础语法

一、注释：

注释的说明：

注释的分类：

二、关键字

关键字概述：

关键字的特点：

三、常量

常量的概述：

常量的分类：

代码示例：

四、数据类型

计算机存储单元：

数据类型：

数据类型内存占用和取值范围：

五、变量

变量概述：

变量的使用：

代码示例：

变量使用的注意事项：

六、标识符

标识符概述：

标识符定义规则：

常见命名约定：

七、类型转换

类型转换分类：

运算符

一、算数运算符

运算符和表达式：

字符的“+”操作：

字符串的”+“操作：

赋值运算符：

二、自增自减运算符

三、关系运算

四、逻辑运算符

基本罗杰运算符：

短路逻辑运算符：

五、三元运算符

六、运算符案例

三元运算符案例之两只老虎：

三元运算符之三个和尚：

数据输入

一、Scanner类

二、数据输入案例

数据输入案例三个和尚：

分支语句

一、流程控制

顺序结构：

分支结构（if,switch）：

1、if语句：

switch语句:

循环结构：(for,while,do...while)

相关文章

赞助商

阅读排行