第二周java基础

计算机基础知识

计算机定义

计算机是一个能够高速处理海量数据智能电子设备.
由两部分组成:
软件和硬件.

计算机硬件

概念:由电子,机械和光电元件组成的物理装置的总称!
组成:由CPU、主板、内存、电源、主机箱、硬盘、显卡、键盘、鼠标，显示器等等

计算机软件

两种:
系统软件
dos系统,windows系统,Linux系统,MAC系统 移动端:Android系统,ios系统
应用软件:
计算机上的安装的客户端软件,QQ,办公软件wps,wegame软件,....

软件结构的划分

C/S结构 :Client-Server 客户端和服务器端交互
特点:
客户端软件必须升级才能使用服务器端的高版本功能
典型的应用:QQ客户端,yy语音....
QQ客户端要想去发红包,如果当前版本比较低,必须升级才能使用高版本功能!
B/S结构(架构):Browser-Server 浏览器端和服务器端交互(我们以后B/S结构)
特点:
只要保证你计算机上有浏览器,无论高版本还低版本都能够访问服务器!
典型的网站:
访问网易新闻等等网站(只要你有浏览器)
软件开发
人机交互
人机交互的两种方式

人机交互

人和人之间交流和沟通,使用人类语言
那么,人和计算机进行交流和交流,需要人输入的指令是计算机能够识别的符号!
比如:在指定磁盘上创建一个文件夹

人机交互的两种方式

方式1:图形界面化(快速)
简单,直观,容易上手!(用鼠标操作即可,快速去创建文件/文件夹/删除等操作)
方式2:命令行方式(掌握指令)
现在是在windows系统上

命令行方式,基本操作

进入dos命令行窗口(dos控制台)
windows键+r键组合键------>输入cmd----->进入dos窗口

常见的Dos命令

1)盘符号的切换
盘符号不区分大小写: 回车即可
C:\Users\Administrator>D:
D:\>
2)进入指定单个文件夹(目录) cd 目录名称
D:\>cd EE_2211
D:\EE_2211>
3)进入多级目录 cd 多级目录的路径
cd 将多级路径的名称复制过来(win10系统/win11系统 在dos窗口直接鼠标右键就粘贴了)
D:\>cd D:\EE_2211\10_24_am_code_resource\code
D:\EE_2211\10_24_am_code_resource\code>
4)回退上一级目录 cd.. 或者cd ..
D:\EE_2211\10_24_am_code_resource\code>cd..
D:\EE_2211\10_24_am_code_resource>
5)如果现在处在多级目录路径上,想回退盘符根目录 cd \或者cd\
D:\EE_2211\10_24_am_code_resource\code>cd\
D:\>
6)查看(罗列)这个盘符或者目录某个目录的详细信息 dir指令
D:\>dir
022/05/22 07:57 <DIR> 360驱动大师目录
2022/10/23 11:50 <DIR> BaiduNetdiskDownload
2022/07/05 11:15 <DIR> bootstrap模板
2022/06/25 00:11 9,804 bug.jpg
2021/07/28 20:44 <DIR> ChromeCoreDownloads
2022/08/27 17:51 <DIR> develop_software
2022/08/30 17:28 <DIR> deveop_tool
2022/09/29 17:38 <DIR> doc_api
2022/08/19 22:17 <DIR> EE_2113
2022/10/21 01:30 <DIR> EE_2204
2022/10/24 09:18 <DIR> EE_2208
2022/10/24 11:21 <DIR> EE_2211
7)清除屏幕指令 cls(clear scrren) :当你dos窗口上面有很多信息,将上面的信息不用了,删了,使用这个
8) 要在指定的目录里面创建文件夹(目录)
md (make directory)文件夹名称(目录名称)
D:\EE_2211\10_24_am_code_resource\code>md aaa
D:\EE_2211\10_24_am_code_resource\code>md bbb
D:\EE_2211\10_24_am_code_resource\code>md ccc
D:\EE_2211\10_24_am_code_resource\code>
9)创建文件
copy con 文件名称带上后缀名 ----按回车键---进入编辑模式,书写文件内容,书写完成成之后,按---ctrl+z,编辑完成----回车即可!
D:\EE_2211\10_24_am_code_resource\code\aaa>copy con a.txt
hello,Java 开始了^Z
已复制 1 个文件。
D:\EE_2211\10_24_am_code_resource\code\aaa>copy con hello.txt
正在学习常用的dos指令^Z
已复制 1 个文件。
D:\EE_2211\10_24_am_code_resource\code\aaa>
10)删除指定的文件夹(目录) 注意事项:rd 文件夹名称(目录名称) 只能删除空目录
D:\EE_2211\10_24_am_code_resource\code>rd aaa
目录不是空的。
先通过下面del指令将文件删除了,然后再去使用rd 文件夹名称(目录名称) 删除这个文件夹
D:\EE_2211\10_24_am_code_resource\code\aaa>cd ..
D:\EE_2211\10_24_am_code_resource\code>rd aaa
11) 删除文件 del 指定文件名称 也可以批量删除所有同名的后缀的文件
举例:del *.txt 删除所有带有.txt的文件
D:\EE_2211\10_24_am_code_resource\code\aaa>del *.txt
D:\EE_2211\10_24_am_code_resource\code\aaa>
D:\EE_2211\10_24_am_code_resource\code\aaa>del hello.java
D:\EE_2211\10_24_am_code_resource\code\aaa>
12) rd的扩展指令
在windows系统上,想删除带内容的目录(里面有文件或者子文件夹)
rd /s 文件夹名称(目录) :询问删除删除带内容的目录? y/n 选择y就是删除,n不删除
D:\EE_2211\10_24_am_code_resource\code>rd /s bbb
bbb, 是否确认(Y/N)?
rd /s /q 文件名称(目录) :不询问删除带内容的目录 (属于暴力删除 这个指令慎用!)
D:\EE_2211\10_24_am_code_resource\code>rd /s /q ccc
D:\EE_2211\10_24_am_code_resource\code>
windows+r--->输入control
rm -rf :在linux系统 递归删除所有的文件夹以及里面子文件
系统指令
查看ip地址 ipcong
ping ip地址或者域名:查看自己本机是否通信
ping指令(类似于 二战的时候:驱逐舰找潜艇,利用声呐系统)
D:\EE_2211\10_24_am_code_resource\code>ping www.baidu.com
正在 Ping www.a.shifen.com [36.152.44.95] 具有 32 字节的数据:
来自 36.152.44.95 的回复: 字节=32 时间=35ms TTL=54
来自 36.152.44.95 的回复: 字节=32 时间=34ms TTL=54
来自 36.152.44.95 的回复: 字节=32 时间=34ms TTL=54
来自 36.152.44.95 的回复: 字节=32 时间=34ms TTL=54
36.152.44.95 的 Ping 统计信息:
数据包: 已发送 = 4，已接收 = 4，丢失 = 0 (0% 丢失)，
往返行程的估计时间(以毫秒为单位):
最短 = 34ms，最长 = 35ms，平均 = 34ms
D:\EE_2211\10_24_am_code_resource\code>

JAVA发展历史

Java之父 詹姆斯高斯林 1995年正式推出
Java图标 热气腾腾咖啡图标
sun公司都被oracle公司收购了,安装jdk---下载? 官网 www.oracle.com

关于Java语言特点以及jdk,Jre,jvm的介绍

Java简单性,健壮性,分布式, (良好的移植性,开源)

JVM:Java Virtual Machine Java虚拟机
假象计算机,自己的网络,自己的内存区域等等;
Jre:Java Runtime Environment Java运行环境,所有的Java应用程序要运
行,计算机上必须有Java环境的支持,没有这个东西,运
行不了,而Jre里面包含了Jvm以及Java程序运行时所有需要的核心类库
Jdk:Java Development Kit :Java开发工具包,里面有很多的开发工具
 tools.jar包,里面有工具类(Arrays:数组工具类,Collections:集合工具
 类...),还包括了jre
三者的关系:Jdk > Jre > Jvm (整个介绍:其实只需要安装jdk即可!)

编写JAVA代码

//在jdk的bin里面新建.txt文件--->一定要显示后缀名(电脑上win10 
查看---隐藏的后缀名勾上)
//HelloWorld.txt
//Java的最基本单元是类: 
class 类名{ 类名:建议是和文件名称一致!
//main方法,程序的入口,能够被安装jdk-->jre--->jvm jvm能够识别这个
main方法,解析Java程序
//固定写法
public static void main(String[] args){
//输出在控制台上一句话:"helloworld"
//固定格式:输出语句
System.out.println("helloworld") ; //"",在控制台上就可以将双引号
的内容输出展示!
	}
}
//举例
class HelloWorld{
public static void main(String[] args){
System.out.println("helloworld") ;
	}
}

Java环境变量的配置path

方式1

1)将jdk的bin目录的路径复制
win10/win11--->此电脑--->右键----属性----->高级系统上设置---->环境
变量---->系统变量,不要在用户变量找path,在系统变量找path (用户变量,
一个计算机可以有多个用户)
path不要删除别的东西,别的东西都是系统配置,谨慎不要随意删除!
将1)里面jdk的bin目录的路径复制过来放在path里面,
D:\develop_software\Java\jdk1.8.0_162\bin
配置完成之后,打开dos窗口,在任何路径下都可以使用javac和java(c盘系统
盘,有的文件夹没有权限)
输入javac
java
java -version 都是有提示信息,说明可以用了

方式2

配置方式步骤
1)赋值jdk安装目录的路径,不是bin目录 D:\develop_software\Java\jdk1.8.0_162
2)此电脑---->右键---->选择属性---->高级系统设置---->环境变量---->系统变量
系统变量----->新建一个变量名: JAVA_HOME
变量值:就是1)的路径
3)在path里面 引入JAVA_HOME对应的变量值的路径
3 .Path环境变量的执行流程
无论使用第一种方式是还是第二种方式,在配置之前,如果你已经打开了dos窗口,
那么配置完成之后,要生效的话,必须将当前dos窗口关闭,重新进入dos窗口 (windows+r--->输入cmd,在进去)
4 .classpath(找你的字节码文件):临时环境变量(了解,不作为重
点)
path环境变量里面的最前面 %JAVA_HOME%\bin ,如果win10/win11 点击path,隔段形式,后面不用分号
如果是在一行上bin后面带上分号;
好处:以后jdk版本升级,需要改动path? 不需要,只需要改动JAVA_HOME变量值里面的路径

path环境变量的执行流程

1)首先肯定需要在指定目录中找对应的.java文件,
举例:如果.java文件是在D盘根目录下,肯定需要现在这个D盘里面 javac xx.java--->进行编译和运行
如果当前指定目录有这个java文件,直接编译和运行!
2)如果在当前这个指定目录找不到,它就会去系统变量path环境变量里面找 :
jdk安装目录的bin里面去找,如果这里面也没有,最终,提示----"找不到文件!

JAVA 注释

注释:在计算机编程语言为了提高代码阅读性,给某些代码进行标记文字提示,让程序阅读性更高一些,
作为中国人,肯定加入中文字符,但是一般习惯写注释,因为代码给人看的(人:程序员),接手别人的项目,它代码没有注释,
很难受!
注释:一行代码---标记了很多行注释,阅读性比较差!(简单标记)
Java中的注释的分类:
单行注释://书写内容
多行注释:/* 书写内容 */
前面两个普通注释:主要就是来标记代码,提高代码阅读性
文档注释: /** 书写内容 */ :特殊注释,可以被解析的

JAVA 中的关键字

Java的关键字:
被Java语言赋予特定含义的单词,叫关键字!
在高级记事本notepad++以及editplus记事本以及开发工具idea(以后用的这个)/eclipse等等
针对关键字有一种颜色标记
package:包名(文件夹/目录结构) :以后在开发中代码分包,分层的 (真实的意义:在面向对象部分讲解)
class:定义类的格式,Java中最基本单元就是类 固定格式 class 类名{}
public:权限修饰符 (公共的/公开的,任何人都可以访问的),访问权限足够大
注意事项:
goto/const这两个字 作为"保留字"去使用!

JAVA中的标识符

标识符:(起名字,"见名知意")
对包名,类名,接口名,变量名,方法名,常量名起名字的一个字符序列!
组成规则:
1)有0-9到数字组成
2)字母字符(26个字母)
3)$符号
$)_下划线
对包名(目录结构package) 起名字规范 (面向对象部分讲解 包的含义)
单级包:(字母都是小写) com包名
xx.java
多级包:包名和包名使用.隔开
com.qf
com下面会有一个qf文件夹
xx.java文件
对类名和接口名起名字是同样的:(遵循阿里规范:大驼峰命名法)
定义类的时候:如果类名是单个单词,首字母大写,其余小写
举例
class Hello{}
class Demo{}
如果类名它是多个单词组成,每个单词首字母大写,其余小写
举例:
class HelloWorld{}
class MakeNameDemo{}
class StartGame{}
对变量名和方法名起名字是相同 规范: (遵循小驼峰命名法)
如果变量名是一个单词,那么 单词的字母全部小写
举例: 定义价格
int price = 5;
如果变量名是多个单词,那么第一个单词字母小写,
8.常量
分类
从第二个单词开始,每个单词首字母大写 ,其余小写!
举例:
定义苹果价格
int applePrice = 7;
对常量起名字(以后看到java的源码里面常量的格式:使用的多个单词写的)
如果常量名,单个单词 ,字母全部大写
举例 HELLO
如果是多个单词,字母全部大写,单词和单词之间用下划线隔开!
jdk提供的Thread类 :线程
定义线程优先级三个常量:只看格式 (最小优先级,默认优先级,最大优先级)
public final static int MIN_PRIORITY = 1;
public final static int NORM_PRIORITY = 5;
public final static int MAX_PRIORITY = 10;

注意事项:
1)起名字,可以数字,但是不能以数字开头
2)Java严格区分大小写,一定要起名字见名知意
3)标识符不能是Java中的关键字

JAVA中的常量

常量在程序过程中,其值不发生改变的量

分类

字面值常量
1)字符串常量:使用英文的符号"" 双引号括起来的任何内容都是字符串
举例
"helloworld"
"今天天气不好,心情是绿色的!"
2)字符常量:使用英文的'' 单引号阔括起来的单个字符内容
'a' :字符小a
'A' : 字符大A
'0' : 字符0
不能'ab'---jvm在解析的时候,认为这个字符串,不是单个内容,解析错误!
如果字符不参与运算,就是字符本身!
如果字符参与运算的时候,此时 字符(键盘上的每一个按键都是字符)
它就会去找ANSI码表里面的字符对应的值,进行运算;
'a' --- 97
'A' --- 65
'0' --- 48
3)整数常量
100,97
4)小数常量
3.14
12.34
5)布尔常量: true/false
6)空常量: 一般不能直接输出null
在引用数据类型(后面讲数组的说),默认值是null
自定义常量 :跟一个关键字 Ũ nal(面向对象去讲!状态修饰符)

进制

进制也属于常量的范畴
 整数默认就是十进制,
进制的由来?
进制的转换
任意进制转成十进制
十进制转成任意进制
快速转换法:8421码
有符号位的数据表示法 (了解) (原,反,补码) 数据在计算机里面进行计算的时候,底层是"补码"进行计算,---转换成反码--->原
码(看到的是原码)
正整数+7
负整数-7

将任意进制转换成十进制

位权展开法:系数*基数的权次幂相加的结果

十进制转换成任意进制

使用当前十进制进行除基取余,直到除到商为0为止,余数进行反向排序

8421 快速转码

JAVA 变量

在程序过程中,其值发生改变的量;
学习Java编程语言,在Java中,如何定义变量?
变量的三要素
1)数据类型
2)变量名
3)初始化值

定义变量的方式

1)先定义,然后在赋初始化值
数据类型 变量名;
变量名 = 值; (在使用这个变量之前,必须赋值,否则编译报错!)
2)要么直接定义时候赋初始化值
数据类型 变量名 = 初始化值;

数据类型有哪些(牢记)

分为两大类
基本数据类型:
四类八种
1)整数类型: 有四种,默认int (讲课过程,没有明确类型都是int)
byte:字节类型 占1个字节 范围:-128~127(必须记住)
short:短整型 占2个字节
int(默认) 占4个字节
long:长整型 占8个字节
在定义long 的时候,规定,在初始化值加上L或者l
2)浮点类型:默认double
单精度类型ũ oat ,在定义ũ oat类型后面规定, 占4个字节
需要标记,在初始化值的后面加上F或者f
双精度类型duoble: 占8个字节
3)字符类型:
char: 里面的内容'字符' 占2个字节
4)布尔类型:开发中,逻辑判断的true还是false的结果
boolean 一般boolean不参与运算,只是表示true或者false 占1个字节
基本类型里面整数类型开发中:
用最多的int,其次long
(long类型定义时间毫秒值,后期通过常用类的功能,将系统时间得到时间毫秒值)

JAVA隐式类型转换

//变量计算的时候,byte,short,char三者之间不转换,参与运算优先提升int(考点)--->long--->float--->double
int a = 3 ;
byte b = 4 ;
int c = a + b ; //可以接收,b这个变量在进行操作的时候,先提升为int类型,然后和a进行求和!

强制类型转换

//显示转换:强转类型转换:就是将大的数据类型---转换成小的数据格式
//目标数据类型 变量名 = (目标数据类型)初始化值;
class DataTypeDemo{
public static void main(String[] args){
//定义两个变量
int a = 4 ;
byte b = 3 ;
//现在使用的接收类型是byte类型
//byte result = a + b ;//不兼容的类型: 从int转换到byte可能会有损失
//(byte,short,char三者之间不转换,一旦参与运算,优先提升int)
// =右边:int类型+byte类型的b,先要将byte类型提升int,结果int类型,
//=左边:byte类型, 无法存储int类型的结果
//目标数据类型 变量名 = (目标数据类型)(初始化在或者表达式);
byte result = (byte)(a+b) ;
System.out.println("结果是:"+result) ;
}
}

class DataTypeTest{
public static void main(String[] args){
//定义三个变量
byte b1 =3,b2 =4,b;
//b = b1 + b2;// 从int转换到byte可能会有损失
/*
b = b1 + b2; b1先提升int b2提升int 结果就是int类型的7,
但是b变量类型byte接收不了int类型结果,解决方案:使用强转类型转换
*/
//强转
//目标类型 变量名 = (目标类型)(初始化值或者表达式);
//b = (byte)(b1+b2) ;
//System.out.println("b的值是:"+b) ;
b = 3+4 ;//先相加,然后看计算的结果是否在接收类型范围内,
//在直接用,否则,需要处理!
System.out.println(b) ;
	}
}

算数运算符

*/
class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 3 ;
		int b = 4 ; 
		
		System.out.println("(a+b):"+(a+b)) ;
		System.out.println("(a-b):"+(a-b)) ;
		System.out.println("(a*b):"+(a*b)) ;
		System.out.println("(a/b):"+(a/b)) ;//默认取整
		System.out.println("(a/b):"+(a*1.0/b)) ;//结果出现小数
		System.out.println("(a%b):"+(a%b)) ;
		
		//计算机对小数计算(伪计算) 
		//除或减,结果可能是无限近似于某个值,不太精确!  
		//后面常量类,Java提供类BigDecimal:对小数可以进行精确计算!
		System.out.println(0.1/1.05) ;//0.09523809523809523
		
	}
}

扩展的算数运算符

/*
	扩展的算术运算符
	
		++或者--  
			
				1)场景--->统计场景(统计用户的登录次数,猜数字游戏,统计用户多少次猜中了)
				2)流程控制语句循环结构语句中---++或者--
				
		使用方式
			1)不参与运算,单独使用
					
					a)在数据的前面
					b)在数据的后面
			结论:
					无论++或者--在数据的前面还是后面,都是对当前数据进行自增1或者自减1
					
			2)参与运算		
					a)在数据的前面
			结论:
					++或者--在数据的前面,先进行增1或者自减1,然后参与运算!
					
					b)在数据的后面
					++或者--在数据的后面,先运算,然后进行自增1或者自减1 !
				
*/
class OperatorDemo2{
	
	public static void main(String[] args){
		
		//定义两个变量
		int a = 4 ;
		int b = 3 ;
		
		System.out.println("原数据是:") ;
		System.out.println("a:"+a+",b:"+b) ;
		System.out.println("--------------++或者--在数据的前面或者后面------------------") ;
		//++a ;
		//--b ;
		a++;
		b-- ;
		System.out.println("a:"+a+",b:"+b) ;
		
		System.out.println("------------------------------------------------" ) ;
		
		//定义两个变量
		int x = 3 ;
		int y = 6 ;
		System.out.println("x:"+x) ;
		System.out.println("y:"+y) ;
		
		//++或者--,参与运算,在数据的前面
		//int m = ++x ;
		//int n = --y ;
		
		//++或者--,参与运算,在数据的后面
		int m = x ++ ;
		int n = y -- ;
		System.out.println("x:"+x) ;
		System.out.println("y:"+y) ;
		System.out.println("m:"+m) ;
		System.out.println("n:"+n) ;
		
	}
}

赋值运算符

/*
	基本的赋值运算符:
			=
	举例:	
			int a = 10 ;
			将10这个数据赋值给int类型的变量a
		将等号的右边的值赋值给等号左边的变量!

	这个"="不能写成"=="  ,后者是比较,最终的结果无非true或者false	

	扩展的赋值运算符
		+=,-=,*-,/=,%=
		举例:
			int b =100 ;
			b += 200 ;   //  如果明确了具体的数据类型 (整数默认int) b = b+200;
			
			将这个扩展的赋值运算符的左边的变量和右边的数据值相加,在赋值给左边的变量
	
			
*/
class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义变量
		//int a == 10;//OperatorDemo.java:18: 错误: 需要';'
		
		int a = 10 ;//基本赋值运算符
		
		//扩展的赋值运算符
		a += 100 ;
		//a是int,结果是int
		System.out.println("a的值是:"+a) ;
	}
}

赋值运算符面试题

/*
	面试题:
			short s = 1 ;
			
			1)s = s + 1 ;
			2)s +=1;
			
			
			这个1),2)两段代码,哪一个会编译失败,哪一个成功,为什么?
		
			1)这个代码会编译报错,因为存在Java隐式类型转换
		
byte,shor char 三者不转换,一旦参与运算,优先提升为int,所以
s = s + 1 ;s先提升int和1相加,结果是int类型,而s类型short,无法接收int类型结果
			
			2)s +=1 ; 会成功,
			因为扩展赋值运算符+=,-=,*=,/=,%=,有一个特点:隐藏了强转类型转换
			
					s +=1 此时等价于s = (short)(s+1) ;

*/
class OperatorTest{
	
	public static void main(String[] args){
		short s = 1 ;
		//s = s+ 1;//从int转换到short可能会有损失
		s +=1 ;//此时等价于s = (short)(s+1) ;
		System.out.println(s) ;//2
		
		
	}
}

比较运算符

/*
	比较(关系)运算符
	
	<,>,<=,>=,==,!=
	
	注意事项:
		1)这些符号无论连接的表达式是简单的还是复杂的
		最终结果要么是true要么是false;
		
		2)==是比较,不能写成"=",否则编译报错
		
		
		== 是在基本数据类型用的,比较的是两个数据值是否相等!
		
*/
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>=b) ;
		System.out.println(a<=b) ;
		System.out.println(a==c) ;
		System.out.println(a!=c) ;
		
		System.out.println("-----------------------------------") ;
		int m = 100 ;
		int n = 200 ;
		//使用boolean变量接收
		boolean flag = m==n; 
		//boolean flag = m=n ;//int无法转换为boolean
		//将n的赋值m,然后将m的值赋值boolean的flag(不行)
		System.out.println("flag:"+flag) ;
		
	}
}

逻辑运算符

/*
	逻辑运算符,开发中,常用与逻辑判断!
	
	基本的逻辑运算符:
			逻辑单与&: (并列关系)
						有false,则false;多个并列条件必须同时满足才能成立,否则,不成立!
						
			逻辑单或|: 或的关系
						有true,则true,多个条件,有一个满足即可成立!
			逻辑异或^: 
					   相同则为false,不同则为true;
					  
					  简单记:男女关系					   
								男男 false
								女女 false
								男女  true
								女男  true
			逻辑非!:
					非true,则false,非false则true
					偶数个非是它本身
*/
class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义三个变量
		int a = 3 ;
		int b = 4 ;
		int c = 5 ;
		
		//逻辑单与&
		System.out.println((a>b) & (a>c)) ;//false & false = false ;
		System.out.println((a>b) & (a<c)) ;//false & true = false ;
		System.out.println((a<b) & (a>c)) ;//true & false = false ;
		System.out.println((a<b) & (a<c)) ;//true & true = true ;
		System.out.println("--------------------------------------------") ;
		
		//逻辑单或|
		System.out.println((a>b) | (a>c)) ;//false | false = false ;
		System.out.println((a>b) | (a<c)) ;//false | true = true ;
		System.out.println((a<b) | (a>c)) ;//true  | false = true ;
		System.out.println((a<b) | (a<c)) ;//true  | true = true ;
		
		System.out.println("--------------------------------------------") ;
		
		//逻辑异或^
		System.out.println((a>b) ^ (a>c)) ;//false ^ false = false ;
		System.out.println((a>b) ^ (a<c)) ;//false ^ true = true ;
		System.out.println((a<b) ^ (a>c)) ;//true  ^ false = true  ;
		System.out.println((a<b) ^ (a<c)) ;//true  ^ true = false ;
		
		System.out.println("--------------------------------------------") ;
		//逻辑非!
		System.out.println(!(a>b)) ;
		System.out.println(!!(a>b)) ;
		
		
	}
}

扩展逻辑运算符

/*
	扩展的逻辑运算符
			逻辑双与&& 和逻辑双或||
			
			逻辑双与&&:
				连接的表达式如果左边为false,则右边不执行(具有短路效果)
			逻辑双或||:
				连接的表达式如果左边为true,则右边不执行(具有短路效果)
			
			
	面试题:
			逻辑双与&&和逻辑单与&有什么区别?
			共同点:
					无论是逻辑单与&还是逻辑双与&&都是表达并列关系,
					而且都是有fasle则false!
					
			不同点:
					
					逻辑单与&,对多个并列条件在执行的时候,效率比较低,因为都
					需要将这个符号左边的表达式和右边的表达式都需要执行一遍!
					
					逻辑双与&& ,
						连接的表达式如果左边为false,则右边不执行(具有短路效果)
						开发中扩展的逻辑运算符,代替基本的运算符,执行效率高!
*/
class OperatorDemo2{
	
	public static void main(String[] args){
		
		//定义三个变量
		int a = 3 ;
		int b = 4 ;
		int c = 5 ;
	
		//逻辑双与&& 满足基本特点:有false,则false
		System.out.println((a>b) && (a>c)) ;//false && false = false ;
		System.out.println((a>b) && (a<c)) ;//false && true = false ;
		System.out.println((a<b) && (a>c)) ;//true && false = false ;
		System.out.println((a<b) && (a<c)) ;//true && true = true ;
		
		System.out.println("-----------------------------------------------------") ;
		//定义两个变量 
		int x  = 3 ;
		int y  = 4 ;
		System.out.println("x:"+x) ;
		System.out.println("y:"+y) ;
		System.out.println("-----------------------------------------------------") ;
		
		//逻辑单与&
		//System.out.println(((++x)==3) & ((--y)==4)) ;//false
		//System.out.println("x:"+x) ;//4
		//System.out.println("y:"+y) ;//3	
		
		//逻辑双与&&
		System.out.println(((++x)==3) && ((--y)==4)) ;//false
		System.out.println("x:"+x) ;
		System.out.println("y:"+y) ;	
		
	}
}

三元运算符

/*
	三元运算符(三目运算符)
	
	格式:
			(表达式)?执行true的结果:执行false的结果;
			
	执行流程:
			表达式可以简单可以复杂,如果结果是true成立,则执行成立的结果
			否则不成立,则执行false的结果
			
	需求:
			定义变量,求两个变量最大值(没有提示,都是int类型)
			三个数据比较最大值?
*/
class OperatorDemo{
	public static void main(String[] args){
		
		//定义两个
		int a = 10 ;
		int b = 5 ;
		
		//套用格式
		//(表达式)?执行true的结果:执行false的结果;
		//定义变量max
		int max = (a>b)?a:b ;
		System.out.println("两个数据中的最大值是:"+max) ;
		
		System.out.println("---------------------------------------") ;

		//定义三个变量
		int x = 20 ;
		int y = 50 ;
		int z = 30 ;
		
		//方式1:使用中间变量的方式 (推荐)
		//使用中间变量的方式记录一下x和y的最大值
		int temp = (x>y)? x:y;
		//使用中间变量的结果和z进行比较
		int max2 = (temp > z)? temp : z ;
		System.out.println("三个数据中的最大值是:"+max2) ;
		
		System.out.println("---------------------------------------") ;
		
		//方式2:不建议(使用括号标记,格式好看,否则没有括号,不好看)三元运算符的嵌套
		int max3 = (x>y)?((x>z)?x:z):((y>z)?y:z) ;
		//int max3 = x>y?x>z?x:z:y>z?y:z ; //不带括号,阅读性很差
		System.out.println("三个数据中的最大值是:"+max3) ;
			
		
	}
}

位运算符

基本的位运算符号:
位与&
位或|
位异或^
反码~
移位符号:
<< 左移 结论
>> 右移 结论
>>> 无符号右移

/*
	位运算符:
			这对具体的数据进行计算的
			
			基本位运算符号:
					位与&  :
									有0则0
						
					位或|  :		有1则1
					位异或^:		相同则为0,不同则为1
								
					反码~  :
							对这个数据全部按位取反  (0变1,1变0)
					
*/
class OperatorDemo{
	
	public static void main(String[] args){
		
		System.out.println(3 & 4) ; //3位与 4			0
		System.out.println(3 | 4) ; //3 位或4			7
		System.out.println(3 ^ 4) ; //3 位异或 4		7
		System.out.println(~3) ;  //反码3				-4
		
	}
}
/*
	位与& :
			有0则0
	
		整数默认int
	      
		00000000 00000000 00000000  00000011          3的原码,反码,补码
	位与&	
		00000000 00000000 00000000  00000100		  4的原码,反码,补码
		
		-----------------------------------------
		00000000 00000000 00000000 000000000
		
		
	位或|: 
		有1则1
		      
		00000000 00000000 00000000  00000011          3的原码,反码,补码
	位与|
		00000000 00000000 00000000  00000100		  4的原码,反码,补码
		-----------------------------------------------------------------
		00000000 00000000 00000000 000000111  				7
		
		
		
		位异或^: 
				相同则为0,不同则为1
		   
		      
		00000000 00000000 00000000  00000011          3的原码,反码,补码
	位异或^
		00000000 00000000 00000000  00000100		  4的原码,反码,补码
		-----------------------------------------------------------------
		00000000 00000000 00000000 000000111			7
		
		
	反码~:全部数据按位取反,0变1,1变0(不管最高符号位)
	
	~3  
	
	00000000 00000000 00000000  00000011     原码,反码,补码
	
	~
	--------------------------------------
	11111111 11111111 11111111  11111100       补码 ---->反码---->原码
	
	
	
	最高符号位   		数值位    
	1				1111111 11111111 11111111  11111100  	补码
	   
	-											      1
	-----------------------------------------------------------
	1               1111111 11111111 11111111  11111011      反码
	---------------------------------------------------------------
	1				0000000 00000000 00000000 000000100		-4
	
*/

/*
	位运算符里面的移位符号的特点
	
			<<:左移	
					将这个数据补码---进行左移,
						多余的位数(最高位)丢弃掉,在右边补0
					
						结论: 使用<<符号左边的数据乘以2的移动次幂
				
			
			>>:右移
					将数据补码进行右移,最高位是1,左边补1,如果最高位是0,左边补0,多余的位数丢弃掉
						结论:将>>左边的数据除以2的移动次幂
			
			>>>:无符号右移
					将数据的补码进行右移,将多余的丢弃掉,无论最高符号位是1还是0,左边永远是补0

*/

class OperatorDemo2{
	
	public static void main(String[] args){
		
		System.out.println(3 << 2) ;		//3*2^2
		
		System.out.println( 24 >>2) ;		//24/2^2 = 6
		
		System.out.println( -24 >>2) ;      //  -6
		
		System.out.println(-24>>>2) ;  //1,073,741,818
 	}
}

/*

	  默认int类型 4个字节    
	  3的原码,反码,补码相同
	  00000000	00000000	00000000 00000011 
	  
3<<2 	  
  (00)000000  00000000	  00000000 00000011  	
	最高符号位
	0  0000000   000000	00 00000000 00001100  12
	
24 >>2 

	24的原码,反码,补码
	
	00000000 00000000 00000000 00011000    
	  0000000000 00000000 00000000 000110    (00) 
	  
	  
	  00000000    00000000 00000000 00000110      		6
	  
	  
	  
	 -24>>2
	 最高符号位		数值位
	 1				0000000 00000000 00000000 00011000 
	 
	 原码---->反码---->补码 ---使用补码移动
	 10000000 00000000 00000000 00011000   原码
	 11111111 11111111 11111111	11100111   反码
	+								   1
----------------------------------------------
	 11111111 11111111 11111111	11101000  补码
	   1111111111 11111111 11111111	111010  (00)
	 移动之后的补码--->反码----原码 
	最高符号位 	数值位
	 1			111111111 11111111 11111111	111010   补码
	 -											 1
---------------------------------------------------------
	 1			111111111 11111111 11111111	111001  反码
	 
	 1          0000000  00000000 00000000 00000110  原码
	 -										6
	 
	 
	-24>>>2 
	10000000 00000000 00000000 00011000   原码
	 11111111 11111111 11111111	11100111   反码
	+								   1
----------------------------------------------
	 11111111 11111111 11111111	11101000  补码
	 
	 
	 11111111 11111111 11111111	11101000
	   0011111111 11111111 11111111	111010 (00)
	   
	    00111111111111111111111111111010 补码---反码---原码
*/

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

*/
class OperatorDemo3{
		public static void main(String[] args){
			
				//定义两个变量
				int a = 10 ;
				int b = 20 ;
				
				System.out.println(a ^ b ^ b) ; //10
			
		}
	
}
/*

	10的原码,反码,补码
	00000000  00000000 00000000  00001010
	20的原码,反码,补码
	00000000  00000000 00000000  00010100
	
	
	00000000  00000000 00000000  00001010
	位异或^
	00000000  00000000 00000000  00010100
	--------------------------------------------
	00000000  00000000 00000000  00011110 
	位异或^
	00000000  00000000 00000000  00010100
	----------------------------------------
	00000000  00000000 00000000  00001010
*/

键盘录入

/*
	为了进行数据逻辑判断操作的时候,程序更灵活一些
	Jdk提供了类供我们使用----->文本扫描器   java.util.Scanner类
在Java中,只要我们用的其他类,只要不是java.lang.xxx类都需要导包
							java.lang.String
							java.lang.Integer
							java.lang.Math
							.....


	使用步骤:
			1)导包  :位置是在class的上面 
			import java.util.Scanner ;  //用谁导谁
			
			2)创建文本扫描器 	----java中的关键字 new  创建对象(具体在面向对象中讲)
					
					Scanenr 变量名(称为"键盘录入对象名") = new Scanner(System.in) ;  固定格式 变量名 ,自己起名字
					
			3)友情提示 "请输入一个数据:"

			4)通过文本扫描器录入数据  (整数默认int)		
					    使用2)的
								
			int  结果变量名= 	变量名.nextInt() ; //.nextInt() :调用文本扫描器的提供功能,录入int类型

			5)使用这个结果变量名来进行操作
			
			
			
			
*/

//1)导包
import java.util.Scanner ;
class ScannerDemo{
	
	public static void main(String[] args){
		
		//2)创建文本扫描器(创建Scanner类对象) 固定写法,变量名自己起
		Scanner sc = new Scanner(System.in) ;
		
		//3)友情提示
		System.out.println("请您输入一个数据(int):") ;
		
		//4)录入int类型数据
		int result = sc.nextInt() ;  //.nextInt() :调用文本扫描器的提供功能 (固定写法)
		
		//5)输出或者使用
		//使用这个结果变量完成其他逻辑操作
		System.out.println("录入的数据是:"+result);
		
		
	
		
		
	}
}

流程控制语句

/*

	流程控制语句
		顺序结构语句 :比较简单,所有程序都是通过jvm调用main进行的(入口)
					代码由上而下依次加载,除非在加载后面代码之前,jvm退出了!
					
					
		选择结构语句
				if
				switch
		循环结构语句
				for
				while
				dowhile
*/

class OrderDemo{
	
	public static void main(String[] args){
		
		//代码由上而下依次加载
		System.out.println("程序开始了...") ;
		
		System.out.println("helloworld") ;
		
		System.out.println("程序结束了....") ;
		
		//jdk提供了System类有一个功能,exit(0),参数为0,正常终止jvm
		System.exit(0) ;//固定格式先记住:可以终止jvm
		
		System.out.println("over") ;
	}
	
}

流程控制语句之if语句1:

/*
	选择结构语句之if
		格式1:
				if(表达式){
					语句;
				}
				
				场景:针对单个情况进行判断
				
				
		格式2:
				if(表达式){
					语句1;
				}else{
					语句2;
				}
				场景:针对两种情况进行判断
		格式3:
				if(表达式1){
					语句1;
				}else if(表达式2){
					语句2;
					...
					...
					...
				}else{
					
					语句n;
				}
				
				场景:针对多情况进行判断
				
				
上面格式1的流程:

		//格式1:{}里面单条语句,可以省略,但是前期不建议
		if(表达式){		  
			语句;
		}
		
		表达式是否成立,成立,则执行语句;
		否则,不执行
						
*/
//导包
import java.util.Scanner ;
class IfDemo{
		
		
		public static void main(String[] args){
				
				//创建键盘录入对象
				Scanner sc = new Scanner(System.in) ;
				
				//提示
				System.out.println("请输入一个数据x的值:") ;
				int x = sc.nextInt() ;
				
				//格式1
				if(x>=10){
					System.out.println("x的值是:"+x);
				}
				System.out.println("over") ;
				
		}
}

流程控制语句之if语句2

/*
使用格式2:完成简单模拟"登录"
提示:
String:Java中的类,代表字符串 (后面常用类里面说)
字符串进行比较: String类的 字符串值1.equals(字符串值2) ,
是比较字符串内容是否相同
已知:
String username = "admin" ; 用户名
String password = "123456" ; 密码
键盘录入用户名和密码和已知的用户名和密码都已知,才能提示"登录成功",
否则"用户名或者密码错误"
*/
//导包
import java.util.Scanner;
class IfTest{
public static void main(String[] args){
//已知
6.if语句格式3
//用户名
String username = "admin" ;
//密码
String password = "123456" ; 
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入用户名:") ; //用户名录入的字符串
// 键盘录入对象名.nextLine() 固定写法
String inputUserName = sc.nextLine() ;
System.out.println("请您输入密码:") ; //用户名录入的字符串
// 键盘录入对象名.nextLine() 固定写法
String inputPwd = sc.nextLine() ;
//if格式2 使用它完成逻辑判断
/*
字符串进行比较: String类的 字符串值1.equals(字符串值2) ,
是比较字符串内容是否相同
*/
//录入的用户名和已知的存在的用户名对比,如果一致,并且录入的密码和已知的密码一致,登录成功
if(inputUserName.equals(username) && inputPwd.equals(password)){
System.out.println("恭喜您,登录成功") ;
}else{
System.out.println("对不起,用户名或者密码输入错误!") ;
		}
	}
}

if语句格式3

/*
if语句格式3
格式3:
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n;
}
场景:针对多情况进行判断
执行流程:
首先,判断表达式1是否成立,成立,则执行语句1;
否则,不成立,继续判断表达式2是否成立,成立,执行语句2;
否则,不错成立...依次判断
....
....
如果上面都没有匹配的结果, 执行else中的语句n;
没有提示数据类型,都是int
需求
键盘录入学生成绩(满分100分),判断该学生成绩的等级的划分
90-100 "优秀"
80-90 "较优"
70-80 "良好"
60-70 "及格"
60以下 "不及格"
*/
//导包
import java.util.Scanner;
class IfDemo3{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入的学生的成绩: ") ;
int socre = sc.nextInt() ;
/*
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n;
}
*/
/*
if(socre>=90 && socre<=100){
System.out.println("优秀") ;
}else if(socre>=80 && socre<90){
System.out.println("较优") ;
}else if(socre>=70 && socre<80){
System.out.println("良好") ;
}else if(socre>=60 && socre<70){
System.out.println("及格") ;
}else{
System.out.println("不及格") ;
}
*/
//测试程序:
//测试正确数据:正常范围内的数据
//测试边界数据:边界数据的是否在我们指定范围内
//测试错误数据:超了范围,不满足,应该也要包含进去
if(socre<0 || socre>100){
System.out.println("您输入的数据有误!") ;
}else if(socre>=90 && socre<=100){
System.out.println("优秀") ;
}else if(socre>=80 && socre<90){
System.out.println("较优") ;
}else if(socre>=70 && socre<80){
System.out.println("良好") ;
}else if(socre>=60 && socre<70){
System.out.println("及格") ;
}else{
System.out.println("不及格") ;
}
}
}