尚硅谷Java入门视频教程第二章——Java基本语法

尚硅谷Java入门视频教程第二章

  • 第一章复习
    • 课后习题
    • Java语言概述
  • 第2章:Java基本语法
    • 2.1 关键字和保留字
    • 2.2 标识符(Identifier)
    • 2.3 变量
      • 2.3.1 变量基本概念
      • 2.3.2 变量分类——按数据类型
        • 1. 整数类型:byte \ short \ int \ long
        • 2. 浮点类型:float \ double
        • 3. 字符类型:char
        • 4. 布尔类型:boolean
        • 引用数据类型——String
      • 2.3.3 基本数据类型之间的运算规则
      • 2.3.4 变量之进制
    • 2.4 运算符
      • 2.4.1 算术运算符
      • 2.4.2 赋值运算符
      • 4.2.3 比较运算符
      • 4.2.4 逻辑运算符
      • 2.4.5 位运算符
      • 2.4.6 三元运算符
      • 运算符优先级
    • 2.5 程序流程控制
      • 2.5.1 顺序结构
      • 2.5.2 分支语句1:if-else结构
        • java随机数生成
      • 2.5.3 分支语句2:switch-case结构
      • 2.5.4 循环结构1:for循环
      • 2.5.5 循环结构2:while循环
      • 2.5.6 循环结构3:do-while循环
      • 2.5.7 嵌套循环(多重循环)
      • 2.5.8 特殊关键字的使用:break、continue
  • 项目一:家庭收支记账软件

第一章复习

课后习题

  1. JDK,JRE和JVM的关系是什么?
    JDK = JRE + 开发工具集(例如Javac编译工具等)
    JRE = JVM + Java SE标准类库
  2. 为什么要配置path环境变量?如何配置?
    配置path环境变量原因:为了在各个路径下都可以调用java相关指令
    配置方法:计算机->属性->高级系统设置->环境变量->新建系统变量->变量名(JAVA_HOME),值(jdk安装路径,bin的上一级)->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定
  3. 常用的Windows命令行操作有哪些?
    cd:切换路径、md:创建文件夹、rd:删除文件夹、del:删除文件等
  4. 创建如下类,使得运行可以产生如下输出:
    题目4
    新建java文件:ChairMan.java
public class ChairMan{
	 public static void main(String[] args){
	 	System.out.println("姓名:主席");
	 	System.out.println();
	 	System.out.println("性别:男");
	 	System.out.println("家庭住址:北京");
	 }
}
  1. 编译和运行上述代码的指令
  • 先切换到文件所在目录

  • 编译:编译是发生的错误一般为语法错误
    javac ChairMan.java
    出现错误:ChairMan.java:3: 错误: 编码GBK的不可映射字符
    尚硅谷Java入门视频教程第二章——Java基本语法_第1张图片
    问题解决:编译时增加编码选项
    javac -encoding utf-8 ChairMan.java

  • 运行:运行时出错一般是运行时问题
    java ChairMan
    编译运行

Java语言概述

  • 基础知识:

    1. 软件:即一系列按照特定顺序组织的计算机数据和指令的集合。分为:系统软件和应用软件。
      系统软件:windows、mac os、linux、android、ios…
      应用软件:word、ppt…
      人机交互方式:图形化界面 vs 命令行方式
      应用程序 = 算法 + 数据结构
    2. 常用DOS命令:cd:切换路径、md:创建文件夹、rd:删除文件夹、del:删除文件等
    3. 计算机语言的发展迭代史
      第一代:机器语言
      第二代:汇编语言
      第三代:高级语言-面向过程与面向对象
    4. Java语言版本迭代(重要时间节点)
      1996年,发布JDK 1.0
      1999年,Java分成J2SE、J2EE和J2ME,JSP/Servlet技术诞生
      2004年,发布里程碑式版本:JDK 1.5,为突出此版本的重要性,更名为JDK 5.0
      2014年,发布JDK 8.0,是继JDK 5.0以来变化最大的版本
    5. Java语言应用领域:
      Java Web开发:后台开发
      大数据开发
      Android应用程序开发:客户端开发
    6. Java语言特点
      面向对象:两个基本概念(类、对象),三大特性(封装、继承、多态)
      健壮性:①去除了c语言中的指针,② 自动垃圾回收机制(仍然会出现内存溢出、内存泄露)
      跨平台性:Write once , Run Anywhere——JVM
  • 开发环境搭建

    1. JDK,JRE和JVM的关系是什么?
      尚硅谷Java入门视频教程第二章——Java基本语法_第2张图片
      JDK = JRE + 开发工具集(例如Javac编译工具等)
      JRE = JVM + Java SE标准类库
    2. JDK下载、安装
      下载:官网
      安装:注意问题:安装软件的路径中不能包含中文、空格
    3. 为什么要配置path环境变量?如何配置?
      配置path环境变量原因:为了在各个路径下都可以调用java相关指令
      配置方法:计算机->属性->高级系统设置->环境变量->新建系统变量->变量名(JAVA_HOME),值(jdk安装路径,bin的上一级)->确定->点击Path变量的值->新建->%JAVA_HOME%\bin->确定->确定->确定
  • 第一个Java程序
    步骤:
    将 Java 代码编写到扩展名为 .java 的文件中;
    通过 javac 命令对该 java 文件进行编译javac ChairMan.java
    通过 java 命令对生成的 class 文件进行运行java ChairMan
    尚硅谷Java入门视频教程第二章——Java基本语法_第3张图片

  • 注释与API文档

    1. 注释:Comment
      分类:
      单行注释://
      多行注释:/* */
      文档注释 (java特有):/** */
      特点:
      对于单行和多行注释,被注释的文字,不会被JVM(java虚拟机)解释执行;
      多行注释里面不允许有多行注释嵌套;
      文档注释内容可以被JDK提供的工具 javadoc 所解析,生成一套以网页文件形式体现的该程序的说明文档。
    2. Java API文档
      API (Application Programming Interface,应用程序编程接口)是 Java 提供的基本编程接口。习惯上将语言提供的类库都称为API。
      API文档:针对于类库如何使用的说明书
    3. 良好的编程风格
      尚硅谷Java入门视频教程第二章——Java基本语法_第4张图片
  • 常用Java开发工具

    1. 文本编辑工具:
      记事本、UltraEdit、 EditPlus、TextPad、 NotePad
    2. Java集成开发环境(IDE):
      JBuilder、NetBeans、Eclipse、MyEclipse、IntelliJ IDEA

第2章:Java基本语法

2.1 关键字和保留字

  • 关键字(keyword)的定义和特点
    定义:被Java语言赋予了特殊含义,用做专门用途的字符串
    特点:关键字中所有字母都为小写
    官方地址: https://docs.oracle.com/javase/tutorial/java/nutsandbolts/_keywords.html尚硅谷Java入门视频教程第二章——Java基本语法_第5张图片尚硅谷Java入门视频教程第二章——Java基本语法_第6张图片
  • Java保留字:
    现有Java版本尚未使用,但以后版本可能会作为关键字使用。自己命名标识符时要避免使用这些保留字,如goto 、const等

2.2 标识符(Identifier)

  • 标识符:
    Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
    技巧:凡是自己可以起名字的地方都叫标识符。

  • 定义合法标识符规则: 不遵守,编译失败

    1. 由26个英文字母大小写,0-9 ,_或 $ 组成
    2. 数字不可以开头
    3. 不可以使用关键字和保留字,但能包含关键字和保留字
    4. Java中严格区分大小写,长度无限制
    5. 标识符不能包含空格
  • Java中的名称命名规范:不遵守,编译可以通过,但建议遵守

    1. 包名:多单词组成时所有字母都小写:xxxyyyzzz
    2. 类名、接口名:多单词组成时,所有单词的首字母大写:XxxYyyZzz(大坨峰)
    3. 变量名、方法名:多单词组成时,第一个单词首字母小写,第二个单词开始每个单词首字母大写:xxxYyyZzz(小坨峰)
    4. 常量名:所有字母都大写。多单词时每个单词用下划线连接:XXX_YYY_ZZZ

2.3 变量

2.3.1 变量基本概念

  • 变量的概念:
    内存中的一个存储区域
    该区域的数据可以在同一类型范围内不断变化
    变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
  • 变量的作用:用于在内存中保存数据
  • 使用变量注意:
  1. Java中每个变量必须先声明,再赋值,后使用
    编译错误① :使用前未定义
class VaribleTest{
	public static void main(String[] args){
		//编译错误:使用前myNumber未定义
		System.out.println(myNumber);

		//变量的声明
		int myNumber;
		//变量的赋值
		myNumber = 1001;
		//变量的使用
		System.out.println(myNumber);
	}
}

编译错误② :使用前仅声明,未赋值

class VaribleTest{
	public static void main(String[] args){
		//变量的声明
		int myNumber;
		
		//编译错误:使用myNumber前仅声明,未赋值
		System.out.println(myNumber);
		
		//变量的赋值
		myNumber = 1001;
		//变量的使用
		System.out.println(myNumber);
	}
}
  1. 使用变量名来访问这块区域的数据
  2. 变量的作用域:其定义所在的一对{ }内
  3. 变量只有在其作用域内才有效;出作用域,变量失效。
  4. 同一个作用域内,不能定义重名的变量

2.3.2 变量分类——按数据类型

对于每一种数据都定义了明确的具体数据类型(强类型语言),在内存中分配了不同大小的内存空间。
尚硅谷Java入门视频教程第二章——Java基本语法_第7张图片

  • 变量按照数据类型划分:

    1. 基本数据类型:
      整型:byte \ short \ int \ long
      浮点型:float \ double
      字符型:char
      布尔型:boolean
    2. 引用数据类型:(后续补充)
      类:class
      接口:interface
      数组:array
  • 变量在类中声明的位置(后续补充)
    成员变量 vs 局部变量

1. 整数类型:byte \ short \ int \ long

尚硅谷Java入门视频教程第二章——Java基本语法_第8张图片
1. Java各整数类型有固定的表数范围和字段长度,不受具体OS的影响,以保证java程序的可移植性。
2. java的整型常量默认为 int 型,声明long型常量须后加‘l’或‘L’(输出结果中不带L/l)
3. java程序中变量通常声明为int型,除非不足以表示较大的数,才使用long

class VaribleTest1{
	public static void main(String[] args){
		//1. 整型:byte(1字节 = 8bit) \ short(2字节) \ int(4字节) \ long(8字节)
		//① byte范围:-128 ~ 127
		byte b1 = 12;
		byte b2 = -128;
		//b2 = 128;//编译不通过
		System.out.println(b1);
		System.out.println(b2);

		// ② 声明long型变量,必须以"l"或"L"结尾
		// ③ 通常,定义整型变量时,使用int型。
		short s1 = 128;
		int i1 = 1234;
		long l1 = 3414234324L;
		System.out.println(l1);
	}
}

2. 浮点类型:float \ double

尚硅谷Java入门视频教程第二章——Java基本语法_第9张图片

  1. 与整数类型类似,Java 浮点类型也有固定的表数范围和字段长度,不受具体操作系统的影响。
    (float表示的数值范围比long还大——float有指数位)
  2. 浮点型常量有两种表示形式:
    十进制数形式:如:5.12 512.0f .512 (必须有小数点)
    科学计数法形式:如:5.12e2 512E2 100E-2
  3. float:单精度,尾数可以精确到7位有效数字。很多情况下,精度很难满足需求。
    double:双精度,精度是float的两倍。通常采用此类型。
  4. Java 的浮点型常量默认为double型,声明float型常量,须后加‘f’或‘F’。
class VaribleTest1{
	public static void main(String[] args){
    	// 2. 浮点型:float(4字节) \ double(8字节)
		// ① 浮点型,表示带小数点的数值
		// ② float表示的数值范围比long还大
		double d1 = 123.3;
		System.out.println(d1+1);
		// ③ 定义float类型变量时,变量要以“f”或“F”结尾
		//float f1 = 12.3;//编译不通过
		float f1 = 12.3F;
		System.out.println(f1);
		// ④ 通常,定义浮点型变量时,使用double型
	}
}

3. 字符类型:char

  1. char 型数据用来表示通常意义上“字符”(2字节)
  2. Java中的所有字符都使用Unicode编码,故一个字符可以存储一个字母,一个汉字,或其他书面语的一个字符。
  3. 字符型变量的三种表现形式:
    字符常量是用单引号(‘ ’)括起来的单个字符。例如:char c1 = ‘a’; char c2 = ‘中’; char c3 = ‘9’;
    Java中还允许使用转义字符来将其后的字符转变为特殊字符型常量。例如:char c3 = ‘\n’; // '\n’表示换行符
    直接使用 Unicode 值来表示字符型常量:‘\uXXXX’。其中,XXXX代表一个十六进制整数。如:\u000a 表示 \n。
  4. char类型是可以进行运算的。因为它都对应有Unicode码
class VaribleTest1{
	public static void main(String[] args){
		// 3. 字符型: char(1字符=2字节)
		// ① 定义char型变量,通常使用一对'',内部只能写一个字符
		char c1 = 'a';
		//c1 = 'AB';//编译不通过
		System.out.println(c1);

		char c2 = '1';
		char c3 = '中';
		char c4 = 'ス';
		System.out.println(c2);
		System.out.println(c3);
		System.out.println(c4);
		
		//② 表示方式:1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
		char c5 = '\n';//换行符
		c5 = '\t';//制表符
		System.out.print("hello" + c5);
		System.out.println("world");

		char c6 = '\u0043';
		System.out.println(c6);
	}
}
  1. 编码方式:字符与计算机内部的表示的对应方式
    ASCII 码 -> Unicode 编码 -> UTF-8
class ReviewTest{
	public static void main(String[] args){
		char c1 = 'a';
		char c2 = 97;//开发中非常少见,将其认为ASCII码,输出为ACSII码对应的字符
		System.out.println(c2);//a

		char c3 = 5;//ASCII码
		char c4 = '5';//字符‘5’
		int i1 = (int)c4;//将字符对应的ASCII妈转换为int型
		System.out.println(i1);//53
	}
}

4. 布尔类型:boolean

  1. boolean 类型用来判断逻辑条件,一般用于程序流程控制:
    if条件控制语句;
    while循环控制语句;
    do-while循环控制语句;
    for循环控制语句;
  2. boolean类型数据只允许取值true和false,无null
    不可以使用0或非 0 的整数替代false和true,这点和C语言不同。
    Java虚拟机中没有任何供boolean值专用的字节码指令,Java语言表达所操作的boolean值,在编译之后都使用java虚拟机中的int数据类型来代替:true用1表示,false用0表示。———《java虚拟机规范 8版》
class VaribleTest1{
	public static void main(String[] args){
		//4.布尔型:boolean
		//① 只能取两个值之一:true 、 false
		//② 常常在条件判断、循环结构中使用
		boolean bb1 = true;
		System.out.println(bb1);

		boolean isMarried = true;
		if(isMarried){
			System.out.println("你就不能参加\"单身\"party了!\\n 很遗憾");
			//System.out.println("你就不能参加"单身"party了!\\n 很遗憾");//编译错误
		}else{
			System.out.println("你可以多谈谈女朋友!");
		}

	}
}

引用数据类型——String

  1. String不是基本数据类型,属于引用数据类型,翻译为:字符串
  2. 使用方式与基本数据类型一致。声明String类型变量时,使用一对"",例如:String str = “abcd”
  3. String可以和8种基本数据类型变量做运算,且运算只能是连接运算:+,运算的结果仍然是String类型
/*
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);

		String s2 = "a";
		String s3 = "";

		//char c = '';//编译不通过

		//***********************
		int number = 1001;
		String numberStr = "学号:";
		String info = numberStr + number;// +:连接运算
		boolean b1 = true;
		String info1 = info + b1;// +:连接运算
		System.out.println(info1);

		//***********************
		//练习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' + '*');//93  //char+char+char ASCII码加法
		System.out.println('*' + "\t" + '*');//*	*  //char+str+char 连接运算
		System.out.println('*' + '\t' + "*");//51*  //char+char+str ASCII码加法+连接运算
		System.out.println('*' + ('\t' + "*"));//*	*  //char+(str+char)=char+str 连接运算


		//***********************

		//String str1 = 123;//编译不通过
		String str1 = 123 + "";
		System.out.println(str1);//"123"
		
		//int num1 = str1;//编译不通过
		//int num1 = (int)str1;//"123"//编译不通过

		int num1 = Integer.parseInt(str1);
		System.out.println(num1);//123
	}
}

2.3.3 基本数据类型之间的运算规则

前提:这里讨论只是7种基本数据类型变量间的运算。不包含boolean类型的。
boolean类型不能与其它数据类型运算。

  1. 自动类型提升:
    结论:当容量小的数据类型的变量与容量大的数据类型的变量做运算时,结果自动提升为容量大的数据类型。
    byte 、char 、short --> int --> long --> float --> double
    特别的:byte,short,char之间不会相互转换,他们三者在计算时首先转换为int类型。当byte、char、short三种类型的变量做运算时,结果为int型
    自动类型提升
    说明:此时的容量大小指的是,表示数的范围的大和小。比如:float容量要大于long的容量
class VariableTest2 {
	public static void main(String[] args) {
		
		byte b1 = 2;
		int i1 = 129;
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		long l1 = b1 + i1;
		System.out.println(i2);

		float f = b1 + i1;
		System.out.println(f);

		short s1 = 123;
		double d1 = s1;
		System.out.println(d1);//123.0

		//***************特别地*********************
		char c1 = 'a';//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);

		short s2 = 10;
		//char c2  = c1 + s2;//编译不通过

		byte b2 = 10;
		//char c3 = c1 + b2;//编译不通过

		//short s3 = b2 + s2;//编译不通过

		//short s4 = b1 + b2;//编译不通过
		//****************************************

	}
}
  1. 强制类型转换:自动类型提升运算的逆运算。
    需要使用强转符:()
    注意点:强制类型转换,可能导致精度损失。
class VariableTest3 {
	public static void main(String[] args) {
		
		double d1 = 12.9;
		//精度损失举例1
		int i1 = (int)d1;//截断操作
		System.out.println(i1);//12
		
		//没有精度损失
		long l1 = 123L;
		short s2 = (short)l1;
		
		//精度损失举例2
		int i2 = 128;
		byte b = (byte)i2;
		System.out.println(b);//-128

	}
}
  1. 变量运算规则两个特殊情况:
    ① 使用long声明变量有时候不加L也可以通过编译,是因为java会默认将其转换为int类型,但当不加L且超过int的表示范围时,仍然会报错。
    float类型必须加F,不加一定会报错。
    ② 整型常量,默认类型为int型;浮点型常量,默认类型为double型。因此在定义变量接受运算结果时,应采用int/double。
class VariableTest4 {
	public static void main(String[] args) {
		//1.编码情况1:
		long l = 123213;
		System.out.println(l);
		//编译失败:过大的整数
		//long l1 = 21332423235234123;
		long l1 = 21332423235234123L;


		//****************
		//编译失败
		//float f1 = 12.3;
		float f1 = (float)12.3;

		
		//2.编码情况2:
		//整型常量,默认类型为int型
		//浮点型常量,默认类型为double型
		byte b = 12;
		//byte b1 = b + 1;//编译失败

		//float f1 = b + 12.3;//编译失败
	}
}

2.3.4 变量之进制

  • 所有数字在计算机底层都以二进制形式存在。  对于整数,有四种表示方式:
    1. 二进制(binary):0,1 ,满2进1.以0b或0B开头。
    2. 十进制(decimal):0-9 ,满10进1。
    3. 八进制(octal):0-7 ,满8进1. 以数字0开头表示。
    4. 十六进制(hex):0-9及A-F,满16进1. 以0x或0X开头表示。此处的A-F不区分大小写。如:0x21AF +1= 0X21B0
  • 二进制:
    1. Java整数常量默认是int类型,当用二进制定义整数时,其第32位是符号位;当是long类型时,二进制默认占64位,第64位是符号位

    2. 二进制的整数有如下三种形式:
      原码:直接将一个数值换成二进制数。最高位是符号位
      负数的反码:是对原码按位取反,只是最高位(符号位)确定为1。
      负数的补码:其反码加1。

    3. 计算机以二进制补码的形式保存所有的整数。
      正数的原码、反码、补码都相同
      负数的补码是其反码+1
      尚硅谷Java入门视频教程第二章——Java基本语法_第10张图片
      特殊补码:
      尚硅谷Java入门视频教程第二章——Java基本语法_第11张图片
      int型的128(0000 0000 0000 0000 0000 0000 1000 0000)强制转换为byte型时会变成-128(1000 0000)。
      由于int型最高位符号位(0000 0000 0000 0000 0000 0000 1000 000)丢失,只保留了数值位,但转换为byte型后,保留的数值位的最高位变成了符号位(1000 0000),因此变为了-128。

    4. 为什么要使用原码、反码、补码表示形式呢?
      计算机辨别“符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了。
      减法运算

2.4 运算符

运算符是一种特殊的符号,用以表示数据的运算、赋值和比较等。 包括算术运算符、赋值运算符、比较运算符(关系运算符)、逻辑运算符、位运算符、三元运算符。

2.4.1 算术运算符

尚硅谷Java入门视频教程第二章——Java基本语法_第12张图片
注意点:

  1. (前)++ :先自增1,后运算
    (后)++ :先运算,后自增1
  2. (前)-- :先自减1,后运算
    (后)-- :先运算,后自减1
  3. 连接符: + :只能使用在String与其他数据类型之间使用。
/*
运算符之一:算术运算符
+ - + - * / % (前)++ (后)++ (前)-- (后)-- +
*/
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
		double result7 = (double)(num1 / num2);//2.0
		System.out.println(result4);
		System.out.println(result5);
		System.out.println(result6);
		System.out.println(result7);



		//%:取余运算
		//结果的符号与被模数的符号相同
		//开发中,尝使用%来判断能否被除尽的情况
		int m1 = 12;
		int n1 = 5;
		System.out.println("m1 % n1 = " + m1 % n1);//2

		int m2 = -12;
		int n2 = 5;
		System.out.println("m2 % n2 = " + m2 % n2);//-2

		int m3 = 12;
		int n3 = -5;
		System.out.println("m3 % n3 = " + m3 % n3);//2

		int m4 = -12;
		int n4 = -5;
		System.out.println("m4 % n4 = " + m4 % n4);//-2


		//(前)++ :先自增1,后运算
		//(后)++ :先运算,后自增1
		int a1 = 10;
		int b1 = ++a1;
		System.out.println("a1 = " + a1 + ",b1 = " + b1);//11, 11
		
		int a2 = 10;
		int b2 = a2++;
		System.out.println("a2 = " + a2 + ",b2 = " + b2);//11, 10
		
		int a3 = 10;
		++a3;//a3++;
		int b3 = a3;

		//注意点:
		short s1 = 10;
		//s1 = s1 + 1;//编译失败
		//s1 = (short)(s1 + 1);//正确的
		s1++;//自增1不会改变本身变量的数据类型
		System.out.println(s1);

		//问题:
		byte bb1 =127;
		bb1++;
		System.out.println("bb1 = " + bb1);//-128


		//(前)-- :先自减1,后运算
		//(后)-- :先运算,后自减1
		int a4 = 10;
		int b4 = --a4;
		System.out.println("a4 = " + a4 + ", b4 = " + b4);//9, 9

		int a5 = 10;
		int b5 = a5--;
		System.out.println("a5 = " + a5 + ", b5 = " + b5);//9, 10
	}
}

练习题:
随意给出一个三位数的整数,打印显示它的个位数,十位数,百位数的值。

class AriExer {
	public static void main(String[] args) {

		int num = 187;

		int bai = num / 100;
		int shi = num % 100 / 10;//int shi = num / 10 % 10;
		int ge = num % 10;

		System.out.println("百位为:" + bai);
		System.out.println("十位为:" + shi);
		System.out.println("个位为:" + ge);
	}
}

2.4.2 赋值运算符

  • 符号:=
    当“=”两侧数据类型不一致时,可以使用自动类型转换或使用强制类型转换原则进行处理。
    支持连续赋值。

  • 扩展赋值运算符: +=, -=, *=, /=, %=

  • 运算的结果不改变数据类型

  • 开发中,如果希望变量实现+2的操作,有几种方法?(前提:int num = 10;)
    方式一:num = num + 2;
    方式二:num += 2; (推荐)

  • 开发中,如果希望变量实现+1的操作,有几种方法?(前提:int num = 10;)
    方式一:num = num + 1;
    方式二:num += 1;
    方式三:num++; (推荐)

/*
运算符之二:赋值运算符
=  +=  -=  *=  /=  %= 
*/
class SetValueTest {
	public static void main(String[] args) {
		//赋值符号:=
		int i1 = 10;
		int j1 = 10;

		int i2,j2;
		//连续赋值
		i2 = j2 = 10;

		int i3 = 10,j3 = 20;
		
		//*********************
		int num1 = 10;
		num1 += 2;//num1 = num1 + 2;
		System.out.println(num1);//12

		int num2 = 12;
		num2 %= 5;//num2 = num2 % 5;
		System.out.println(num2);//2 

		short s1 = 10;
		//s1 = s1 + 2;//编译失败
		s1 += 2;//结论:不会改变变量本身的数据类型
		System.out.println(s1);

		//开发中,如果希望变量实现+2的操作,有几种方法?(前提:int num = 10;)
		//方式一:num = num + 2;
		//方式二:num += 2; (推荐)
		
		//开发中,如果希望变量实现+1的操作,有几种方法?(前提:int num = 10;)
		//方式一:num = num + 1;
		//方式二:num += 1; 
		//方式三:num++; (推荐)
		
		//练习1
		int i = 1;
		i *= 0.1;
		System.out.println(i);//0
		i++;
		System.out.println(i);//1

		//练习2
		int m = 2;
		int n = 3;
		n *= m++; //n = n * m++;//先运算,后+1	
		System.out.println("m=" + m);//3
		System.out.println("n=" + n);//6
		
		//练习3
		int n1 = 10;
		n1 += (n1++) + (++n1);//n1 = n1 + (n1++) + (++n1);
		System.out.println(n1);//32

	}
}

4.2.3 比较运算符

尚硅谷Java入门视频教程第二章——Java基本语法_第13张图片

  • 比较运算符的结果是boolean类型
  • 区分 == 和 =
  • > \ < \ >= \ <= :只能使用在数值类型的数据之间
  • ==:不仅可以使用在数值类型的数据之间,还可以使用在其他引用类型变量之间。
/*
运算符之三:比较运算符
==  !=  >  <  >= <=  instanceof

结论:
1.比较运算符的结果是boolean类型
2.区分 ==  和  = 
*/
class CompareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;

		System.out.println(i == j);//false
		System.out.println(i = j);//20

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true
	}
}

4.2.4 逻辑运算符

尚硅谷Java入门视频教程第二章——Java基本语法_第14张图片

  • 逻辑运算符操作的都是boolean类型的变量,得到的结果也是boolean类型。
  • 区分& 与 &&
    相同点1:& 与 && 的运算结果相同
    相同点2:当符号左边是true时,二者都会执行符号右边的运算
    不同点:当符号左边是false时,&继续执行符号右边的运算。&&不再执行符号右边的运算。
    开发中,推荐使用&&
  • 区分:| 与 ||
    相同点1:| 与 || 的运算结果相同
    相同点2:当符号左边是false时,二者都会执行符号右边的运算
    不同点3:当符号左边是true时,|继续执行符号右边的运算,而||不再执行符号右边的运算
    开发中,推荐使用||
/*
运算符之四:逻辑运算符

&  && |  || ! ^

说明:
1.逻辑运算符操作的都是boolean类型的变量
*/
class LogicTest {
	public static void main(String[] args) {
		
		//区分& 与 &&
		//相同点1:& 与  && 的运算结果相同
		//相同点2:当符号左边是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);

		// 区分:| 与 || 
		//相同点1:| 与  || 的运算结果相同
		//相同点2:当符号左边是false时,二者都会执行符号右边的运算
		//不同点3:当符号左边是true时,|继续执行符号右边的运算,而||不再执行符号右边的运算
		//开发中,推荐使用||
		boolean b3 = false;
		b3 = true;
		int num3 = 10;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num3 = " + num3);


		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("我现在在北京");
		}else{
			System.out.println("我现在在南京");
		}
		System.out.println("num4 = " + num4);
	}
}

练习1:
尚硅谷Java入门视频教程第二章——Java基本语法_第15张图片
练习2:

class Test {
	public static void main (String [] args) {
		boolean x = true;
		boolean y = false;
		short z = 42;
		//if(y == true)
		if((z++ == 42)&&(y = true))z++;//((先比较,后增1 -> T,z:43)&&(赋值语句:与= true -> T)) - > T -> z:44
		if((x = false) || (++z == 45)) z++;//((F)||(先增1,再比较 -> z:45, T)) -> T -> z: 46
		System.out.println("z = " + z);//46
	}
}

2.4.5 位运算符

尚硅谷Java入门视频教程第二章——Java基本语法_第16张图片

  1. 位运算符操作的都是整型的数据
  2. << :在一定范围内,每向左移1位,相当于 * 2
    >> :在一定范围内,每向右移1位,相当于 / 2
    尚硅谷Java入门视频教程第二章——Java基本语法_第17张图片
    面试题:最高效方式的计算2 * 8 ?
    2 << 3 或 8 << 1
  3. 没有<<<
  4. 细节问题:尚硅谷Java入门视频教程第二章——Java基本语法_第18张图片
/*
运算符之五:位运算符 (了解)

结论:
1. 位运算符操作的都是整型的数据
2. << :在一定范围内,每向左移1位,相当于 * 2
   >> :在一定范围内,每向右移1位,相当于 / 2


面试题:最高效方式的计算2 * 8 ?  2 << 3  或 8 << 1
*/
class BitTest {
	public static void main(String[] args) {
		int i = 21;
		i = -21;
		System.out.println("i << 2 :" + (i << 2));
		System.out.println("i << 3 :" + (i << 3));
		System.out.println("i << 27 :" + (i << 27));

		int m = 12;
		int n = 5;
		System.out.println("m & n :" + (m & n));
		System.out.println("m | n :" + (m | n));
		System.out.println("m ^ n :" + (m ^ n));

		//练习:交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);

		//方式一:定义临时变量的方式
		//推荐的方式
		int temp = num1; 
		num1 = num2;
		num2 = temp;

		//方式二:好处:不用定义临时变量  
		//弊端:① 相加操作可能超出存储范围 ② 有局限性:只能适用于数值类型
		//num1 = num1 + num2;
		//num2 = num1 - num2;
		//num1 = num1 - num2;

		//方式三:使用位运算符
		//有局限性:只能适用于数值类型
		//num1 = num1 ^ num2;
		//num2 = num1 ^ num2;
		//num1 = num1 ^ num2;

		System.out.println("num1 = " + num1 + ",num2 = " + num2);

	}
}
  • 例题1:如何求一个0-255范围内的整数的十六进制值。如:60的十六进制形式为3C
/*
如何求一个0-255范围内的整数的十六进制值。如:60的十六进制形式为3C
*/

class BitTest2{
	public static void main(String[] args) {
		int i1 = 60;
		int i2 = i1 & 15;//15的二进制只有最低四位为1111,因此按位相与后只保留i1的最低四位的值
		String j = (i2>9)?(char)(i2-10+'A')+"":i2+"";//+""是将结果变成字符串,防止字符之间进行运算
		int temp = i1 >>> 4;
		i2 = temp & 15;
		String k = (i2>9)?(char)(i2-10+'A')+"":i2+"";
		System.out.println(k+""+j);
	}
}

2.4.6 三元运算符

  • 格式: (条件表达式)? 表达式1 : 表达式2
    尚硅谷Java入门视频教程第二章——Java基本语法_第19张图片
    1. 说明
      ① 条件表达式的结果为boolean类型
      ② 根据条件表达式真或假,决定执行表达式1,还是表达式2.
      如果表达式为true,则执行表达式1。
      如果表达式为false,则执行表达式2。
      ③ 表达式1 和表达式2要求是一致的(可以用同种类型接收 )。
      ④ 三元运算符可以嵌套使用
    2. 凡是可以使用三元运算符的地方,都可以改写为if-else
      反之,不成立。
    3. 三元运算符与if-else的联系与区别:
      1)三元运算符可简化if-else语句
      2)三元运算符要求必须返回一个结果。
      3)if后的代码块可有多个语句
    4. 如果程序既可以使用三元运算符,又可以使用if-else结构,那么优先选择三元运算符。原因:简洁、执行效率高。
/*
运算符之六:三元运算符
1.结构:(条件表达式)? 表达式1 : 表达式2
2. 说明
① 条件表达式的结果为boolean类型
② 根据条件表达式真或假,决定执行表达式1,还是表达式2.
  如果表达式为true,则执行表达式1。
  如果表达式为false,则执行表达式2。
③ 表达式1 和表达式2要求是一致的。
④ 三元运算符可以嵌套使用

3. 
凡是可以使用三元运算符的地方,都可以改写为if-else
反之,不成立。

4. 如果程序既可以使用三元运算符,又可以使用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);

		double num = (m > n)? 2 : 1.0;

		//(m > n)? 2 : "n大";//编译错误

		//**************************
		n = 12;
		String maxStr = (m > n)? "m大" : ((m == n)? "m和n相等" : "n大");
		System.out.println(maxStr);

		//*****************************
		//获取三个数的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;
		
		int max1 = (n1 > n2)? n1 : n2;
		int max2 = (max1 > n3)? max1 : n3;
		System.out.println("三个数中的最大值为:" + max2);

		//不建议
		//int max3 = (((n1 > n2)? n1 : n2) > n3)? ((n1 > n2)? n1 : n2) : n3;
		//System.out.println("三个数中的最大值为:" + max3);

		//该写成if-else:
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

运算符优先级

  • 运算符有不同的优先级,所谓优先级就是表达式运算中的运算顺序。如下表,上一行运算符总优先于下一行。
    尚硅谷Java入门视频教程第二章——Java基本语法_第20张图片
  • 只有单目运算符、三元运算符、赋值运算符是从右向左运算的。

2.5 程序流程控制

  • 流程控制语句是用来控制程序中各语句执行顺序的语句,可以把语句组合成能完成一定功能的小逻辑模块。
  • 其流程控制方式采用结构化程序设计中规定的三种基本流程结构,即:
    1. 顺序结构
      程序从上到下逐行地执行,中间没有任何判断和跳转。
    2. 分支结构
      根据条件,选择性地执行某段代码。
      有if…else和switch-case两种分支语句。
    3. 循环结构
      根据循环条件,重复性的执行某段代码。
      有while、do…while、for三种循环语句。
      注:JDK1.5提供了foreach循环,方便的遍历集合、数组元素。

2.5.1 顺序结构

Java中定义成员变量时采用合法的前向引用。如:
尚硅谷Java入门视频教程第二章——Java基本语法_第21张图片

2.5.2 分支语句1:if-else结构

  • if-else的三种情况:
    1. 一分支执行,一分支不执行
      尚硅谷Java入门视频教程第二章——Java基本语法_第22张图片

    2. 两分支二选一
      尚硅谷Java入门视频教程第二章——Java基本语法_第23张图片

    3. 多选一
      尚硅谷Java入门视频教程第二章——Java基本语法_第24张图片

/*
分支结构中的if-else(条件判断结构)


一、三种结构

第一种:
if(条件表达式){
   执行表达式
}

第二种:二选一
if(条件表达式){
   执行表达式1
}else{
   执行表达式2
}

第三种:n选一
if(条件表达式){
   执行表达式1
}else if(条件表达式){
   执行表达式2
}else if(条件表达式){
   执行表达式3
}
...
else{
   执行表达式n
}
*/
class IfTest {
   public static void main(String[] args) {
   	
   	//举例1
   	int heartBeats = 79;
   	if(heartBeats < 60 || heartBeats > 100){
   		System.out.println("需要做进一步检查");
   	}

   	System.out.println("检查结束");
   	
   	//举例2
   	int age = 23;
   	if(age < 18){
   		System.out.println("你还未成年");
   	}else{
   		System.out.println("你已经成年了");
   	}

   	//举例3
   	if(age < 0){
   		System.out.println("您输入的数据非法");
   	}else if(age < 18){
   		System.out.println("青少年时期");
   	}else if(age < 35){
   		System.out.println("青壮年时期");
   	}else if(age < 60){
   		System.out.println("中年时期");
   	}else if(age < 120){
   		System.out.println("老年时期");
   	}else{
   		System.out.println("你是要成仙啊~~");
   	}
   }
}
  • Scanner的使用:
    如何从键盘获取不同类型的变量:需要使用Scanner类
    具体实现步骤:
    1. 导包:import java.util.Scanner;
    2. Scanner的实例化:Scanner scan = new Scanner(System.in);
    3. 调用Scanner类的相关方法(next() / nextXxx()),来获取指定类型的变量
//1.导包:import java.util.Scanner;
import java.util.Scanner;

class ScannerTest{
	
	public static void main(String[] args){

		//2.Scanner的实例化
		Scanner scan = new Scanner(System.in);

		//3.调用Scanner类的相关方法
		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.nextDouble();
		System.out.println(weight);

		System.out.println("你是否相中我了呢?(true/false)");
		boolean isLove = scan.nextBoolean();
		System.out.println(isLove);

		//对于char型的获取,Scanner没有提供相关的方法。只能获取一个字符串
		System.out.println("请输入你的性别:(男/女)");
		String gender = scan.next();//"男"
		char genderChar = gender.charAt(0);//获取索引为0位置上的字符
		System.out.println(genderChar);
	}
}

注意:
需要根据相应的方法,来输入指定类型的值。如果输入的数据类型与要求的类型不匹配时,会报异常:InputMisMatchException,导致程序终止。
尚硅谷Java入门视频教程第二章——Java基本语法_第25张图片

  • If-else练习题
    1.岳小鹏参加Java考试,他和父亲岳不群达成承诺,如果:
    成绩为100分时,奖励一辆BMW;
    成绩为(80,99]时,奖励一台iphone xs max;
    当成绩为[60,80]时,奖励一个 iPad;
    其它时,什么奖励也没有。
    请从键盘输入岳小鹏的期末成绩,并加以判断。
/*
说明:
1. else 结构是可选的。
2. 针对于条件表达式:
   > 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面,无所谓。
   > 如果多个条件表达式之间有交集的关系,需要根据实际情况,考虑清楚应该将哪个结构声明在上面。
   > 如果多个条件表达式之间有包含的关系,通常情况下,需要将范围小的声明在范围大的上面。否则,范围小的就没机会执行了。
*/
import java.util.Scanner;
class IfTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		
		System.out.println("请输入岳小鹏期末成绩:(0-100)");
		int score = scan.nextInt();

		if(score == 100){
			System.out.println("奖励一辆BMW");
		}else if(score > 80 &&  score <= 99){
			System.out.println("奖励一台iphone xs max");
		}else if(score >= 60 && score <= 80){
			System.out.println("奖励一个 iPad");
		}else{
			System.out.println("什么奖励也没有");
		}
	}
}
  1. 编写程序:由键盘输入三个整数分别存入变量num1、num2、num3,对它们进行排序(使用 if-else if-else),并且从小到大输出。
/*
说明:
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时,对应的一对{}可以省略的。但是,不建议大家省略。
*/
import java.util.Scanner;
class IfTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入第一个整数:");
		int num1 = scan.nextInt();
		System.out.println("请输入第二个整数:");
		int num2 = scan.nextInt();
		System.out.println("请输入第三个整数:");
		int num3 = scan.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 + "<" + num1);
		}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. 练习:判断输出结果
    ①输出atguigu
    尚硅谷Java入门视频教程第二章——Java基本语法_第26张图片
    ②输出 x is 4
    尚硅谷Java入门视频教程第二章——Java基本语法_第27张图片
    ③ b ==false:b
    b=false:c
    尚硅谷Java入门视频教程第二章——Java基本语法_第28张图片

java随机数生成

如何获取一个随机数:10-99
(int)(Math.random() * 90 + 10)//[0.0, 1.0) -> [0.0, 90.0) -> [10.0,100.0) -> [10, 99]
公式[a, b]:
(int)(Math.random * (b - a + 1) + a)

2.5.3 分支语句2:switch-case结构

  • 格式尚硅谷Java入门视频教程第二章——Java基本语法_第29张图片
  • 说明:
    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关键字是可选的。
    6. default:相当于if-else结构中的else.
      default结构是可选的,而且位置是灵活的。
class SwitchCaseTest {
	public static void main(String[] args) {
		
		int number = 5;
		switch(number){
		
		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");
			break;
		case 2:
			System.out.println("two");
			break;
		case 3:
			System.out.println("three");
			break;
		default:
			System.out.println("other");
			//break;
		}


		String season = "summer";
		switch (season) {
		case "spring":
			System.out.println("春暖花开");
			break;
		case "summer":
			System.out.println("夏日炎炎");
			break;
		case "autumn":
			System.out.println("秋高气爽");
			break;
		case "winter":
			System.out.println("冬雪皑皑");
			break;
		default:
			System.out.println("季节输入有误");
			break;
		}



		//**************如下的两种情况都编译不通过*********************
		//情况一: switch表达式不可以为boolean类型
		/*
		boolean isHandsome = true;
		switch(isHandsome){
		
		case true:
			System.out.println("我好帅啊~~~");
			break;
		case false:
			System.out.println("我好丑啊~~~");
			break;
		default:
			System.out.println("输入有误~~~");
		}
		*/
		//情况二:case常量不可以为表达式
		/*
		int age = 10;
		switch(age){
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
		}
		*/
	}
}
  • 例题
  1. 对学生成绩大于60分的,输出“合格”。低于60分的,输出“不合格”。
    说明:如果switch-case结构中的多个case的执行语句相同,则可以考虑进行合并。
class SwitchCaseTest1 {
	public static void main(String[] args) {
		
		/*
		int score = 78;
		switch(score){
		case 0:

		case 1:

		case 2:

			...
		case 100:
		
		}
		*/

		/*
		int score = 78;
		if(score >= 60){
		
		}else{
		
		}
		*/
		
		int score = 78;
		switch(score / 10){
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			System.out.println("不及格");
			break;
		case 6:
		case 7:
		case 8:
		case 9:
		case 10:
			System.out.println("及格");
			break;

		}
		
		//更优的解决方案:
		switch(score / 60){
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("及格");
			break;
		}
	
	}
}

  1. 编写程序:从键盘上输入2019年的“month”和“day”,要求通过程序输出输入的日期为2019年的第几天。
/*
2  15:  31 + 15
5 7: 31 + 28 + 31 + 30 + 7 
....

说明:break在switch-case中是可选的
*/
import java.util.Scanner;
class SwitchCaseTest2{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入2019年的month:");
		int month = scan.nextInt();
		System.out.println("请输入2019年的day:");
		int day = scan.nextInt();

		//定义一个变量来存储总天数
		int sumDays = 0;

		switch(month){
		case 12:
			sumDays = 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			sumDays += 28;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}
		System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}
  1. 从键盘分别输入年、月、日,判断这一天是当年的第几天
    注:判断一年是否是闰年的标准:
    1)可以被4整除,但不可被100整除

    2)可以被400整除
/*
说明:
1. 凡是可以使用switch-case的结构,都可以转换为if-else。反之,不成立。
2. 我们写分支结构时,当发现既可以使用switch-case,(同时,switch中表达式的取值情况不太多),又可以使用if-else时,我们优先选择使用switch-case。原因:switch-case执行效率稍高。
*/
import java.util.Scanner;
class SwitchCaseExer {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入year:");
		int year = scan.nextInt();
		System.out.println("请输入month:");
		int month = scan.nextInt();
		System.out.println("请输入day:");
		int day = scan.nextInt();


		//定义一个变量来保存总天数
		int sumDays = 0;

		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			//sumDays += 28;
			//判断year是否是闰年
			if((year % 4 == 0 && year % 100 != 0 ) || year % 400 == 0){
				sumDays += 29;
			}else{
				sumDays += 28;
			}

		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}

		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

2.5.4 循环结构1:for循环

  • 循环结构:在某些条件满足的情况下,反复执行特定代码的功能
  • 循环语句分类:
    for 循环
    while 循环
    do-while 循环
  • 循环语句的四个组成部分:
    1. 初始化部分(init_statement)
    2. 循环条件部分(test_exp) :boolean类型
    3. 循环体部分(body_statement)
    4. 迭代部分(alter_statement)
      尚硅谷Java入门视频教程第二章——Java基本语法_第30张图片
  • for循环
  • 语法格式
for (①初始化部分; ②循环条件部分; ④迭代部分){ 
	③循环体部分;
 } 
  • 执行过程:
    ①-②-③-④-②-③-④-②-③-④-…-②
    尚硅谷Java入门视频教程第二章——Java基本语法_第31张图片
  • 说明:
    ②循环条件部分为boolean类型表达式,当值为false时,退出循环
    ①初始化部分可以声明多个变量,但必须是同一个类型,用逗号分隔
    ④可以有多个变量更新,用逗号分隔
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、for循环的结构

for(①;②;④){
	③
}

执行过程:① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

*/
class ForTest {
	public static void main(String[] args) {

		/*
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		System.out.println("Hello World!");
		*/

		for(int i = 1;i <= 5;i++){//i:1,2,3,4,5
			System.out.println("Hello World!");
		}
		//i:在for循环内有效。出了for循环就失效了。
		//System.out.println(i);
		
		//练习:
		int num = 1;
		for(System.out.print('a');num <= 3;System.out.print('c'),num++){
			System.out.print('b');
		}
		//输出结果:abcbcbc

		System.out.println();

		//例题:遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
		//int sum;//编译错误,变量在使用之前必须先赋值
		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("总和为:" + sum);
		System.out.println("个数为:" + count);

	}
}

  • 例题
  1. 编写程序从1循环到150,并在每行打印一个值,另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”
class ForTest1 {
	public static void main(String[] args) {
		
		for(int i = 1;i <= 150;i++){
			
			System.out.print(i + "	");
			if(i % 3 == 0){
				System.out.print("foo" + "	");
			}
			if(i % 5 == 0){
				System.out.print("biz" + "	");
			}
			if(i % 7 == 0){
				System.out.print("baz" + "	");
			}
			System.out.println();
		}

	}
}
  1. 题目:输入两个正整数m和n,求其最大公约数和最小公倍数。
    比如:12和20的最大公约数是4,最小公倍数是60。
/*
说明:break关键字的使用:一旦在循环中执行到break,就跳出循环
*/
import java.util.Scanner;
class ForTest{
	public static void main(String[] args){
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入第一个正整数:");
		int m = scan.nextInt();
		System.out.println("请输入第二个正整数:");
		int n = scan.nextInt();
		
		//获取最大公约数(一定在1-较小数之间)
		int min = (m <= n)? m : n;
		for(int i = min;i >= 1;i--){
			if(m % i == 0 && n % i == 0){
				System.out.println("最大公约数为:" + i);
				break;
			}
		}

		//获取最小公倍数(一定在较大数-m*n之间)
		int max = (m >= n)? m : n;
		for(int i = max;i <= m*n;i++){
			if(i % m == 0 && i % n == 0){
				System.out.println("最小公倍数为:" + i);
				break;
			}
		}
	}
}

2.5.5 循环结构2:while循环

  • 语法格式
①初始化部分
while(②循环条件部分){ 
③循环体部分; ④迭代部分; 
} 
  • 执行过程:
    ①-②-③-④-②-③-④-②-③-④-…-②
  • 说明:
    1. 注意不要忘记声明④迭代部分。否则,循环将不能结束,变成死循环。
    2. for循环和while循环可以相互转换
      区别:for循环和while循环的初始化条件部分的作用范围不同。
/*
说明:
1.写while循环千万小心不要丢了迭代条件。一旦丢了,就可能导致死循环!
2.我们写程序,要避免出现死循环。
3.for循环和while循环是可以相互转换的! 
  区别:for循环和while循环的初始化条件部分的作用范围不同。

算法:有限性。
*/
class  WhileTest{
	public static void main(String[] args) {
		
		//遍历100以内的所有偶数
		int i = 1;
		while(i <= 100){
			
			if(i % 2 == 0){
				System.out.println(i);
			}
			
			i++;
		}
		//出了while循环以后,仍可以调用。
		System.out.println(i);//101

	}
}

2.5.6 循环结构3:do-while循环

  • 语法格式
①初始化部分;
do{
	③循环体部分
	④迭代部分
}while(②循环条件部分);
  • 执行过程:
    ①-③-④-②-③-④-②-③-④-…②
  • 说明:
    do-while循环至少执行一次循环体。
/*
do-while循环的使用

一、循环结构的4个要素
① 初始化条件
② 循环条件  --->是boolean类型
③ 循环体
④ 迭代条件

二、do-while循环结构:

①
do{
	③;
	④;

}while(②);

执行过程:① - ③ - ④ - ② - ③ - ④ - ... - ②

说明:
1.do-while循环至少会执行一次循环体!
2.开发中,使用for和while更多一些。较少使用do-while

*/
class DoWhileTest {
	public static void main(String[] args) {
		
		//遍历100以内的偶数,并计算所有偶数的和及偶数的个数
		int num = 1;
		int sum = 0;//记录总和
		int count = 0;//记录个数
		do{
			
			if(num % 2 == 0){
				System.out.println(num);
				sum += num;
				count++;
			}

			num++;

		}while(num <= 100);
		

		System.out.println("总和为:" + sum);
		System.out.println("个数为:" + count);

		//*************体会do-while至少执行一次循环体***************
		int number1 = 10;
		while(number1 > 10){
			System.out.println("hello:while");
			number1--;
		}

		int number2 = 10;
		do{
			System.out.println("hello:do-while");
			number2--;
		}while(number2 > 10);

	}
}
  • 循环结构综合例题
    从键盘读入个数不确定的整数,并判断读入的正数和负数的个数,输入为0时结束程序。
/*
说明:
1. 不在循环条件部分限制次数的结构:for(;;) 或 while(true)
2. 结束循环有几种方式?
     方式一:循环条件部分返回false
	 方式二:在循环体中,执行break
*/

import java.util.Scanner;

class ForWhileTest {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		int positiveNumber = 0;//记录正数的个数
		int negativeNumber = 0;//记录负数的个数

		for(;;){//while(true){
			
			int number = scan.nextInt();

			//判断number的正负情况
			if(number > 0){
				positiveNumber++;
			}else if(number < 0){
				negativeNumber++;
			}else{
				//一旦执行break,跳出循环
				break;
			}

		}

		System.out.println("输入的正数个数为:" + positiveNumber);
		System.out.println("输入的负数个数为:" + negativeNumber);
	}
}

2.5.7 嵌套循环(多重循环)

  • 将一个循环放在另一个循环体内,就形成了嵌套循环。其中,for ,while ,do…while均可以作为外层循环或内层循环。
  • 实质上,嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时,才会完全跳出内层循环,才可结束外层的当次循环,开始下一次的循环。
  • 假设外层循环次数为m次,内层为n次,则内层循环体实际上需要执行m*n次。
    外层循环控制行数,内层循环控制列数。
  • 例题
  1. 打印如下的图形:菱形1
    * 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    *
class ForForTest{
	public static void main(String[] args){
		for(int i = 1; i <= 5; i++){
			for(int j = 1; j <= 5-i; j++){
				System.out.print(" ");
			}
			for(int k = 1; k <= i; k++){
				System.out.print("* ");
			}
			System.out.println();
		}
		for(int i = 1; i <= 4; i++){
			for(int j = 1; j <= i; j++){
				System.out.print(" ");
			}
			for(int k = 1; k <= 5 - i; k++){
				System.out.print("* ");
			}
			System.out.println();
		}
	}
}
  1. 九九乘法表
/*
嵌套循环的应用1:

九九乘法表
1 * 1 = 1
2 * 1 = 2  2 * 2 = 4
。。。
9 * 1 = 9 。。。 9 * 9 = 81
*/
class NineNineTable {
	public static void main(String[] args) {
		for(int i = 1;i <= 9;i++){
			for(int j = 1;j <= i;j++){
				System.out.print(i + " * " + j + " = " + i*j + "	");
			}
			System.out.println();
		}

	}
}
  1. 输出100以内所有的质数
/*
100以内的所有质数的输出。
质数:素数,只能被1和它本身整除的自然数。-->从2开始,到这个数-1结束为止,都不能被这个数本身整除。

最小的质数是:2
*/
class PrimeNumber{
	public static void main(String[] args){
		int flag;//设置标志位,判断是否为质数
		int count = 0;
		for(int i = 2;i <= 100;i++){
			flag = 0;
			for(int j = 2;j < i;j++){
				if(i % j == 0){
					flag = 1;//若能被其他数整除,则不是质数,改变标志位
					break;//主要出现能被其他数整除的情况,就不是质数,不用继续判断
				}
			}
			if(flag == 0){
				System.out.println(i);
				count++;
			}
		}
		System.out.println("100以内的所有质数共有" + count +"个。");
	}
}

优化:内部循环只需要比较到根号i即可(<=Math.sqrt(i))

/*
100000以内的所有质数的输出。实现方式一
质数:素数,只能被1和它本身整除的自然数。-->从2开始,到这个数-1结束为止,都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumber1 {
	public static void main(String[] args) {
		
		boolean isFlag = true;//标识i是否被j除尽,一旦除尽,修改其值
		int count = 0;//记录质数的个数

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			
			//优化二:对本身是质数的自然数是有效的。
			//for(int j = 2;j < i;j++){
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				
				if(i % j == 0){ //i被j除尽
					isFlag = false;
					break;//优化一:只对本身非质数的自然数是有效的。
				}
				
			}
			//
			if(isFlag == true){
				//System.out.println(i);
				count++;
			}
			//重置isFlag
			isFlag = true;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为:" + count);
		System.out.println("所花费的时间为:" + (end - start));//17110 - 优化一:break:1546 - 优化二:13

	}
}

2.5.8 特殊关键字的使用:break、continue

  • break 语句
    break语句用于终止某个语句块的执行
{ ……
	break;
……
} 
  • continue 语句

    1. continue只能使用在循环结构中
    2. continue语句用于跳过其所在循环语句块的一次执行,继续下一次循环
    3. continue语句出现在多层嵌套的循环语句体中时,可以通过标签指明要跳过的是哪一层循环
  • break/continue语句出现在多层嵌套的语句块中时,可以通过标签指明要终止的是哪一层语句块

label1: { ……
label2: 	{ ……
label3: 		{ ……
					break label2;//continue label 2;
					……
				}
			}
		 }
  • break和continue关键字的使用异同
使用范围 循环中使用的作用(不同点) 相同点
break switch-case \ 循环结构中 结束当前循环 关键字后面不能声明执行语句
continue 循环结构中 结束当次循环 关键字后面不能声明执行语句
class BreakContinueTest {
	public static void main(String[] args) {

		for(int i = 1;i <= 10;i++){
		
			if(i % 4 == 0){
				break;//123
				//continue;//123567910
				//System.out.println("今晚迪丽热巴要约我!!!");//编译错误
			}
			System.out.print(i);
		}

		System.out.println("\n");
		//******************************
		
		label:for(int i = 1;i <= 4;i++){
		
			for(int j = 1;j <= 10;j++){
				
				if(j % 4 == 0){
					//break;//默认跳出包裹此关键字最近的一层循环。
					//continue;

					//break label;//结束指定标识的一层循环结构//123
					continue label;//结束指定标识的一层循环结构当次循环//123123123
				}
				
				System.out.print(j);
			}
			
			System.out.println();
		}
	}
}
  • 求质数的另一种解法(用continue)

/*
100000以内的所有质数的输出。实现方式二
质数:素数,只能被1和它本身整除的自然数。-->从2开始,到这个数-1结束为止,都不能被这个数本身整除。

对PrimeNumberTest.java文件中质数输出问题的优化
*/
class PrimeNumberTest2 {
	public static void main(String[] args) {
		
		int count = 0;//记录质数的个数
		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long start = System.currentTimeMillis();

		label:for(int i = 2;i <= 100000;i++){//遍历100000以内的自然数
			for(int j = 2;j <= Math.sqrt(i);j++){//j:被i去除
				if(i % j == 0){ //i被j除尽
					continue label;
				}		
			}
			//能执行到此步骤的,都是质数
			count++;
		
		}

		//获取当前时间距离1970-01-01 00:00:00 的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为:" + count);
		System.out.println("所花费的时间为:" + (end - start));
	}
}

项目一:家庭收支记账软件

主函数:

class FamilyAccount{
	public static void main(String[] args){
		boolean isFlag = true;
		String details = "收支\t账户金额\t收支金额\t说 明\n";
		int balance = 1000;//记录当前账户总金额
		while(isFlag){
			System.out.println("-----------------家庭收支软件-----------------");
			System.out.println("                 1 收支明细");
			System.out.println("                 2 登记收入");
			System.out.println("                 3 登记支出");
			System.out.println("                 4 退    出");
			System.out.println();
			System.out.print("            请选择(1-4):");

			char selection = Utility.readMenuSelection();
			switch(selection){
			case '1':
				//System.out.println("1 收支明细");
				System.out.println("-----------------当前收支明细记录-----------------");
				System.out.println(details);
				System.out.println("--------------------------------------------------\n");
				break;

			case '2':
				//System.out.println("2 登记收入");
				//读取收入信息
				System.out.print("本次收入金额:");
				int income = Utility.readNumber();
				System.out.print("本次收入说明:");
				String incomeInfo = Utility.readString();

				//更新账户信息
				balance += income;
				details += "收入\t" + balance + "\t\t" + income + "\t\t" + incomeInfo + "\n";

				System.out.println("---------------------登记完成----------------------\n");
				break;

			case '3':
				//System.out.println("3 登记支出");
				//读取支出信息
				System.out.print("本次支出金额:");
				int expendture = Utility.readNumber();
				System.out.print("本次支出说明:");
				String expendtureInfo = Utility.readString();

				if(expendture > balance){
					System.out.println("支出超过账户总金额,支出失败!");
				}else{
					//更新账户信息
					balance -= expendture;
					details += "支出\t" + balance + "\t\t" + expendture + "\t\t" + expendtureInfo + "\n";
				}

				System.out.println("---------------------登记完成----------------------\n");
				break;

			case '4':
				//System.out.println("4 退    出");
				System.out.print("确认是否退出(Y/N):");
				char isExit = Utility.readConfirmSelection();
				if(isExit == 'Y'){
					isFlag = false;
				}
				break;
			}

		}
	}
}

工具类:

import java.util.Scanner;
/**
Utility工具类:
将不同的功能封装为方法,就是可以直接通过调用方法使用它的功能,而无需考虑具体的功能实现细节。
*/
public class Utility {
    private static Scanner scanner = new Scanner(System.in);
    /**
	用于界面菜单的选择。该方法读取键盘,如果用户键入’1’-’4’中的任意字符,则方法返回。返回值为用户键入字符。
	*/
	public static char readMenuSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1);
            c = str.charAt(0);
            if (c != '1' && c != '2' && c != '3' && c != '4') {
                System.out.print("选择错误,请重新输入:");
            } else break;
        }
        return c;
    }
	/**
	用于收入和支出金额的输入。该方法从键盘读取一个不超过4位长度的整数,并将其作为方法的返回值。
	*/
    public static int readNumber() {
        int n;
        for (; ; ) {
            String str = readKeyBoard(4);
            try {
                n = Integer.parseInt(str);
                break;
            } catch (NumberFormatException e) {
                System.out.print("数字输入错误,请重新输入:");
            }
        }
        return n;
    }
	/**
	用于收入和支出说明的输入。该方法从键盘读取一个不超过8位长度的字符串,并将其作为方法的返回值。
	*/
    public static String readString() {
        String str = readKeyBoard(8);
        return str;
    }
	
	/**
	用于确认选择的输入。该方法从键盘读取‘Y’或’N’,并将其作为方法的返回值。
	*/
    public static char readConfirmSelection() {
        char c;
        for (; ; ) {
            String str = readKeyBoard(1).toUpperCase();
            c = str.charAt(0);
            if (c == 'Y' || c == 'N') {
                break;
            } else {
                System.out.print("选择错误,请重新输入:");
            }
        }
        return c;
    }
	
	
    private static String readKeyBoard(int limit) {
        String line = "";

        while (scanner.hasNext()) {
            line = scanner.nextLine();
            if (line.length() < 1 || line.length() > limit) {
                System.out.print("输入长度(不大于" + limit + ")错误,请重新输入:");
                continue;
            }
            break;
        }

        return line;
    }
}

你可能感兴趣的:(#,Java基础,java)