周总结_第一周

周总结

计算机概念

	是一种能够按照程序运行，自动，高速处理海量数据的现代化智能电子设备。
	俗称"电脑",没有任何软件的计算机 "裸机"!
	计算机的分类:
			台式计算机,笔记本,大型计算机(公司的机房)
		计算机的用途
		1)科学计算 
	2)多媒体应用
	3)计算机辅助设计 ----CAD工程制图
	4)人工智能
	5)计算机网络

计算机硬件和软件

	硬件:机械,光电元件的物理装置的总称: cpu,电源,主机箱,显卡,键盘,鼠标,主板,显示器....
	软件:
		系统软件:
				pc端: Windows,Linux,Mac
				移动端:android,ios
		应用软件:
				计算机安装的客户端软件:
							QQ客户端
							微信
							yy语音
				
	软件结构划分
	C/S结构
			Client/Server:客户端和服务器端的交互
			典型特点:
					客户端必须升级,才能使用 服务器高版本的功能: 比如QQ
					
			一阶段:网络编程 TCP/IP 建立客户端和服务器通道!(Socket)		
	B/S结构
	
			Browser/Server:浏览器端和服务器端的交互 
			
			二阶段一直到四阶段  以后研究B/S结构
			典型的特点:
					只要保证计算机上有浏览器,那么就可以访问服务器高版本功能!(浏览器本地可以不升级)
					程序员专用浏览器  
							"firefox 火狐"  /谷歌浏览器
	软件开发
			就是借助开发工具与计算机语言完成软件的制作过程(制作过程中,需要有计算机语言相关的数据和指令!)
			开发工具:
				前两周---使用notepadd++ 高级记事本(写任何计算机语言代码的会有颜色标记),写代码
						使用dos控制台进行编译和运行(javac/java指令)  
				第三周开始:就会使用  idea2021 (自动编译/很智能化)	
				二阶段:
						前端开发工具:HBuilderX或者vscode/webStorm(idea同一个公司的)

	人机交互 
			xxxxxxxxxx 人和计算机之间沟通一种方式:
			1)图形界面化:无论任何操作系统,都会有图形界面化(简单,直观,易于上手)
			​2)命令行方式:需要控制台 (Linux系统,Linux控制台终端输入一些命令) 
			          windows系统:打开dos控制台,里面输入一些指令
			                              
			windows系统打开dos控制台的方式:          
						1)开始菜单输入cmd---->命令行提示符---->以管理员身份打开         
						 2)推荐方式:                windows+r键--->输入"cmd"--->打开控制台

人机交互在windows上一些常用指令

			1)盘符切换		盘符号后面:(盘符号不区分大小写)
				C:\Users\Administrator>D:
			
				D:\>
			2)dir罗列当前盘符或者指定文件夹中所有的文件以及文件的名称(详细信息)	
			3)当dos窗口内容比较多,清屏命令 cls   (clear screen:清除屏幕)
			
				D:\>cls
			4)cd 目录名称(文件夹名称)  :进入指定的目录中		cd(change Directory)
				D:\>cd ee_2302
			
				D:\EE_2302>
				
			
			5)cd.. 回退上一级目录
				D:\EE_2302\day2>cd..
			
				D:\EE_2302>
			6)cd 多级目录名称:进入指定路径的文件夹中
				D:\>cd D:\EE_2302\day2\code
			
				D:\EE_2302\day2\code>
			7)cd \ 从多级目录中回退到根目录
				D:\EE_2302\day2\code>cd \
			
				D:\>
			8)md 目录名称(文件夹名称):创建文件夹             md(make directory)
				D:\EE_2302\day2\code>md aaa
			
				D:\EE_2302\day2\code>
			9)创建文件  copy con 文件名称  --->按回车--->进入编辑模式(编辑文件内容)---->按 ctrl+z:保存--->按回车--->创建完成
				D:\EE_2302\day2\code\aaa>copy con aaa.txt
				这是一个txt文件^Z
				已复制         1 个文件。
			
				D:\EE_2302\day2\code\aaa>
				
			10)删除指定的文件   del 文件名称   
				D:\EE_2302\day2\code\aaa>del a.java
			
				D:\EE_2302\day2\code\aaa>
			11)批量删除所有的指定后缀的文件 del *.xx
				D:\EE_2302\day2\code\aaa>del *.txt			批量删除所有带.txt后缀的文件
			
				D:\EE_2302\day2\code\aaa>
			12)删除目录(文件夹)  rd 目录名称  (前提条件:这个目录必须为空目录,否则系统提示"目录不是空的")
				D:\EE_2302\day2\code>rd aaa
				目录不是空的。
			
				D:\EE_2302\day2\code>
			传统删除带内容的目录:需要先进入到指定目录中,删除里面的内容;然后回退上一级目录,删除当前文件夹!
			
			13)rd扩展指令: rd /s 目录名称(询问是否删除带内容目录)
				D:\EE_2302\day2\code>rd /s aaa
				aaa, 是否确认(Y/N)? y
			
				D:\EE_2302\day2\code>
				
			14)rd扩展指令  rd /s /q 目录名称(暴力删除,不询问直接干掉)	
				D:\EE_2302\day2\code>rd /s /q 高圆圆
			
				D:\EE_2302\day2\code>

Java语言发展历史

				詹姆斯~高斯林  :Java之父    1995年正式推出"Java" "爪哇"
			Jdk版本:目前使用的8版本/9版本 自己新特性


Java应用领域:比较广泛 360行几乎全部涵盖进去

			1)电商平台
			2)医院挂号系统
			3)收银系统
			4)健康码
			5)比亚迪----MES系统  (传统行业)
			6)物流系统
			7)元宇宙
				
				畜牧业系统(涉及云端)


Java平台版本(重点)
		JAVASE:桌面应用程序 (一阶段)
					学习java语法/运算符/流程语句/面向对象的基础/高级特性(集合,io流,多线程,网络编程,反射,jdk新特性....) Java认知
		
		JAVAME:针对嵌入式设备提供一套解决方案 
			   (移动端用到的 早期塞班系统,安卓系统)  "看平台"
			   
		JAVAEE:针对企业级开发提供一套解决方案 (以后的方向)
				二阶段去学习企业级开发的核心技术
				
					Servlet(开源的原生框架  Server Applet:针对服务端程序开发(java服务连接器))
					servlet+jsp+jdbc
				三阶段:
	            		Spring 
	            		SpringMVC
	            		Mybatis
	            		
	            		Springboot+vue 前后端分离
	            		
	           	四阶段:JavaEE分布式 SpringCloud 	

Java语言特点

	           	很多特点 :
						安全性,健壮性,分布式....(学习到后期体会)
			比较容易理解:
						开源----->开发源代码---涉及的Java设计模式/数据结构/算法...
						跨平台---->跨操作系统(不同的操作系统上都可以编译和执行 java文件)

jdk安装目录的文件夹以及文件的介绍

classpath(了解)

		临时环境变量    
		 此电脑--->右键属性---->高级系统设置---->环境变量----->系统变量 
		 新建一个变量名:classpath
		 变量值:要指定的那个class文件(字节码)的路径
		 
	 
		 配置完毕之后,在java 字节码文件前缀的时候---运行这个类的时候,始终是在classpath临时环境变量去执行对应.cass文件,如果这个路径中没有class字节码文件,提示"找不到主类"!

Java系统环境的配置path(重点)

配置path的目的:是为了在任何目录都能使用javac和java指令


为什么要配置系统环境变量?
如果不配置系统环境变量,永远只能在jdk安装目录中bin目录里面去使用javac和java指令,对java编译和运行!

配置是为了让我们在任何目录中都能够使用javac和java指令!
两种方式:选一种即可
	配置方式1	
		1)复制jdk安装目录的bin目录的路径	举例:D:\develop_software\Java\jdK_8\bin
		2)此电脑--->右键属性---->高级系统设置---->环境变量----->系统环境---->找到path将上面路径复制到path中(放在最前面)
		3)退出dos窗口,重写打开新的dos窗口,在任何目录中进行编译和运行!
		
		
	方式1配置的弊端	
		1)不安全,当jdk版本切换,需要手动更改系统变量中path,可能会导致别的环境变量被误删!
		2)这种方式后期 学习"web应用服务器" tomcat(用java编写的),启动会闪屏(启动失败),tomcat服务器启动的时候会寻找系统变量是否有"JAVA_HOME"的变量,如     			果存在,tomcat启动不会闪屏!
		
	
		
		
			 
	配置方式2(推荐方式)
		1)复制jdk安装路径(不需要bin目录的路径)
				举例:D:\develop_software\Java\jdK_8
		2)此电脑--->右键属性---->高级系统设置---->环境变量----->系统环境---->
			新建一个变量名
				变量名 JAVA_HOME
				变量值 上的jdk的安装路径
		3)在path中的路径上使用 %JAVA_HOME%\bin	
	    
	    
	  优点:\
	  	1)安全,即使jdk升级,不需要改动系统变量中path路径,只需要更改JAVA_HOME对应的路径
	  	2)后期使用tomcat web服务器的时候,不会出现闪屏!

Path环境变量的执行流程

	1)先要去在指定目录中(文件夹)找是否存在这个 xxx.java文件,如果存在这个文件就直接编译然后运行字节码的前缀
	2)如果当前指定的目录中(文件夹)如果不存在xxx.java文件,那么就需要在系统变量path中 %JAVAH_H0ME%\bin
	这个路径去寻找是否存在,如果存在,就编译,如果也不存在,那么说明系统中不存在这个文件 "找不到文件!"

文件名

如果是public class 类名{
}//主类？
这个类名必须和文件名一致

如果是 class 类名 
则可以和文件名不一致

JRE,JDK,JVM概念

JRE:
Java Runtime Environment Java运行环境,包含jvm以及java文件运行所需要的核心类库 (lib--rt.jar)

JDK:
Java Development Kit :Java软件开发工具包,包含jre以及工具文件(toos.jar)

JVM:
Java Virtual Machine :Java虚拟机, 抽象化的计算机(在实际计算机上模拟各种功能)

JVM有自己的内存模型结构:
		栈(本地方法栈,操作数栈...) ,堆,方法区,pc寄存器(程序计数器) 等等
		
Java文件需要运行在操作系统上,而操作系统需要有Java运行环境里面需要jvm来编译并且解析Java文件中的内容!

java指令:负责解析java文件编译后的.class文件

什么是关键字合字符？

什么是关键字?
		关键字:被赋予特定含义的单词!
		
		在高级记事本notepad++或者editPlus,以及开发工具idea针对关键字都有一种特殊颜色标记!
	
		class:Java语言中定义类的格式!  (面向对象部分去讲)
		public:权限修饰符号  (公开的/公共的,任何人都可以访问的,访问权限足够大)
		static:静态修饰符号(在面向对象部分去讲)
		void:和Java语言中定义方法(函数)一种格式  (方法的时候讲!)
	
	
	注意事项:
			1)组成关键字的字母全部都是小写,而且特殊含义的!
			2)goto 和const不作为关键字,保留字使用!

class KeyWord{
	
	public static void main(String[] args){
		
			System.out.println("被Java语言赋予特定含义的单词!") ;
		
	}
}

标识符的组成规则有哪些？

标识符:
	给包,类(接口:面向对象中讲),方法(变量),常量等起名字一种"字符序列"
	起名字------>做到"见名知意"
组成规则:
	1)可以是英文大小写字母
	2)可以是数字
	3)可以_下划线
	4)可以是$符号
	
注意事项:
	1)不能以数字开头
	2)非法字符不能出现,_和$在开头的
	3)Java严格区分大小写(虽然起名字可以使用大写关键字 int Public = 100;不推荐)
	
标识符命名规范

    1)给类名(或者接口名)起名字:  遵循格式 "大驼峰命名法" ("阿里规范")
		类名是单个单词: 首字母大写,其余小写!
		举例:
				定义一个学生类
						class Student{}   
						class S{} 不规范
		类名是多个单词:	每个单词首字母大写,其余小写		
		举例:
				定义有一个"玩游戏"的类
						 class PlayGameDemo{}
						 
	2)给变量(和方法就是函数)起名字:遵循"小驼峰命名法";
		变量名是一个单词:字母全部小写
		举例:
				定义一个价格(默认int 整数)
				int price = 100 ;
		变量名是多个单词:第一个单词字母全部小写,
						 从第二个单词开始每一个单词首字母大写.其余小写	
		举例:
				定义一个苹果价格
				int applePrice = 100 ;
	3)给常量(程序执行过程中,其值是固定的),起名字的时候:

		常量是一个单词(开发中很少见):字母全部大写
		举例:	字符串常量 :双引号括起来的内容    "HELLO"
		
		常量是多个单词(开发中经常见到):
			每个单词字母都大写,单词和单词之间下划线隔开
			
		举例:
				jdk提供了一个类  "Thread 线程类"提供线程优先级的常量
				
				自定义常量:public static final int MIN_PRIORITY = 1;

   
				前面省略修饰符int NORM_PRIORITY = 5;  默认优先级

   
				前面省略修饰符int MAX_PRIORITY = 10;  最大优先级

Java中的注释分为哪些，有什么作用

//单行注释

/*
	多行注释
*/


/**
	文档注释 --在面向对象中讲    (在jdk的bin目录里面有一个指令javadoc.exe 可以解析文档注释的)
	@author:作者名称
	@version:版本号
*/
	注释: 解释代码的文字说明  (必须习惯写,适当的针对关键性代码添加一些注释)
		分类:
		     单行注释/多行注释-- 普通注释
			 文档注释

作用:
	1)提高代码阅读性
	2)可以排错(仅仅是在高级记事本 写的java代码,自己手动编译!)

		//java中定义一个类 固定语法格式 : class 类名{} 
class CommonsDemo{
	
	/*
		main函数的固定写法 public static void main(String[] args){}
		它是能够jvm进行调用的,是所有java程序的入口!
	*/
	public static void main(String[] args){
		
		//输出语句的固定写法:输出不同的"字符串"(双引号括起来的)内容
		System.out.println("helloworld") ;
		System.out.println("高圆圆") ;
		System.out.println("JavaEE") ;
		System.out.println("王宝强") ;
	}
			
}

Java数据类型的划分

两大类:
		基本数据类型：四类八种

			整数类型:
					字节类型 byte    -128-127   1个字节
					短整型  short               2个字节
					默认int类型                 4个字节
					长整型 long                 8个字节		//注意赋值时数据末尾添加L/l
			浮动类型:
					单精度 float                4个字节			//注意赋值时数据末尾添加F/f
					双精度:double(默认的)        8个字节
		  	字符类型:
					char					   2个字节
		  	布尔类型
					boolean					   1个字节
	引用数据类型:(以后研究类型:引用类型)
			数组,类,接口(面向对象中)
			

		基本类型使用居多:整数以及浮点/布尔boolean
			整数类型:使用居多int类型,long(定义时间毫秒值)
			浮点类型: double使用居多(市场价等等都会double)
			布尔类型: 在一个具体业务场景的时候,大量会使用逻辑语句,需要用boolean

进制相关

01_进制的由来以及概念组成规则

02_任意进制转换十进制

03_十进制转换成任意进制

04_8421码

05_定义变量的三要素

06_扩展_有符号位的数据表示法_以及两个变量相加的隐式类型提升

07_强转类型转换的语法格式

练习

什么是常量？常量的分类

什么是常量?
在程序过程中,其值不发生改变的量!(固定值)
分类:
	1)字面值常量
	
		A)字符串常量: 使用双引号括起来的内容都是字符串
			举例:	"高圆圆","helloworld"....
			字符串+任何数据 = "新的字符串" ; 中间"+",拼接符号
			或者任意数据+"字符串"="新的字符串";
			
			
		B)字符常量:	使用单引号括起来的单个内容
		
			举例:
					'a','A','0' 
				字符单独使用,就是代表字符本身 ,如果字符参与运算,它会寻找
				ASII码表中的对应的整数值计算(重点)
					'A'对应的值 65
					'a'对应的值 97
					'0'对应的值 48   (只有参与运算才去找个值)
			
			
					
					'AB'---错误的
		C)整数常量
				100,10,24...
				包含进制 
						进制:数据进位一种方式
		D)小数常量
				3.14,12.35
		E)布尔常量
				true或者false 
		F)空常量 null	---属于"引用数据类型"的默认值	(面向对象中讲)
				举例:String:jdk提供的字符串类(字符串在java非常特殊的引用类型)
						String s = null ;
						String s = "高圆圆" ;
	
	2)自定义常量:
			面向对象中讲  java中一个关键字 final:状态修饰符(最终的,无法更改的)

	     class ConstantDemo{
	
	public static void main(String[] args){
		
		//字符串常量
		System.out.println("helloworld") ;
		System.out.println("高圆圆") ;
		System.out.println("--------------------------------") ;
		//字符常量
		//System.out.println('AB') ;//必须单个内容
		System.out.println('中') ;
		System.out.println('a') ;
		System.out.println('A') ;
		System.out.println('0') ;
		System.out.println('a'+1) ;//'a'参与运算对应的ASII码表的值 97
		System.out.println('A'+1) ; //'A'参与运算对应的ASII码表的值 65
		System.out.println('0'+1) ;//'0'参与运算对应的码表的值 48
		
		
		System.out.println("--------------------------------") ;
		//整数常量
		System.out.println(100) ;
		System.out.println(55) ;
		System.out.println("--------------------------------") ;
		//小数常量
		System.out.println(3.14) ;
		System.out.println("--------------------------------") ;
		//布尔常量
		System.out.println(true);
		System.out.println(false) ;
		System.out.println("--------------------------------"); 
		//空常量
		//System.out.println(null) ;//报错的
		//定义一个字符串
		String abc = "高圆圆" ;
		System.out.println(abc) ;
		abc = null ;//重新赋值
		System.out.println(abc) ;
		
 	}
}
	     

进制

//打印出 
//0B100对应的十进制
//0100(八进制)对应的十进制
//100:整数:默认就是十进制
//0x100(0x表示的十六进制) 对应的十进制

//进制就是常量
class ConstantDemo2{
	
	public static void main(String args[]){
		
		System.out.println(0100) ;//八进制---64
		System.out.println(0b100) ;//二进制---4
		System.out.println(100) ;//十进制 默认十进制
		System.out.println(0x100) ;//十六进制---256
		
	}
}

变量

	变量三要素:
			 数据类型 变量名  =初始化值;
			 
			 数据类型 变量名;
			 变量名 = 值;
	 
	数据类型:
			 基本数据类型:四类八种
			 	整数:  byte 		1个字节    -128~127
			 		  short      2个字节
			 		  int:默认   4个字节
			 		  long       8个字节 ,定义的时候,初始化值后面必须加标记L或者l
			 	浮点: 
			 		   float:单精度 	 4个字节
			 		   double:默认双进度 8个字节
			 	字符   char         占2个字节
			 	布尔   boolean	  占1个字节
			 引用数据类型:数组,类,接口(面向对象中讲)

/*
	什么是变量?
	变量:在程序的执行过程中,其值发生改变的量!
	定义变量的三要素:
		
		1)数据类型
		2)变量名:满足标识符的规则 "小驼峰命名法"
		3)初始化值
		
		
	数据类型:(重点)
		1)基本数据类型:四类八种
			整数类型:			如果题意中没有明确要求数据类型,默认都是int
					 byte	字节类型     占1个字节            范围:-128~127(考点)
					 short	短整型		 占2个字节
					 int	整数类型     占4个字节
					 long	长整型		 占8个字节
					 整数默认int,在定义long类型,在初始化值的后面加上标记 L或者l(推荐L)
					
			浮点类型			默认类型是double
					float	单精度类型	 占4个字节
							float后面的值必须加标记F或者f
					double	双精度类型	 占8个字节
			字符类型
					char	使用单引号括起来的字符  占2个字节
			布尔类型
					boolean	表示true或者false ,不会参与运算!(开发中表示逻辑:真或者假)
			
		2)引用数据类型 :下周讲
					数组,类,接口
		

*/
class DataTypeDemo{
	
	public static void main(String[] args){
		
		
		//定义一个byte类型变量
		byte b = 100 ;
		b = 120 ;
		System.out.println("b:"+b) ; // "b:120"
		System.out.println("-------------------------") ;
		
		//短整型short
		short s = 120 ;
		s = 150 ;
		System.out.println("s:"+s) ;
		
		System.out.println("-------------------------") ;
		
		//int类型
		int i = 10000 ;
		System.out.println("i:"+i) ;
		
		System.out.println("-------------------------") ;
		//int ii = 100000000000000;//过大的整数,int类型不能接收,使用长整型long
		//整数默认int,在定义long类型,在初始化值的后面加上标记 L或者l(推荐L)
		long ii = 100000000000000L;
		System.out.println("ii:"+ii)  ;
		System.out.println("-------------------------") ;
		//浮点类型:
		//float/double:默认double
		double d = 12.56 ;
		d = 12.34 ;
		System.out.println("d:"+d) ;
		System.out.println("-------------------------") ;
		//float f = 3.14 ;//DataTypeDemo.java:67: 错误: 不兼容的类型: 从double转换到float可能会有损失
              //浮动类型默认double,所以float后面的值必须加标记F或者f
		float f =3.14f;//定义就是单精度类型
	
		System.out.println("f:"+f) ;
		
		System.out.println("-------------------------") ;
		
		//字符char
		char ch = '我' ;
		char ch2 = 'a' ;
		ch2 = 'A' ;
		System.out.println("ch:"+ch) ;
		System.out.println("ch2:"+ch2) ;
		System.out.println("-------------------------") ;
		
		//布尔类型 boolean
		
		boolean flag = true ; //后端语言使用逻辑语句进行处理: 
								//登录:必须满足用户名和密码都和数据库中一致,才能登录!
								
		flag  = false ;
		System.out.println("flag:"+flag) ;
	
	}
}

定义变量的注意事项:
	1)Java语言是一个"强类型"语言,它的语法结构非常严谨,不能重复定义变量
			而前端语言:javascript:弱类型语言,是可以重复定义变量;
	2)java语言中的所有语句结束了就必须带";"分号		
	3)定义变量代码书写格式:(代码风格)
			建议:一行一个变量,不要所有变量都写在一行上
	4)定义变量,但是在使用之前没有初始化,就会报错,系统认为这个变量没值!(仅仅适用于局部变量)

		局部变量:在方法(函数)中定义的变量,都是局部变量,必须使用之前给值!

class DataTypeDemo2{
	
	public static void main(String[] args){
		
		//定义一个int类型的变量
		int x = 100 ;
		//int x = 200 ;//重复定义变量(已在方法 main(String[])中定义了变量 x)
		x = 50 ;//这样可以,重新赋值
		System.out.println("x的值是:"+x) ;
		System.out.println("--------------------------") ;
		//int m = 10 ;//需要分号才能结束
		
		
		//int a = 10 ; int b = 20 ; int c = 30 ;(代码不规范)
		
		//同时定义三个变量(分行定义)
		//int a = 10 ;
		//int b = 20 ; 
		//int c = 30 ; 
		
		//一行同时定义多个变量
		int m, n= 100,z = 50 ; //(笔试题中)
		System.out.println("m:"+m) ;// 可能尚未初始化变量m,在使用之前必须给初始化值
		m = 10 ;
		System.out.println("m:"+m) ;//定义后,使用之前给值,就可以用!
		System.out.println("n:"+n) ;
		System.out.println("z:"+z) ;
		
		
	}
}

什么隐式转换?

Java语言中,变量相加,必须保证数据类型一致才能进行运算!

Java的一种隐式转换(默认类型提升) (重点)
针对byte,short,char三者之间 不转换,一旦自己参与运算的时候,
优先提升为int(考点)--->long--->float--->double

boolean类型不会参与任何转换!

	/*
	需求:
		int a = 3 ; 
		byte b = 4 ;
		
	变量和变量b求和的结果是什么?结果的数据类型是什么?
	*/
class DataTypeDemo3{
	public static void main(String[] args){
		
		//定义两个变量
		int  a = 3 ; 
		byte b = 4 ;
		//System.out.println(3+4) ;
		
		//如果此时接收a+b的结果类型如果是int类型
		int result = a + b ; //a +  b---->提升int类型才能进行计算!
		System.out.println("result:"+result) ;
		
		
		
	}
}

什么是显示转换(强转)

Java强转类型转换("强转")(显示转换):目的将大的数据类型转换成小的数据类型
		
语法格式:这个格式不仅仅适用于基本类型,也适用于引用数据类型!

		目标数据类型  变量名  = (目标数据类型)(初始化值);
		
		举例:
				
			byte result = a + b ; // 
			优化为
			byte result= (byte)(a+b);

class DataTypeDemo4{
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 3 ;
		byte b = 4 ;

		//两个变量进行相加
		//接收结果变量是byte类型
		//byte result = a + b ;//DataTypeDemo4.java:14: 错误: 不兼容的类型: 从int转换到byte可能会有损失
		//上面出现错误的原因:
		//等号右边: a+b--->byte类型的b参与运算,优先提升为int,相加后的结果int类型的7
		//等号左边:字节类型 byte:占1个字节,不能接收4个字节的结果
		
		//必须使用强转类型转换才能接收
		//目标数据类型  变量名  = (目标数据类型)初始化值;
		byte result = (byte)(a+b);
		
		System.out.println("result:"+result) ;
	}
}

算术运算符:

   基本算术运算符:  +,-,*,/,%
   注意:
	        /:默认取整 (java是强类型语言,弱类型javascript前端语言不会默认取整)
			%:模:求余数
			//小数计算 - 或者/ 计算机计算的时候,"伪计算"
			//jdk提供一个类(后面讲这个常用类:BigDecimal 会对小数进行精确计算!)
		
	扩展的算术运算符:++和--	 (使用比较多的)	
			++和—单独使用和参与运算使用发区别
			单独使用:
				 无论在数据的前面还是后面,都是对当前这个变量自增1或者自减1
			参与运算使用:
			     在数据的前面,先自增或者自减1,然后参与运算
			     在数据的后面,先运算,然后在自己自增或者自减1

基本的赋值运算符:=

	将=号右边的值赋值给左边指定类型的变量

		//举例:
					int x = 10 ;//	将10赋值给int类型的变量x

	注意:
	    =不能写成==,==不能写成= (==是比较运算符)
		
	扩展的赋值运算符
		+=,-=,*=,/=,%=  :将等号右边的数据和左边的变量值操作,在赋值给左边的变量

			//举例:
			    int x = 10 ;
				x += 20 ;-//---->等价于  x = x + 20 ;(前提条件:类型相同)
						//将=等号左边的变量和右边的值相加在赋值给左边的变量x		

	扩展的赋值运算赋的特点
				特点:隐藏了强转类型转换

 short = 23 ;
    s += 12 ; 不会编译报错----等价于 s = (short)(s+12) ;
    
    short = 23 ;
	//s = s +12 ; //会编译报错:  s+12 --->s优先提升int,结果还是int,short无法接收,必须强转!

关系(比较)运算符(最简单一种运算符)

<,>,<=,>=,==,!=
这些符号连接的表达式无论简单还是复杂的结果都是boolean值!

==:在基本数据类型中,比较两个数据值是否相等

注意事项:
		==不能写成 "="
数学表达式
	3<=x<=5, //错误，计算机语言中:必须使用逻辑符号连接!
	//例：(x >= 3 && x <= 5)

class OperatorDemo{
	public static void main(String[] args){
		
		//定义三个变量
		int a = 3 ;
		int b = 4 ;
		int c = 5 ;
		
		System.out.println(a > b) ;
		System.out.println(a<=b) ;
		System.out.println(a <= c) ;
		System.out.println(a >c) ;
		System.out.println(a==c) ;
		System.out.println(a!=b) ;
		
		System.out.println("-------------------------------") ;
		
		int x = 100 ;
		int y = 200 ;
		//定义变量接收x和y比较的结果
		//boolean flag =  x= y ; 将y的值给x,将x值留下来赋值给flag,boolean不参与运算!
		
		boolean flag = (x==y) ;
		System.out.println(flag) ;
		
		
		
	}
}

逻辑运算符号(开发中经常用到)

基本的逻辑运算符号：

	逻辑与&：具有并列条件,所有的条件必须同时满足才能成立!
			特点:有false则false (有一个不满足就不成立!)
			
			&符号连接的左边表达式如果是false,右边依然要执行,效率低!
	
	逻辑或|:  或的关系,只要满足一个条件即可成立
			特点:有true,则true
			
			|符号连接的左边表达式如果是true,右边依然要执行,效率低!
	逻辑异或^
			 特点:相同则为false,不同则为true
			 简单记 男女关系
					"男男" "女女"   false 
			        "女男"  "男女"  true
	逻辑非! 
			特点:非true,则false
			    非false,则true
				偶数个非是它本身!

class OperatorDemo{
	public static void main(String[] args){
			
		//定义三个变量
		int x = 3 ;
		int y = 4 ;
		int z = 5 ;
		
		//逻辑与&
		System.out.println((x > y) & (x > z)) ; //false & false
		System.out.println((x > y) & (x < z)) ; //false & true
		System.out.println((x < y) & (x > z)) ; //true  & false
		System.out.println((x < y) & (x < z)) ; //true  & true
		System.out.println("---------------------------------") ;
		
		//逻辑或|
		System.out.println((x > y) | (x > z)) ; //false | false
		System.out.println((x > y) | (x < z)) ; //false | true
		System.out.println((x < y) | (x > z)) ; //true  | false
		System.out.println((x < y) | (x < z)) ; //true  | true
		
		System.out.println("---------------------------------") ;
		
		//逻辑异或^
		System.out.println((x > y) ^ (x > z)) ; //false ^ false
		System.out.println((x > y) ^ (x < z)) ; //false ^ true
		System.out.println((x < y) ^ (x > z)) ; //true  ^ false
		System.out.println((x < y) ^ (x < z)) ; //true  ^ true
		
		System.out.println("---------------------------------") ;
		//逻辑非!
		System.out.println(!(x>y)) ;
		System.out.println(!!(x>y)) ;
		
		System.out.println("---------------------------------") ;
		
		//对于逻辑单与&  
		
		int a = 3 ; //a=4
		int b = 2 ;  // b=1
							//false    &  true 
		System.out.println(((++a) == 3) & ((b--)==2)) ;
		//a,b值多少,以及 上面输出结果是多少
		System.out.println("a:"+a) ;
		System.out.println("b:"+b) ;
		System.out.println("-------------------------") ;
		
		//逻辑单或|
		int m = 3 ; 	//m=4
		int n = 2 ;  //n=1
							//true    |  false
		System.out.println(((m++) == 3) | ((--n)==2)) ;
		//m,n值多少,以及 上面输出结果是多少
		System.out.println("m:"+m) ;
		System.out.println("n:"+n) ;
		
		
	}
}

	逻辑双与&&和逻辑单与&有什么区别?
	
		共同点:
				有false,则false(并列条件,必须同时满足条件才成立!)
	
		区别:
				逻辑单与&:连接的表达式左边如果是false,右边依然要执行
				而逻辑双与&&  ,连接的表达式如果左边是false,则右边不执行(具有短路效果)
		
		开发中:并列条件：逻辑双与&&代替逻辑单与&,因为效率高!
		
   			  或的条件:优先采用是逻辑双||代替逻辑单或|,效率高!

			  逻辑双与||:左边为true(有true,则true),右边不执行,具有短路效果!

class OperatorDemo2{
	public static void main(String[] args){
		
		//逻辑双与&&
		//定义三个变量
		int x = 3 ;
		int y = 4 ;
		int z = 5 ;
		
		//逻辑双与&&:有false则false
		System.out.println((x > y) && (x > z)) ; //false && false
		System.out.println((x > y) && (x < z)) ; //false && true
		System.out.println((x < y) && (x > z)) ; //true  && false
		System.out.println((x < y) && (x < z)) ; //true  && true
		
		System.out.println("--------------------------------") ;
		
		//定义变量m
		int m = 4 ;		//m=5
		int n = 3 ;
		
		System.out.println("m:"+m) ; //m:4
		System.out.println("n:"+n) ; //n:3
		System.out.println("--------------------------------") ;
							//false && 	true
		boolean flag = (((++m) ==3) || ((n--) == 3) ) ;
		System.out.println(flag) ;
		System.out.println("m:"+m) ;
		System.out.println("n:"+n) ;
		
		System.out.println("--------------------------------") ;
		
		//逻辑双或||
		//左边为true(有true,则true),右边不执行,具有短路效果!
		int a = 10 ;
		a ++ ;
		int b = 11 ;		 
							//true ||  false // b=12
		System.out.println((a==b) || ((b++)==12)) ;
		System.out.println("a:"+a+",b:"+b) ;
		
	}
}

三元运算符的格式以及执行流程

三元运算符(三目运算符)
			还有二目:一个表达式两个变量  x==y

三元运算符的格式:
			(表达式)? 执行true的结果:执行false的结果; (后期在jdk源码中会见到)
	
执行流程:
			1)表达式可以简单可以复杂,结果是boolean,判断表达式是否成立
			  如果成立,则执行true的结果
			2)否则不成立,则执行false的结果;

class OperatorDemo{
	public static void main(String[] args){
		
		//定义两个变量
		int a = 10 ;
		int b = 12 ;
		
		//求两个变量的最大值(没有明确要求数据类型默认int)
		
		//(表达式)? 执行true的结果:执行false的结果;
		
		//定义一个变量max
		int max = (a>b)?a:b;  //符号:都是英文的
		System.out.println("两个变量中的最大值是:"+max);
		System.out.println("--------------------------------");
		//求最小值
		int min = (a<b)?a:b;
		System.out.println("两个变量中的最小值是:"+min);
		
		System.out.println("--------------------------------");
		//比较a和b的值是否相等   true/false
		
		//方式1:
		boolean flag = (a==b)? true:false ;
		System.out.println(flag) ;
		
		//方式2:boolean flag = (a==b);
		
		
		//需求:自定义三个变量,x,y,z(默认int),比较三个数据中的最大值;
		int x = 10 ;
		int y = 30 ;
		int z = 20 ;
		//三元运算符实现?
		//方式1:分步实现
		//1)将x和y先进行比较,使用一个中间变量记录x和y最大值
		//2)使用这个临时变量记录的最大值在和z比较
		
		//(表达式)? 执行true的结果:执行false的结果;
		//定义一个变量(中间变量)
		int temp = (x>y)?x:y;
		//定义结果变量max2
		int max2 = (temp>z)? temp : z ;
		System.out.println("三个数据中的最大值是:"+max2) ;
		System.out.println("-----------------------------------------") ;
		
		//三元运算符的嵌套方式(不推荐)
		int max3 = (x>y)?((x>z)?x:z):((y>z)?y:z) ;
		System.out.println("三个数据中的最大值是:"+max3) ;
	}
}

键盘录入的操作步骤

键盘录入是jdk提供的一个类 java.util.Scanner类   (文本扫描器,让桌面应用程序更灵活)

	为什么要使用键盘录入数据呢?
	如果直接去定义变量,直接写死了,程序不灵活,jdk提供给我们 "文本扫描器"
	可以键盘录入数据,让程序灵活一些 

键盘录入数据的操作步骤:
		1)在class类的上面书写 导包的格式
		固定格式: import java.util.Scanner;(在Java中只要不是java.lang包下的都需要导包)

		2)在main方法中,创建文本扫描器 :格式
			Scanner  文本扫描器变量名  =  new  Scanner(System.in) ;  固定格式
		3)提示并录入数据(没有提示类型,默认录入int)
			System.out.println("请输入一个数据:") ;
			int 结果变量= 文本扫描器变量名.nextInt() ;   nextInt():文本扫描器提供 录入int数据的方法
		4)使用结果变量;

	//1)导包


import java.util.Scanner ;
class Demo{
    
    public static void main(String[] arsg){
        
        //2)创建键盘录入对象(文本扫描器):固定格式
        Scanner sc = new Scanner(System.in) ;
        
        //3)提示并录入数据
        System.out.println("请输入一个数据:") ;
        int x = sc.nextInt() ;//录入下一个int类型//录入字符推荐nextLine ，还有一个是next,
							//俩者有区别 ,用xx.equals(),比较字符
											
        
        //4)使用x进行逻辑操作...
    }
}

3.流程控制语句

1)顺序结构语句:简单(代码从main进来之后,由上而下依次加载!)
2)选择结构语句
		两种格式
			1)if语句:(使用居多)
					//1.1)
						 if(条件表达式){
						}
					1.2)
						if(条件表达式){
	                            ...
	                        }else{
	                            ...
	                        }
					
					1.3)
						if(条件表达式1){
	                        ...
						}else if(表达式2){
	                        ...
	                        ...
						}else{
	                       ...
						}
						可以嵌套使用

import java.util.Scanner;
public class If{
	public static void main(String[] args){
		String userName = "高";//不知道为什么中文相同总是不能比较成功，可能是编码问题
		String passWord = "123456";
		//创建文本编辑器
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入用户名");
		String yourName = sc.nextLine();
		System.out.println("请输入密码");
		String yourPwd = sc.nextLine();
		//判断用户名，密码是否正确
		if((yourName.equals(userName)) && (yourPwd.equals(passWord))){
			System.out.println("恭喜你，登陆成功");

		}else{
			System.out.println("对不起，你的用户名或者密码错误");
		}
	}
}

了解

扩展(了解概念)
	位运算符:它是针对数据直接进行运算的!
	
	基本的位运算符:
	
		位与&:有0,则0
		位或|:有1,则1
		位异或^:相同则为0,不同则为1
		反码~:所有的二进制位全部按位取反,0变1,1变0

		Java中计算机所以计算都是对补码进行计算

//举例
class OperatorDemo{
	public static void main(String[] args){
		
		System.out.println(3&4) ;
		System.out.println(3|4) ;
		System.out.println(3 ^ 4) ;
		System.out.println(~3) ; 
 	}
}

/*
	3和4对应的原码
	
	00000000  00000000 00000000  00000011   3的原码,反码,补码
	
	00000000  00000000 00000000  00000100   4的原码,反码,补码
	

位与&:有0,则0

	00000000  00000000 00000000  00000011
	
位与&	
	00000000  00000000 00000000  00000100
	----------------------------------------
	00000000  00000000 00000000  00000000
	
结果是0



位或:有1,则1
	00000000  00000000 00000000  00000011
位或|	
	00000000  00000000 00000000  00000100
	-----------------------------------------------
	00000000  00000000 00000000  00000111
	
	7
	
	
	
位异或^:相同则为0,不同则为1	
	
	00000000  00000000 00000000  00000011
位异或^	
	00000000  00000000 00000000  00000100
	----------------------------------------
	00000000  00000000 00000000  00000111

    7
	
	
	
~3 所有的二进制位全部按位取反,0变1,1变0
	00000000  00000000 00000000  00000011	
~
	---------------------------------------
	11111111  11111111 11111111  11111100   ----补码 
	
	
	最高符号位     数值位					
	1				1111111  11111111 11111111  11111100    补码
	-												   1
	---------------------------------------------------------
	1				1111111  11111111 11111111  11111011  	反码
	
	-----------------------------------------------------------
	1				0000000  00000000 00000000  00000100    原码	
	-							4
*/

	位异或^特点
	
		一个数据被另一个数据位异或^两次,其值是它本身

class OperatorDemo3{
	
	public static void main(String[] args){
		int a = 10 ;
		int b = 20 ;
		System.out.pritnln( a ^ b ^ b) ; //输出a
	}
}

/*
	请实现两个变量数据交互(思考)
举例:
		int a = 10 ;
		int b = 20 ;
		
		最终结果:a = 20 
		b = 10 ;

*/
class Test{
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 10 ;
		int b = 20 ;
		System.out.println("互换前:") ;
		System.out.println("a:"+a) ;
		System.out.println("b:"+b) ;
		System.out.println("--------------") ;
		
		//方式1:中间变量(开发中常用)
		
		int temp = a; // temp = 10 
		
		a = b ;       // a = 20 ;
		b = temp ;	  // b  =10 ;
		
		
		/*
		//方式2:位异或^特点:一个数据被另一个数据位异或两次,其值是它本身
		a = a ^ b ;
		b = a ^ b ; // a ^ b  ^ b
		a = a ^ b ; // a ^ b  ^ a
*/		
		
		System.out.println("互换后:") ;
		System.out.println("a:"+a) ;
		System.out.println("b:"+b) ;
		
		
	}
}

		Java中计算机所以计算都是对补码进行计算
		
		面试题:(考点移位符号)
			请用有效的方式计算出2*8的结果 （2 * 2 ^ 移动次幂）
			
		位运算符里面的移位符号(扩展)
		
		<<(左移):  
		
				将"<<"左边的数据向左移动指定的位数(补码进行移动),
				将高位丢弃掉,空位补0
				
				结论:将"<<"左边的数据乘以2的移动次幂  
		
		>>(右移):
		
			将">>"左边的数据使用补码向右移动,如果最高符位是0,左边补0;
				如果最高符号位是1,左边补1;
				
				结论:将">>"左边的数据除以2的移动次幂
				
		>>>(无符号右移):
		
				将">>>"左边的数据使用补码向右移动,无论最高符号位是1
			还是0,永远左边空位补0;

class OperatorDemo2{
	public static void main(String[] args){
			System.out.println(3 << 2) ;//3左移2位  (12)   3*2^2 
			
			System.out.println(24 >> 2) ; //24 右移2位   24 /2^2 = 6
			
			System.out.println(-24 >> 2) ;//-6
			
			System.out.println(-24>>>2) ;
	}
}

待续

		2)switch语句(考点比较多)
			switch的格式
		3)循环结构语句
			for:使用居多
			while
			do-while