亚美体育app下载中心 立博老虎机游戏-亚美体育

立博老虎机游戏 来源:网络 2024-03-07 09:27:02
JAVA入门 打开CMD
  • Win+R
  • 输入cmd.
  • 按下回车键
  • 常见CMD命令
  • 亚美体育在线官方入口

    说明:盘符切换

    举例:E:回车,表示切换到E盘

  • dir

    说明:查看当前路径下的内容

  • 亚美体育app下载中心

    说明:进入单级目录

    举例:cd itheima

  • cd…

    说明:回退到上一级目录

  • 亚美体育注册网站

    说明:进入多级目录

    举例:cd itheima\JavaSE

  • cd\

    说明:回退到盘符目录

  • cls

    说明:清屏

  • exit

    说明:退出命令提示符窗口

  • 配置环境变量

    为什么配置环境变量?

    我们想要在任意的目录下都可以打开指定的软件。就可以把软件的路径配置到环境变量中。

    打开我的电脑-属性-高级系统设置-高级-环境变量-系统变量path-编辑-新建-把软件的完整路径粘贴进去-上移-确定。

    Java基础学习 基础语法 jdk

    注意:针对不同操作系统,下载对应的安装包。

    安装:傻瓜式安装,下一步即可

    安装路径中不要包含中文和空格。

    所有的开发工具最好安装目录统一。

    bin:该路径下存放了各种工具命令。其中比较重要的有javac和java。

    conf:该路径下存放了相关配置文件。

    include:该路径下存放了一些平台特定的头文件。

    jmods:该路径下存放了各种模块。

    legal:该路径下存放了各模块的授权文档。

    lib:该路径下存放了工具的一些补充JAR包。

    Java程序初体验 编写步骤 用记事本写程序
    								
    									public
    									class
    									HelloWorld
    									{
    									public
    									static
    									void
    									main
    									(
    									String
    									[
    									]args)
    									{
    									System
    									.out.
    									println
    									(
    									"HelloWorld"
    									)
    									;
    									}
    									}
    								
    							
    1. 编译文件

      如何理解编译?相当于翻译文件

    1. 运行程序

      ​ CMD中程序运行步骤:

      1. 切换盘符:要先找到我们刚刚书写的代码
      2. 编译:javac是JDK提供的编译工具,我们可以通过这个工具,把当前路径下的HelloWorld.java文件编译成class文件。
      3. 运行:java也是JDK提供的一个工具。作用就是用来运行代码的。运行当前路径下的HelloWorld.class这个文件。在运行的时候是不加后
      4. 案例常见问题

        BUG的解决

      5. 具备识别BUG的能力 ———多看!
      6. 具备分析BUG的能力 ———多思考,多查阅资料 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
      7. 具备解决BUG的能力 ———多尝试,多总结

        常见问题

      8. 中英文符号问题
      9. 单词拼写问题
      10. 环境变量

        配置环境变量安全方式:

        点击新建-变量名:JAVA_HOME,变量值:把路径粘贴进去,把bin给删掉。-确定-找到Path-新建-输入%JAVA_HOME%\bin-确定就可以了

        步骤:

      11. 先配置JAVA_HOME.(路径不带bin)(E:develop\jdk)
      12. 再配置Path(%JAVA_HOME%\bin)
      13. 额外小拓展

        部分win10的电脑有一个小bug.

        当你重启后,配置的环境变量会失效.

        解决方案:

      14. JAVA_HOME还是照样配置
      15. 在path当中,就不要引用JAVA_HOME了.
      16. 直接写完整路径.比如:E:develop\jdk\bin

        Java 学习 Java能做什么?

        Java的三大分类

        JavaSE:java语言的(标准版),用于桌面应用的开发,是其他两个版本的基础.—-桌面应用开发.

        学习java的目的:

        为今后要从是的Java EE开发 ,打基础.

        JavaME:Java语言的(小型版),用于嵌入式电子设备或者小型移动设备.

        JavaEE:Java语言的(企业版),用于Web方向的网站开发.在这个领域,是当之无愧的NO.1.网站开发:浏览器+服务器

        桌面应用开发

        ​ 各种税务软件,IDEA,Clion,Pycharm

        企业级应用开发

        ​ 微服务,springcloud

        移动应用开发

        ​ 鸿蒙,Android,医疗设备

        科学计算

        matlab

        大数据开发

        ​ Hadoop

        游戏开发

        Java为什么这么火

        主要从四个方面表现

        ​ 用户量:使用人群

        ​ 适用面:作用范围

        ​ 与时俱进:更新速度

        ​ 自身特点:面向对象/安全性/多线程/跨平台/简单易用/开源

        ​ Write Once Run Anywhere一次编译,到处运行

        高级语言的编译运行方式

        编程/编译/运行

        编程:Java程序员写的.java代码,c程序员写的.c代码,python程序员写的.py代码

        编译:机器只认识0011的机器语言,把.java.c.py的代码做转化让机器认识的过程

        运行:让机器执行编译后的指令

        语言类型

        编译型:

        解释性:

        混合型:半编译,半解释

        JRE和JDK

        JVM(Java Virtual Machine):Java虚拟机,整整运行Java程序的地方

        JRE(Java Runtime Environment):Java运行环境

        ​ JVM/核心类库/运行工具

        JDK(Java Development Kit):Java开发工具包

        ​ JVM虚拟机:Java程序运行的地方

        ​ 核心类库:Java已经写好的东西,我们可以直接用

        ​ 开发工具:javac/java/jdb/jhat…

        三者的包含关系

        ​ JDK包含了JRE

        ​ JRE包含了JVM

        Java基础语法 注释

        单行注释 格式://注释信息

        多行注释 格式:/注释信息* System .out. println ( "HelloWorld" ) ; } }

        注释的使用细节:

      17. 注释内容不会参与编译与运行,仅仅是对代码的解释说明
      18. 不管是单行注释还是多行注释,在书写的时候都不要嵌套
      19. 关键字

        关键字:被Java赋予了特定涵义的英文单词

        特点:

        关键字的字母全部小写

        class:用于(创建/定义)一个类;类是Java最基本的组成单元

        字面量

        告诉程序员:数据在程序中的书写格式

        字面量类型 说明 举例 整数类型 不带小数点的数字 666,-88 小数类型 带小数点的数字 13.14,-5.21 字符串类型 用双引号括起来的内容 “HelloWorld”,“张代伟” 字符类型 用单引号括起来的内容 ‘A’,‘O’,’我’ 布尔类型 布尔值,表示真假 只有两个值:true,false 空类型 一个特殊的值,空值 值是:null
        											
        												public
        												class
        												ValueDemo
        												{
        												public
        												static
        												void
        												main
        												(
        												String
        												[
        												]args)
        												{
        												//整数
        												System
        												.out.
        												println
        												(
        												666
        												)
        												;
        												System
        												.out.
        												println
        												(
        												-
        												777
        												)
        												;
        												//小数
        												System
        												.out.
        												println
        												(
        												1.93
        												)
        												;
        												System
        												.out.
        												println
        												(
        												-
        												3.71
        												)
        												;
        												//字符串
        												System
        												.out.
        												println
        												(
        												"刘顺国"
        												)
        												;
        												System
        												.out.
        												println
        												(
        												"尼古拉斯阿淮"
        												)
        												;
        												//字符
        												System
        												.out.
        												println
        												(
        												'A'
        												)
        												;
        												System
        												.out.
        												println
        												(
        												'B'
        												)
        												;
        												//布尔
        												System
        												.out.
        												println
        												(
        												true
        												)
        												;
        												System
        												.out.
        												println
        												(
        												false
        												)
        												;
        												//空
        												//细节:null不能直接打印的.
        												//如果我们要打印null,那么只能用字符串的形式进行打印
        												System
        												.out.
        												println
        												(
        												null
        												)
        												;
        												}
        												}
        											
        										

        特殊字符字面量:

        \t 制表符

        在打印的时候,把前面字符串的长度补齐到8,或者8的整数倍.最少补1个空格,最多补8个空格.

        变量 定义

        变量:在程序执行的过程中,其值有可能发生改变的量(数据)

        变量的使用场景:

        ​ 当某个数据经常发生改变时,我们也可以用变量存储.当数据变化时,只要修改变量里面记录的值即可.

        变量的定义格式:

        ​ 数据类型 变量名 = 数据值;

        											
        												public
        												class
        												VariableDemo
        												{
        												public
        												static
        												void
        												main
        												(
        												String
        												[
        												]args)
        												{
        												//定义变量
        												//数据类型 变量名 = 数据值;
        												//数据类型:限定了变量能存储数据的类型
        												//int(整数)  double(小数)
        												//变量名:就是存储空间的名字
        												//作用:方便以后调用
        												//数据值:真正存在变量中的数
        												//等号:赋值. 把右边的数据赋值给左边的变量
        												//===================================
        												int
        												a
        												=
        												10
        												;
        												System
        												.out.
        												println
        												(a)
        												;
        												//10
        												}
        												}
        											
        										
        使用方式

        注意事项:

      20. 只能存一个值
      21. 变量名不允许重复定义
      22. 一条语句可以定义多个变量
      23. 变量在使用之前一定要进行赋值
      24. 变量的作用域范围
      25. 											
        												public
        												class
        												VariableDemo
        												{
        												public
        												static
        												void
        												main
        												(
        												String
        												[
        												]args)
        												{
        												//1.基本用法
        												//定义变量,再进行输出
        												//===================================
        												int
        												a
        												=
        												10
        												;
        												System
        												.out.
        												println
        												(a)
        												;
        												//10
        												System
        												.out.
        												println
        												(a)
        												;
        												//10
        												System
        												.out.
        												println
        												(a)
        												;
        												//10
        												//2.变量参与计算
        												int
        												b
        												=
        												20
        												;
        												int
        												c
        												=
        												30
        												;
        												System
        												.out.
        												println
        												(b+c)
        												;
        												//修改变量记录的值
        												a
        												=
        												50
        												;
        												System
        												.out.
        												println
        												(a)
        												;
        												//50
        												//注意事项
        												//在一条语句中,可以定义多个变量
        												int
        												d
        												=
        												100
        												,e
        												=
        												200
        												,f
        												=
        												300
        												;
        												System
        												.out.
        												println
        												(d)
        												;
        												System
        												.out.
        												println
        												(e)
        												;
        												System
        												.out.
        												println
        												(f)
        												;
        												//变量在使用之前必须要赋值
        												//int g;
        												//g = 50;
        												//建议:以后在定义变量的时候,请直接赋值.
        												System
        												.out.
        												println
        												(g)
        												;
        												}
        												}
        											
        										

        变量的练习
        											
        												package
        												classVariableTest
        												{
        												//主入口
        												public
        												static
        												void
        												main
        												(
        												String
        												[
        												]args)
        												{
        												//一开始没有乘客
        												int
        												count
        												=
        												0
        												;
        												//第一站:上去一位乘客
        												//在原有基础上 + 1
        												count
        												=
        												count+
        												1
        												;
        												//第二站:上去两位乘客.下来一位乘客
        												count
        												=
        												count+
        												2
        												-
        												1
        												;
        												//第三站:上来两位乘客,下来一位乘客
        												count=
        												count+
        												2
        												-
        												1
        												;
        												//第四站:下来一位乘客
        												count=count-
        												1
        												;
        												//第五站:上去一位乘客
        												count=
        												count+
        												1
        												;
        												//请问:到了终点站,车上一共几位乘客.
        												System
        												.out.
        												println
        												(count)
        												;
        												}
        												}
        											
        										
        计算机的存储规则

        三类数据

        1. Text文本数据:数字/字母/汉字

          进制:在计算机中,任意数据都是以二进制的形式来存储的

          不同进制在代码中的表现形式:

          1. 二进制:由0和1组成,代码中以0b开头.
          2. 十进制:由0-9组成,前面不加任何前缀.
          3. 八进制:由0-7组成,代码中以0开头.
          4. 十六进制:由0-9还有a-f组成,代码中以0x开头.
          5. 进制之间的转换 任意进制转换为十进制 公式:系数*基数的权次幂 相加 ​ 系数:就是每一位上的数字 ​ 基数:当前进制数 ​ 权:从右向左,依次为0 1 2 3 4 5 ……

            十进制转其他进制

            ​ 除基取余法

            ​ 不断的除以基数(几进制,基数就是几)得到余数,直到商为0,再将余数倒着拼接起来即可.

            1. 1920*1080

              1. 1998*1080
              2. 2048*1080
              3. 2048*858
              4. 4K屏分辨率大致分为:

                																	
                																		1.  ==3840*2160==  		2.  3996*2160              		3.  4096*2160             		4.  4096*1716
                																	
                																

                ​ 像素

                ​ 黑白图:1是白,2是黑

                ​ 灰度图:0是纯黑,255是纯白

                ​ 三原色

                ​ 彩色图:三原色:红黄蓝也称美学三原色.计算机中采用光学三原色:红绿蓝(RGB),写成十进制(0-255)或十六进制(0-FFFF).

              5. Sound声音数据

              6. 数据类型

                数据类型的分类

              7. 基本数据类型

                注意事项:

                long类型变量:需要加入L标识(大小写都可以)

                float类型变量:需要加入F标识(大小写都可以)

                																		
                																			public
                																			class
                																			VariableTest
                																			{
                																			public
                																			static
                																			void
                																			main
                																			(
                																			String
                																			[
                																			]args)
                																			{
                																			//定义变量记录姓名
                																			String
                																			name
                																			=
                																			"张代伟"
                																			;
                																			//定义变量记录年龄
                																			int
                																			age
                																			=
                																			18
                																			;
                																			//定义变量记录性别
                																			char
                																			gender
                																			=
                																			'男'
                																			;
                																			//定义变量记录身高
                																			double
                																			height
                																			=
                																			180.1
                																			;
                																			//定义变量记录是否单身
                																			//true 单身 false 不是单身
                																			boolean
                																			flag
                																			=
                																			true
                																			;
                																			//输出变量的值
                																			System
                																			.out.
                																			println
                																			(name)
                																			;
                																			Systrm
                																			.out.
                																			println
                																			(age)
                																			;
                																			System
                																			.out.
                																			println
                																			(gender)
                																			;
                																			System
                																			.out.
                																			println
                																			(height)
                																			;
                																			System
                																			.out.
                																			println
                																			(flag)
                																			;
                																			}
                																			}
                																		
                																	
                																		
                																			public
                																			class
                																			VariableTest
                																			{
                																			public
                																			static
                																			void
                																			main
                																			(
                																			String
                																			[
                																			]args)
                																			{
                																			//定义变量记录电影的名字
                																			String
                																			name
                																			=
                																			"送初恋回家"
                																			;
                																			//定义变量记录主演的名字
                																			String
                																			tostar
                																			=
                																			"刘鑫 张雨提 高媛"
                																			;
                																			//定义变量记录电影的年份
                																			int
                																			year
                																			=
                																			2020
                																			;
                																			//定义变量记录电影的评分
                																			double
                																			grade
                																			=
                																			9.0
                																			;
                																			//输出所有变量的值
                																			System
                																			.out.
                																			println
                																			(name)
                																			;
                																			System
                																			.out.
                																			println
                																			(tostar)
                																			;
                																			System
                																			.out.
                																			println
                																			(year)
                																			;
                																			System
                																			.out.
                																			printlan
                																			(grade)
                																			;
                																			}
                																		
                																	
                																		
                																			public
                																			class
                																			VariableTest
                																			{
                																			public
                																			static
                																			void
                																			main
                																			(
                																			String
                																			[
                																			]args)
                																			{
                																			//定义变量记录手机的价格
                																			double
                																			price
                																			=
                																			5299.0
                																			;
                																			//定义变量记录手机的品牌
                																			String
                																			name
                																			=
                																			"华为"
                																			;
                																			//输出结果
                																			System
                																			.out.
                																			println
                																			(name)
                																			;
                																			System
                																			.out.
                																			println
                																			(price)
                																			;
                																			}
                																		
                																	
              8. 引用数据类型

              9. 标识符

                标识符:就是给类,方法,变量等起的名字.

                标识符命名规则—硬性要求

              10. 由数字、字母、下划线(_)和美元符($)组成
              11. 不能以数字开头
              12. 不能是关键字
              13. 区分大小写
              14. 标识符的命名规则—软性建议

                命名要做到:见名知意

                小驼峰命名法:适合变量和方法 大驼峰命名法:适合类名 规范1:标识符是一个单词的时候,全都小写. 规范1:标识符是一个单词的时候,首字母大写. 范例1:name 范例1:Student 规范2:标识符由多个单词组成的时候,第一个单词首字母小写,其他单词首字母大写. 规范2:标识符由多个单词组成的时候,每个单词的首字母大写. 范例2:firstName 范例2:GoodStudent 键盘录入

                为什么要有键盘录入?

                键盘录入介绍

                ​ Java帮我们写好一个类叫Scanner,这个类的功能就可以接收键盘输入的数字等数据.

                使用步骤:

              15. 导包——Scanner这个类在哪

                import java.util.Scanner;导包的动作必须出现在类定义的上边.

              16. 创建对象——表示我要开始用Scanner这个类了

                Scanner sc = new Scanner(System.in)

                上面这个格式里面,只有sc是变量名,可以改变,其他的都不允许变.

              17. 接受数据——真正开始干活了

                int i = sc.nextInt();左面这个格式里面,只有i是变量名,可以变,其他的都不允许变.

              18. 																	
                																		//导包,找到Scanner这个类在哪
                																		//书写要注意:要写在类定义的上面
                																		import
                																		java.util.
                																		
                																		Scanner
                																		;
                																		public
                																		class
                																		ScannerDemo
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//2.创建对象,表示我现在准备要用Scanner这个类
                																		Scanner
                																		scanner
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入整数:"
                																		)
                																		;
                																		//3.接收数据
                																		int
                																		i
                																		=
                																		scanner.
                																		nextInt
                																		(
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		)
                																		;
                																		}
                																		}
                																	
                																

                练习:键盘输入数字求和

                需求:键盘录入两个整数,求出他们的和并打印出来

                																	
                																		//导包
                																		import
                																		java.util.
                																		
                																		Scanner
                																		;
                																		public
                																		class
                																		ScannerTest
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//2.创建对象
                																		Scanner
                																		scanner
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入整数:"
                																		)
                																		;
                																		//3.接收数据
                																		int
                																		num1
                																		=
                																		scanner.
                																		nextInt
                																		(
                																		)
                																		;
                																		//再次接收第二个数据
                																		int
                																		num2
                																		=
                																		scanner.
                																		nextInt
                																		(
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(num1+num2)
                																		;
                																		}
                																		}
                																	
                																
                IDEA IDEA概述

                全称IntelliJ IDEA,是用于Java语言开发的集成环境,它是业界公认的目前用于Java程序开发最好用的工具.

                集成环境:把代码编写,编译,执行,调试等多种功能综合到一起的开发工具.

                IDEA下载和安装
              19. 安装:傻瓜式安装,建议修改安装路径.
              20. IDEA中的第一个代码

                IDEA项目结构介绍:

              21. 项目(project)
              22. 模块(module)
              23. 包(package)
              24. 类(class)
              25. 大小排列:项目-模块-包-类

                右键-open in-Exploer(在本地打开文件件)

                IDEA的项目和模块操作 项目(project)

                修改主体:(更换背景)

                File-settings-Appearance & Bahavior-Appearance-Theme(主题)

                修改字体:

                File-settings-Editor-font-选择喜欢的字体(Consolas—程序员最喜欢的字体)

                修改颜色:什么颜色都可以,但绝不能设置成红色,跟bug冲突.

                File-settings-Editor-Color Scheme-Language Defaults-comments

                键盘录入时自动导包:

                File-settings-General-Auto Import-选择Add…+Optimize…两项确定即可

                设置背景照片:

                File-settings-Appearance-UI Options-Background Image…

                IDEA中类的相关操作:

              26. 新建类

                选中包-右键点击包-new-java class

              27. 修改类名

                选中类-右键点击类-Refactor-Rename(快捷键:shift+f6)

              28. 删除类

              29. 选中类-右键点击类-delete

                IDEA中项目的相关操作

              30. 关闭项目

                File-Close Project

              31. 新建项目

                New Project-Empty Project

              32. 打开项目

              33. 修改项目

              34. 模块(module)

                IDEA中模块的相关操作

              35. 新建模块

                File-Project Stucture- Module-±New Module-java(根据需要选择需要的类型)

              36. 删除模块

              37. 修改模块

              38. 导入模块

              39. 运算符 运算符和表达式

                运算符:对字面量或者变量进行操作的符号

                表达式:

                运算符把字面量或者变量连接起来,符合Java语法的式子就可以称为表达式.

                不同运算符连接的表达式体现的是不同类型的表达式.

                算数运算符
                																	
                																		public
                																		class
                																		ArithmeticoperatoeDemo
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//+
                																		System
                																		.out.
                																		println
                																		(
                																		1
                																		+
                																		2
                																		)
                																		;
                																		//-
                																		System
                																		.out.
                																		println
                																		(
                																		5
                																		-
                																		2
                																		)
                																		;
                																		/
                																		//1.键盘录入两个整数表示衣服的时髦度
                																		Scanner
                																		sc
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入我们自己的衣服时髦度"
                																		)
                																		;
                																		int
                																		myfashion
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入相亲对象衣服的时髦度"
                																		)
                																		;
                																		int
                																		girlfashion
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		//2.把我衣服的时髦度跟女朋友的时髦度进行对比就可以了
                																		boolean
                																		result
                																		=
                																		myfashion
                																		>girlfashion;
                																		//打印结果
                																		Sysstem
                																		.out.
                																		println
                																		(result)
                																		;
                																		}
                																		}
                																	
                																
                逻辑运算符

                在数学中,一个数据x,大于5,小于15,我们可以这样来进行表示:5

                在Java中,需要把上面的式子先进行拆解,在进行合并表达.

                拆解为:x>5和x<15

                合并后:x>5&x<15

                分类:

                符号 作用 说明 & 逻辑与(且) 并且,两边都为真,结果才是真 | 逻辑或 或者,两边都为假,结果才是假 ^ 逻辑异或,用的很少 相同为false,不同为true ! 逻辑非 取反
                																	
                																		public
                																		class
                																		LogicoperatorDemo
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//1.& 并且
                																		//两边都为真,结果才是真
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		&
                																		true
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		&
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		&
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		&
                																		true
                																		)
                																		;
                																		//使用场景1:登录.用户名正确并且密码正确
                																		//2.| 或者
                																		//两边都为假,结果才是假
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		|
                																		true
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		|
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		|
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		|
                																		true
                																		)
                																		;
                																		//使用场景2:满足其中一个条件时
                																		//3.^ 异或
                																		//相同为false,不同为true
                																		//了解即可
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		^
                																		true
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		^
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		^
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		^
                																		true
                																		)
                																		;
                																		//! 逻辑非 取反
                																		//提示:
                																		//取反的感叹号不要写多次,要么不写,要么只写一次
                																		System
                																		.out.
                																		println
                																		(
                																		!
                																		false
                																		)
                																		;
                																		//true
                																		System
                																		.out.
                																		println
                																		(
                																		!
                																		true
                																		)
                																		;
                																		//false
                																		}
                																		}
                																	
                																
                短路逻辑运算符 符号 作用 说明 && 短路与 结果和&相同,但是有短路效果 || 短路或 结果和|相同,但是有短路效果
                																	
                																		public
                																		class
                																		LogicoperatorDemo
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//1.&&
                																		//运行结果跟单个&是一样的
                																		//表示两边都为真,结果才是真
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		&&
                																		true
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		&&
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		&&
                																		true
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		&&
                																		false
                																		)
                																		;
                																		//2.||
                																		//运行结果跟单个|是一样的
                																		//表示两边为假,结果才是假
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		||
                																		true
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		||
                																		false
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		false
                																		||
                																		true
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		true
                																		||
                																		false
                																		)
                																		;
                																		//3.短路逻辑运算符局有短路效果
                																		//简单理解:当左边的表达式能确定最终的结果,那么右边就不会参与运行了
                																		int
                																		a
                																		=
                																		10
                																		;
                																		int
                																		b
                																		=
                																		10
                																		;
                																		boolean
                																		result
                																		=
                																		++a<
                																		5
                																		&&
                																		++b<
                																		5
                																		;
                																		System
                																		.out.
                																		println
                																		(result)
                																		;
                																		System
                																		.out.
                																		println
                																		(a)
                																		;
                																		System
                																		.out.
                																		println
                																		(b)
                																		;
                																		}
                																	
                																

                注意事项:

              40. &or|,无论左边true orfalse,右边都要被执行
              41. &&or||,如果左边能确定整个表达式的结果,右边不执行.
              42. &&:左边为false,右边不管是真是假,整个表达式的结果一定是false.
              43. ||:左边为true,右边不管是真是假,整个表达式的结果一定是true.
              44. 这两种情况下,右边不执行,提高了效率.

                以后最常用的逻辑运算符:&&,||,!.

                练习:数字6

                数字6是一个伟大的数字,键盘录入两个整数.

                如果其中一个为6,最终结果输出true.

                如果他们的和为6的倍数.最终结果输出true.

                其他情况都是false.

                																	
                																		public
                																		class
                																		test{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		
                																		//分析
                																		//1.键盘录入两个整数
                																		//变量a  变量b
                																		//2.a==6  b==6  (a+b)%6==0
                																		//如果满足其中一个,那么就可以输出true
                																		//
                																		Scanner
                																		sc
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入一个整数"
                																		)
                																		;
                																		int
                																		num1
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入一个整数"
                																		)
                																		;
                																		int
                																		nim2
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		//可以短路逻辑运算符去连接三个判断
                																		boolean
                																		result
                																		=
                																		num1==
                																		6
                																		||num2==
                																		6
                																		||
                																		(num1+num2)
                																		%
                																		6
                																		==
                																		0
                																		;
                																		System
                																		.out.
                																		println
                																		(result)
                																		;
                																		}
                																	
                																
                三元运算符

                需求:定义一个变量记录两个整数的较大值

                作用:可以进行判断,根据判断的结果得到不同的内容

                (三元运算符/三元表达式)格式

              45. 格式:关系表达式?表达式1:表达式2;

              46. 范例:求两个数的较大值.

                a>b?a:b;

                System.out.println(a>b?a:b);

                																		
                																			public
                																			class
                																			test{
                																			public
                																			static
                																			void
                																			main
                																			(
                																			String
                																			[
                																			]args)
                																			{
                																			//需求:使用三元运算符,获取两个数的较大值
                																			//分析:
                																			//1.定义两个变量记录两个整数
                																			int
                																			number1
                																			=
                																			10
                																			;
                																			int
                																			number2
                																			=
                																			20
                																			;
                																			//2.使用三元运算符获取两个整数的最大值
                																			//格式:关系表达式?表达式1:表达式2;
                																			//整个三元运算符的结果必须要被使用
                																			number1>number2?number1:number2;
                																			System
                																			.out.
                																			println
                																			(max)
                																			;
                																			System
                																			.out.
                																			println
                																			(number1>number2?number1:number2)
                																			;
                																			}
                																		
                																	
              47. 练习1:两只老虎

                需求:动物园里有两只老虎,体重分别为通过键盘录入获得,请用程序实现判断两只老虎的体重是否相同.

                																	
                																		public
                																		class
                																		test1{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		
                																		//分析:
                																		//1.键盘录入两只老虎的体重
                																		Scanner
                																		sc
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入第一只老虎的体重"
                																		)
                																		;
                																		int
                																		weight1
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入第二只老虎的体重"
                																		)
                																		;
                																		int
                																		weight2
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		//2.比较
                																		String
                																		result
                																		=
                																		boolean
                																		weight1>weight2?相同:不同;
                																		System
                																		.out.
                																		println
                																		(result)
                																		}
                																	
                																

                练习2:三元运算符练习2

                需求:一座寺庙里住着三个和尚,已知他们的身高分别为150cm,210cm,165cm.请用程序实现获取这三个和尚的身高.

                																	
                																		public
                																		class
                																		test2{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		
                																		//1.定义三个变量记录三个和尚的身高
                																		int
                																		height1
                																		=
                																		150
                																		;
                																		int
                																		height2
                																		=
                																		210
                																		;
                																		int
                																		height3
                																		=
                																		165
                																		;
                																		//2.拿着第一个和尚和第二个和尚进行比较
                																		//再拿着结果跟第三个和尚进行比较即可
                																		int
                																		temp
                																		=
                																		height1>height2?height1:height2;
                																		int
                																		max
                																		=
                																		temp>height3?temp:height3;
                																		//ctrl+alt+L代码对齐快捷键
                																		System
                																		.out.
                																		println
                																		(max)
                																		;
                																		}
                																	
                																
                运算符优先级

                小括号()优先于所有

                原码、反码、补码 原码

                原码:十进制数据的二进制表现形式,最左边是符号位,0为正,1为负。[外链图片转存失败,源站可能有防盗链机制,建议将图片 原码的弊端:

                利用原码对正数进行计算的时候,如果是整数是完全不会有问题的。

                但是如果是负数计算,结果就出错,实际运算的结果,跟我们预期的结果是相反的。

                反码

                反码:正数的补码反码是其本身,负数的反码是符号位保持不变,其余位取反。

                反码:为了解决原码不能计算负数的问题而出现的。

                计算规则:正数的反码不变,负数的反码在原码的基础上,符号位不变,数值取反,0变1,1变0.

                反码的弊端:负数运算的时候,如果结果不跨0,是没有任何问题的,但是如果结果跨0,跟实际结果会有1的偏差。

                补码

                补码:正数的补码是其本身,负数的补码是在其反码的基础上+1.

                补码出现的目的:

                为了解决负数计算时跨0的问题而出现的。

                补码的计算规则:

                正数的补码不变,负数的补码在反码的基础上+1.

                另外补码还能多记录一个特殊的值-128,改数据在1个字节下,没有源码和反码。

                补码的注意点:

                计算机中的存储和计算都是以补码的形式进行的。

                基本数据类型

                基本类型 字节数 二进制 1个字节 0000 1010 short类型的10 2个字节 0000 0000 0000 1010 int类型的10 4个字节 0000 0000 0000 0000 0000 0000 0000 1010 long类型的10 8个字节 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1010

                其他的运算符

                运算符 含义 运算规则 & 逻辑与 0为false 1为true | 逻辑或 0为false 1为true <<左移 向左移动,低位补0,规则:移一位*2 >> 右移 向右移动,高位补0或1规则:移一位/2 >>> 无符号右移 向右移动,高位补0
                																	
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		voidmain
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		int
                																		a
                																		=
                																		200
                																		;
                																		int
                																		b
                																		=
                																		10
                																		;
                																		System
                																		.out.
                																		println
                																		(a|b)
                																		;
                																		0000
                																		0000
                																		0000
                																		0000
                																		0000
                																		0000
                																		1100
                																		1000
                																		0000
                																		0000
                																		0000
                																		0000
                																		0000
                																		0000
                																		0000
                																		1010
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		=
                																		0000
                																		0000
                																		0000
                																		0000
                																		0000
                																		0000
                																		1100
                																		1010
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		==
                																		=
                																		202
                																		}
                																		}
                																	
                																
                流程控制语句 顺序结构
                																	
                																		public
                																		class
                																		OrderDemo
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		"好好学习Java"
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"早日掌握一门技术"
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"为国家崛起而奋斗"
                																		)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"赚大钱"
                																		)
                																		;
                																		}
                																		}
                																	
                																
                分支结构 if语句 第一种格式:
                																	
                																		if
                																		(关系表达式)
                																		{
                																		if
                																		(酒量>
                																		2
                																		)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		)
                																		:
                																		}
                																		语句体;
                																		}
                																		if的注意点:
                																		1.大括号的开头可以另起一行书写,但是建议写在第一行的末尾;
                																		2.在语句体中,如果只有一句代码,大括号可以省略不写;建议:大括号不要省略.
                																		3.如果对一个布尔类型的变量进行判断,不要用==;直接把变量写在小括号中即可
                																		public
                																		class
                																		IfDemo
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//需求:键盘录入女婿的酒量,如果大于2,老丈人给出回应,反之不回应.
                																		//if格式
                																		//if(关系表达式){
                																		//语句体;
                																		//}
                																		//分析:
                																		//1.键盘录入女婿的酒量
                																		Scanner
                																		sc
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请输入女婿的酒量"
                																		)
                																		;
                																		int
                																		wine
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		//2.对酒量进行判断
                																		if
                																		(wine>
                																		2
                																		)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		"小伙子,不错呦!"
                																		)
                																		;
                																		}
                																		}
                																		}
                																	
                																
                																	
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//小红:如果你这次考试全班第一,我就做你女朋友
                																		//分析:
                																		//1.定义变量记录小明的名次
                																		int
                																		ranking
                																		=
                																		1
                																		;
                																		//2.对小明的名次进行判断
                																		if
                																		(ranking==
                																		1
                																		)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		"小红成为了小明的女朋友"
                																		)
                																		;
                																		}
                																		}
                																		}
                																	
                																

                自动驾驶

                																	
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//汽车无人驾驶会涉及到大量的判断
                																		//当汽车行驶的时候遇到了红绿灯,就会进行判断
                																		//如果红灯亮,就停止
                																		//如果黄灯亮,就减速
                																		//如果绿灯亮,就行驶
                																		//1.定义三个变量,表示灯的状态
                																		//true 亮  false 关
                																		boolean
                																		isLightGreen
                																		=
                																		false
                																		;
                																		boolean
                																		isLightYellow
                																		=
                																		false
                																		;
                																		boolean
                																		isLightRed
                																		=
                																		true
                																		;
                																		//2.判断
                																		//红灯亮,就停止
                																		//黄灯亮,就减速
                																		//绿灯亮,就行驶
                																		if
                																		(isLightGreen)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		"GoGoGo!"
                																		)
                																		;
                																		}
                																		if
                																		(isLightYellow)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		"slow!"
                																		)
                																		;
                																		}
                																		if
                																		(isLightRed)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		"stop!"
                																		)
                																		;
                																		}
                																		}
                																	
                																
                第二种格式:
                																	
                																		if
                																		(关系表达式)
                																		{
                																		语句体1
                																		;
                																		}
                																		else
                																		{
                																		语句体2
                																		;
                																		}
                																		执行流程:
                																		1.首先计算关系表达式的值
                																		2.如果关系表达式的值为true就执行语句体1
                																		3.如果关系表达式的值为false就执行语句体2
                																		4.继续执行后面的其他语句
                																	
                																

                练习:吃饭

                																	
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		
                																		//分析:
                																		//1.键盘录入小明的考试成绩
                																		Scanner
                																		sc
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请录入一个整数表示小明的成绩"
                																		)
                																		;
                																		int
                																		score
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		//对异常数据进行判断校验
                																		//0-100合理数据
                																		if
                																		(score>
                																		0
                																		&&score<=
                																		100
                																		)
                																		{
                																		//2.根据不同的考试成绩,给出不同的奖励;
                																		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
                																		(
                																		"揍一顿"
                																		)
                																		;
                																		}
                																		}
                																		else
                																		{
                																		Syetem
                																		.out.
                																		println
                																		(
                																		"成绩不合法"
                																		)
                																		;
                																		}
                																		}
                																	
                																
                																	练习:自动驾驶;
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		boolean
                																		isLightGreen
                																		=
                																		false
                																		;
                																		boolean
                																		isLightYellow
                																		=
                																		false
                																		;
                																		boolean
                																		isLightRed
                																		=
                																		true
                																		;
                																		if
                																		(isLightGreen)
                																		{
                																		Syetem
                																		.out.
                																		println
                																		(
                																		"GoGoGo!!"
                																		)
                																		;
                																		}
                																		else
                																		if
                																		(isLightYellow)
                																		{
                																		Syetem
                																		.out.
                																		println
                																		(
                																		"Slow!!!!"
                																		)
                																		;
                																		}
                																		else
                																		if
                																		(isLightRed)
                																		{
                																		Syetem
                																		.out.
                																		println
                																		(
                																		"Stop!!!!"
                																		)
                																		;
                																		}
                																		}
                																	
                																
                switch

                Switch语句格式

                																	
                																		Switch
                																		(表达式)
                																		{
                																		case1
                																		:
                																		语句体1
                																		;
                																		break
                																		;
                																		case2
                																		:
                																		语句体2
                																		;
                																		break
                																		;
                																		case3
                																		:
                																		语句体3
                																		;
                																		break
                																		;
                																		.
                																		.
                																		.
                																		.
                																		.
                																		default
                																		:
                																		语句体n+
                																		1
                																		;
                																		break
                																		;
                																		}
                																		执行流程:
                																		1.首先计算表达式的值;
                																		2.依次和case后面的值进行比较,如果有对应的值,就会执行相应的语句,在执行的过程中,遇到break就会结束;
                																		如果所有的case后面的值和表达式的值都不匹配,就会执行default里面的语句体,然后结束整个Switch语句.
                																		格式说明:
                																		1.表达式:
                																		(将要匹配的值)取值为byte
                																		/
                																		short
                																		/
                																		int
                																		/
                																		char
                																		.JDK5以后可以是枚举,JDK7以后可以是String
                																		.
                																		2.
                																		case
                																		:后面跟的是要和表达式进行比较的值(被匹配的值)
                																		;
                																		3.
                																		break
                																		:表示中断,结束的意思,用来结束Switch语句;
                																		4.
                																		default
                																		:表示所有情况都不匹配的时候,就执行该处的内容,if语句的else相似;
                																		5.
                																		case后面的值只能是字面量,不能是变量;
                																		6.
                																		case给出的值不允许重复.
                																		Switch其他知识点
                																		default的位置和省略
                																		case穿透
                																		Switch新特性
                																		Switchif第三种格式各自的使用场景
                																	
                																
                																	练习:吃面
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//兰州拉面,武汉热干面,北京炸酱面,陕西油泼面
                																		//1.定义变量记录我心里想吃的面
                																		String
                																		noodles
                																		=
                																		"兰州拉面"
                																		;
                																		//2.拿着这个面利用Switch跟四种面条匹配
                																		Switch
                																		(noodles)
                																		{
                																		case
                																		"兰州拉面"
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"吃兰州拉面"
                																		)
                																		;
                																		break
                																		;
                																		case
                																		"武汉热干面"
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"吃武汉热干面"
                																		)
                																		;
                																		break
                																		;
                																		case
                																		"北京炸酱面"
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"吃北京炸酱面"
                																		)
                																		;
                																		break
                																		;
                																		case
                																		"陕西油泼面"
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"吃陕西油泼面"
                																		)
                																		;
                																		break
                																		;
                																		default
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"吃方便面"
                																		)
                																		;
                																		break
                																		;
                																		}
                																		}
                																	
                																
                																	练习:运动计划;
                																		需求:键盘录入星期数,显示今天的减肥活动;
                																		周一:跑步;
                																		周二:游泳;
                																		周三:慢走;
                																		周四:动感单车;
                																		周五:拳击;
                																		周六:爬山;
                																		周日:好好吃一顿;
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//分析:
                																		//1.键盘录入星期数
                																		Scanner
                																		sc
                																		=
                																		new
                																		Scanner
                																		(
                																		System
                																		.in)
                																		;
                																		System
                																		.out.
                																		println
                																		(
                																		"请录入星期"
                																		)
                																		;
                																		int
                																		week
                																		=
                																		sc.
                																		nextInt
                																		(
                																		)
                																		;
                																		//2.利用Switch对星期进行匹配;
                																		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
                																		(
                																		"没有这个星期"
                																		)
                																		;
                																		break
                																		;
                																		}
                																	
                																
                																	
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//default的位置和省略;
                																		//1.位置:default不一定是写在最下面的,我们可以写在任意位置,只不过习惯会写在最下面.
                																		//2.省略:default可以省略,语法不会有问题,但是不建议省略.
                																		int
                																		number
                																		=
                																		100
                																		;
                																		switch
                																		(number)
                																		{
                																		case
                																		1
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"number的值为1"
                																		)
                																		;
                																		break
                																		;
                																		case
                																		20
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"number的值为20"
                																		)
                																		;
                																		break
                																		;
                																		case
                																		100
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"number的值为100"
                																		)
                																		;
                																		break
                																		;
                																		default
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"number的值不是1,20和100"
                																		)
                																		;
                																		break
                																		;
                																		}
                																		}
                																	
                																
                																	
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		
                																		int
                																		number
                																		=
                																		1
                																		;
                																		switch
                																		(number)
                																		{
                																		case
                																		1
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"number的值为1"
                																		)
                																		;
                																		// break;
                																		case
                																		20
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"number的值为20"
                																		)
                																		;
                																		//break;
                																		case
                																		100
                																		:
                																		System
                																		.out.
                																		println
                																		(
                																		"number的值为100"
                																		)
                																		;
                																		//break;
                																		//default:
                																		// System.out.println("number的值不是1,20和100");
                																		// break;
                																		}
                																		}
                																	
                																
                																	public class Test{     public static void main(String[]args){                  //需求:         //1 2 3                  int number = 10;         Switch(number){             case 1->System.out.println("一");             case 2->System.out.println("二");             case 3->System.out.println("三");             default->System.out.println("没有这种选项");         }     }
                																	
                																
                																	
                																	
                																
                																	public class Test{     public static void main(String[]args){                  //分析:         //1.键盘录入星期数         Scanner sc = new Scanner(System.in);         System.out.println("请录入一个整数表示星期");         int week = sc.nextInt();         //2.利用Switch语句来进行选择         Switch(week){             case 1:             case 2:             case 3:             case 4:             case 5:             System.out.println("工作日");             break;             case 6:             case 7:             System.out.println("休息日");             break;             default:             System.out.println("没有这个星期");             break;         }              Scanner sc = new Scanner(System.in);         System.out.println("请录入一个整数表示星期");         int week = sc.nextInt();         //2.利用Switch语句来进行选择         Switch(week){             case 1,2,3,4,5->System.out.println("工作日");             case 6,7->System.out.println("休息日");                        default->System.out.println("没有这个星期");         }              }
                																	
                																
                																	public class Test{     public static void main(String[]args){                           //分析:         //1.键盘录入一个整数,表示我们的选择         Scanner sc = new Scanner(System.in);         System.out.println("请输入您的选择");         int choose = sc.nextInt();         //2.根据选择执行不同的代码         switch(choose){             case 1->System.out.println("机票查询");                              case 2->System.out.println("机票预订");                              case 3->System.out.println("机票改签");                              //case 4->System.out.println("退出服务");                              default->System.out.priln("退出服务");         }     }
                																	
                																
                循环结构 什么是循环?

                ​ 重复的做某件事情

                ​ 具有明确的开始和停止标记

                循环的分类: for循环——重点
                																	格式: for(int i=1;i<=0;i++){     System.out.println("HelloWorld"); } 执行流程: 1.执行初始化语句                           2.执行条件判断语句,看其结果是true还是false     如果是false,循环结束     如果是true,执行循环体语句 3.执行条件控制语句 4.回到2继续执行条件判断语句
                																	
                																

                																	
                																		public
                																		class
                																		ForDemo
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		//1.需求:打印5次HelloWorld
                																		//分析:
                																		//i 1~5
                																		
                																		for
                																		(
                																		int
                																		i=
                																		1
                																		;i<=
                																		5
                																		;i++
                																		)
                																		{
                																		System
                																		.out.
                																		println
                																		(
                																		"HelloWorld"
                																		)
                																		;
                																		}
                																		}
                																	
                																
                																	public class Test{     public static void main(String[]args){         //需求1:打印1~5                  //分析:         //开始条件:1         //结束条件:5         for(int i=1;i<=5;i++){             //第一次循环:i=1             //第二次循环:i=2             //i:1 2 3 4 5             System.out.println(i);         }                  //需求2:打印5~1         //分析:         //开始条件:5         //结束条件:1         for(int i=5;i>.=1;i--){             System.out.println(i);         }          }
                																	
                																
                																	练习:断线重连 在实际开发中,需要重复执行的代码,会选择循环实现. 那么断线重连这个业务逻辑就需要重复执行. 假设现在公司要求,断线重连的业务逻辑最多只能写5次. 请用代码实现. 备注:断线重连的业务逻辑可以用输出语句替代. public class Test{     public static void main(String[]args){                  //分析:         //1.因为我们需要重复执行某段代码,所以需要用循环解决         //循环的次数5次         //开始条件:1         //结束条件:5         for(int i=1;i<=5;i++){             System.out.println("第"+i+"次执行断线重连的业务逻辑");         }     }
                																	
                																
                																	练习:求和 需求:在实际开发中,如果要获取一个范围中的每一个数据时,也会用到循环.
                																		比如:1
                																		~
                																		5之间的和.
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		
                																		//分析:
                																		//1.循环1~5得到里面的每一个数字
                																		//开始条件:1
                																		//结束条件:5
                																		//用来进行累加的
                																		//int sum = 0;
                																		for
                																		(
                																		int
                																		i=
                																		1
                																		;i<=
                																		5
                																		;i++
                																		)
                																		{
                																		//1.求和的变量不能定义在循环的里面,因为变量只在所属的大括号中有效.
                																		//2.如果我们把变量定义在循环的里面,那么当前变量只能在本次循环中有效.
                																		//当本次循环结束之后,变量就会从内存中消失.
                																		//第二次循环开始的时候,又会重新定义一个新的变量.
                																		//如果以后我们要写累加求和的变量,可以把变量定义在循环的外面.
                																		int
                																		sum
                																		=
                																		0
                																		;
                																		System
                																		.out.
                																		println
                																		(i)
                																		;
                																		//可以把得到的每一个数字累加到变量sum当中
                																		sum=sum+i;
                																		//sum +=i;
                																		}
                																		//当前循环结束之后,表示已经把1~5累加到变量sum当中了
                																		System
                																		.out.
                																		println
                																		(sum)
                																		;
                																		}
                																	
                																
                																	练习:求和2 需求:在实际开发中,如果要获取一个范围中的每一个数据时,会用到循环; 但是此时,大多数情况下,不会获取所有的数据,而是获取其中符合要求的数据. 此时就需要循环和其他鱼护结合使用了. 比如:求1~100之间的偶数和. public class Test{     public static void main(String[]args){         //分析:         //1.获取1~100之间的每个数         int sum = 0;         for(int i=1;i<=100;i++){             //2.累加求和(先判断,再求和)             if(i%2==0){                 sum=sun+i;             }             //打印sum             System.out.println(sum);         }     }
                																	
                																
                																	练习:统计满足条件的数字; 需求:键盘录入两个数字,表示一个范围.统计这个范围中,既能被3整除,又能被5整除的数字有多少个? public class Test{     public static void main(String[]args){          //分析:         //1.键盘录入两个数字         Scanner sc = new Scanner(System.in);         System.out.println("请输入一个数字表示范围的开始");         int start = sc.nextInt();         System.out.println("请输入一个数字表示范围的结束");         int end= sc.nextInt();         //统计变量         //简单理解,统计符合要求的数字的个数         int count =0;         //2.利用循环获取这个范围中的每一个数字         //开始条件:start         //结束条件:end         for(int i=start;i<=end;i++){             //3.对每一个数字进行判断,统计有多少可满足要求的数字             if(i%3==0&&i%5==0){                 //System.out.println(i);                 count++;             }         }         System.out.println(count);              }
                																	
                																
                																	##### while循环—-重点 #####
                																	
                																
                																	格式: 初始化语句; while(条件判断语句){     循环体语句;     条件控制语句; } 初始化语句只执行一次; 判断语句为true,循环继续; 判断语句为false,循环结束
                																	
                																

                																	public class Test{     public static void main(String[]args){         //需求:利用while循环打印1~100         //分析:         //开始条件:1         //结束条件:100         int i= 1;         while(i<=100){             System.out.println(i);             i++;         }     }
                																	
                																
                for和while的对比

                相同点:运行规则都是一样的.

                区别:

              48. for循环中,控制循环的变量,因为归属for循环的语法结构中,在for循环结束后,就不能再次被访问到了.
              49. while循环中,控制循环的变量,对于while循环来说不归属其语法结构中,在while循环结束后,该变量还可以继续使用.
              50. 																	练习:打印折纸的次数 需求:世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米),假如我有一张足够大的纸,它的厚度是0.1毫米.请问我折叠多少次,可以折成珠穆朗玛峰的高度? public class Test{     public static void main(String[]args){         //分析:折叠纸张:每一次折叠纸张的厚度都是原先的两倍         //double a = 0.1;         //a = a*2;或者a *=2;         //1.定义一个变量用来记录山峰的高度         double height = 8844430;         //2.定义一个变量用来记录纸张的初始厚度         double paper = 01.;         //3.定义一个变量用来统计次数         int count=0;         //4.循环折叠纸张,只要纸张的厚度小于山峰的高度,那么循环就继续         while(paper
                																
                																	练习:回文数; 需求:给你一个整数X; 如果x是一个回文整数,打印true,否则,则返回false. 解释:回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数 例如121是回文,而123不是 public class Test{     public static void main(String[]args){         //核心思路:把狮子倒过来跟原来的数字进行比较                  //1.定义数字         int x = 12345;         //定义一个临时变量用于记录X原来的值,用于最后进行比较         int temp =x;         //记录倒过来之后的结果;         int num = 0;         //2.利用循环从右往左获取每一位数字         while(x!=0){             //从右往左获取每一位数字             int ge = x%10;             //修改一下x记录的值             x = x/10;             //把当前获取到的数字拼接到最右边             num = num*10+ge;         }         //3.打印num         System.out.println(num);         //4.比较         System.out.println(num==temp)                  //1.定义数字;         int x =12;         //2.获取个位;         int ge = x%10;//2         //获取十位;         int shi = x/10%10;//1         //拼接         int result =ge*10+shi;         System.out.println(result);              }
                																	
                																
                																	练习:求商和余数 需求:给定两个整数,被除数和除数(都是正数,且不超过今天的范围)
                																		.
                																		将两数相除,要求不使用乘法/除法和%运算符.
                																		得到商和余数.
                																		public
                																		class
                																		Test
                																		{
                																		public
                																		static
                																		void
                																		main
                																		(
                																		String
                																		[
                																		]args)
                																		{
                																		
                																		//1.定义变量记录被除数
                																		int
                																		dividend
                																		=
                																		10
                																		;
                																		//2.定义变量用来记录除数
                																		int
                																		divisor
                																		=
                																		3
                																		;
                																		//3.定义一个变量用来统计相减了多少次
                																		int
                																		count
                																		=
                																		0
                																		;
                																		//4.循环while
                																		//在循环中,不断的用被除数-除数
                																		//只要被除数是大于除数的,那么就一直循环
                																		while
                																		(dividend>=divisor)
                																		{
                																		dividend
                																		=
                																		dividend-divisor;
                																		//只要减一次,那么统计变量就自增一次
                																		count++
                																		;
                																		}
                																		//当循环结束之后dividend变量记录的就是余数
                																		System
                																		.out.
                																		println
                																		(
                																		"余数为:"
                																		+dividend)
                																		;
                																		//当循环结束之后,count记录的值就是商
                																		System
                																		.out.
                																		println
                																		(
                																		"商为:"
                																		+count)
                																		}
                																	
                																
                																	##### do…while—以后几乎不用 #####
                																	
                																
                																	格式: 初始化语句; do{     循环体语句;     条件控制语句; }while(条件判断语句);