文章介绍了Java语言中的基本数据类型，包括变量、常量、运算符和流程控制语句的使用。详细讲解了变量的声明、数据类型的转换，如隐式转换和强转，以及算术、关系、逻辑运算符的运用。此外，还涉及到了键盘输入、位运算符和流程控制结构如if-else。内容覆盖了Java编程的基础知识。
一周的学习基础有:变量,常量,标识符,关键字,运算符,流程控制语句.
常量
/*
什么是常量?
在程序过程中,其值不发生改变的量!(固定值)
分类:
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:状态修饰符(最终的,无法更改的)
*/
classConstantDemo{
publicstaticvoidmain(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) ;//报错的
//定义一个字符串
Stringabc="高圆圆" ;
System.out.println(abc) ;
abc=null ;//重新赋值
System.out.println(abc) ;
}
}
//打印出
//0B100对应的十进制
//0100(八进制)对应的十进制
//100:整数:默认就是十进制
//0x100(0x表示的十六进制) 对应的十进制
//进制就是常量
classConstantDemo2{
publicstaticvoidmain(Stringargs[]){
System.out.println(0100) ;//八进制---64
System.out.println(0b100) ;//二进制---4
System.out.println(100) ;//十进制 默认十进制
System.out.println(0x100) ;//十六进制---256
}
}
变量
什么是变量
/*
什么是变量?
变量:在程序的执行过程中,其值发生改变的量!
定义变量的三要素:
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)引用数据类型 :下周讲
数组,类,接口
*/
classDataTypeDemo{
publicstaticvoidmain(String[] args){
//定义一个byte类型变量
byteb=100 ;
b=120 ;
System.out.println("b:"+b) ; // "b:120"
System.out.println("-------------------------") ;
//短整型short
shorts=120 ;
s=150 ;
System.out.println("s:"+s) ;
System.out.println("-------------------------") ;
//int类型
inti=10000 ;
System.out.println("i:"+i) ;
System.out.println("-------------------------") ;
//int ii = 100000000000000;//过大的整数,int类型不能接收,使用长整型long
//整数默认int,在定义long类型,在初始化值的后面加上标记 L或者l(推荐L)
longii=100000000000000L;
System.out.println("ii:"+ii) ;
System.out.println("-------------------------") ;
//浮点类型:
//float/double:默认double
doubled=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
floatf=3.14f;//定义就是单精度类型
System.out.println("f:"+f) ;
System.out.println("-------------------------") ;
//字符char
charch='我' ;
charch2='a' ;
ch2='A' ;
System.out.println("ch:"+ch) ;
System.out.println("ch2:"+ch2) ;
System.out.println("-------------------------") ;
//布尔类型 boolean
booleanflag=true ; //后端语言使用逻辑语句进行处理:
//登录:必须满足用户名和密码都和数据库中一致,才能登录!
flag =false ;
System.out.println("flag:"+flag) ;
}
}
变量定义的注意事项
/*
定义变量的注意事项:
1)Java语言是一个"强类型"语言,它的语法结构非常严谨,不能重复定义变量
而前端语言:javascript:弱类型语言,是可以重复定义变量;
2)java语言中的所有语句结束了就必须带";"分号
3)定义变量代码书写格式:(代码风格)
建议:一行一个变量,不要所有变量都写在一行上
4)定义变量,但是在使用之前没有初始化,就会报错,系统认为这个变量没值!(仅仅适用于局部变量)
局部变量:在方法(函数)中定义的变量,都是局部变量,必须使用之前给值!
*/
classDataTypeDemo2{
publicstaticvoidmain(String[] args){
//定义一个int类型的变量
intx=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 ;
//一行同时定义多个变量
intm, 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) ;
}
}
隐式转换
/*
需求:
int a = 3 ;
byte b = 4 ;
变量和变量b求和的结果是什么?结果的数据类型是什么?
Java语言中,变量相加,必须保证数据类型一致才能进行运算!
Java的一种隐式转换(默认类型提升) (重点)
针对byte,short,char三者之间 不转换,一旦自己参与运算的时候,
优先提升为int(考点)--->long--->float--->double
boolean类型不会参与任何转换!
*/
classDataTypeDemo3{
publicstaticvoidmain(String[] args){
//定义两个变量
int a=3 ;
byteb=4 ;
//System.out.println(3+4) ;
//如果此时接收a+b的结果类型如果是int类型
intresult=a+b ; //a + b---->提升int类型才能进行计算!
System.out.println("result:"+result) ;
}
}
强制转换
/*
Java强转类型转换("强转")(显示转换):目的将大的数据类型转换成小的数据类型
语法格式:这个格式不仅仅适用于基本类型,也适用于引用数据类型!
目标数据类型 变量名 = (目标数据类型)(初始化值);
举例:
byte result = a + b ; //
优化为
byte result= (byte)(a+b);
*/
classDataTypeDemo4{
publicstaticvoidmain(String[] args){
//定义两个变量
inta=3 ;
byteb=4 ;
//两个变量进行相加
//接收结果变量是byte类型
//byte result = a + b ;//DataTypeDemo4.java:14: 错误: 不兼容的类型: 从int转换到byte可能会有损失
//上面出现错误的原因:
//等号右边: a+b--->byte类型的b参与运算,优先提升为int,相加后的结果int类型的7
//等号左边:字节类型 byte:占1个字节,不能接收4个字节的结果
//必须使用强转类型转换才能接收
//目标数据类型 变量名 = (目标数据类型)初始化值;
byteresult= (byte)(a+b);
System.out.println("result:"+result) ;
}
}
//看程序,写结果
classDataTypeTest{
publicstaticvoidmain(String[] args){
System.out.println("hello"+'a'+1) ; //"hello +'a' ="helloa"+1="helloa1"
System.out.println('a'+1+"hello") ;//'a'+1 = 98 + "hello" = "98hello"
System.out.println("5+5="+5+5) ; //"5+5="+5 = "5+5=5" + 5 = "5+5=55"
System.out.println(5+5+"=5+5") ; //5+5 =10 + "=5+5" = "10=5+5"
}
}
day_笔记
计算机基础
计算机概念
俗称"电脑",没有任何软件的计算机 "裸机"!
计算机的分类:
台式计算机,笔记本,大型计算机(公司的机房)
计算机的用途
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同一个公司的)
人机交互
人和计算机之间沟通一种方式:
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安装目录的文件夹以及文件的介绍
9. Java系统环境的配置path(重点)
为什么要配置系统环境变量?
如果不配置系统环境变量,永远只能在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
这个路径去寻找是否存在,如果存在,就编译,如果也不存在,那么说明系统中不存在这个文件 "找不到文件!"
10.classpath(了解)
临时环境变量
此电脑--->右键属性---->高级系统设置---->环境变量----->系统变量
新建一个变量名:classpath
变量值:要指定的那个class文件(字节码)的路径
配置完毕之后,在java 字节码文件前缀的时候---运行这个类的时候,始终是在classpath临时环境变量去执行对应.cass文件,如果这个路径中没有class字节码文件,提示"找不到主类"!
11.关键字
/*
什么是关键字?
关键字:被赋予特定含义的单词!
在高级记事本notepad++或者editPlus,以及开发工具idea针对关键字都有
一种特殊颜色标记!
class:Java语言中定义类的格式! (面向对象部分去讲)
public:权限修饰符号 (公开的/公共的,任何人都可以访问的,访问权限足够大)
static:静态修饰符号(在面向对象部分去讲)
void:和Java语言中定义方法(函数)一种格式 (方法的时候讲!)
注意事项:
1)组成关键字的字母全部都是小写,而且特殊含义的!
2)goto 和const不作为关键字,保留字使用!
*/
classKeyWord{
publicstaticvoidmain(String[] args){
System.out.println("被Java语言赋予特定含义的单词!") ;
}
}
12.标识符
/*
什么是Java中的标识符?
在Java语言中,给包,类名,接口名,方法名,变量名,常量等等起名字一种"字符序列";
起名字---做到四个字 "见名知意!"
包(文件夹/目录)---关键字 package(面向对象中讲,分包)
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; 最大优先级
*/
classMakeNameDemo{
publicstaticvoidmain(String[] args){
}
}
/*标识符命名规则:
(1)可以是26个字母大小写
(2)可以是数字
(3)可以是下划线_
(4)可以是$符
(5)不能以数字开头
不能是关键字
*/
day4笔记
变量的面试题
/*
面试题:
byte b = 300 ;
会出现什么情况?如何解决?计算结果分析
*/
classDataTypeDemo2{
publicstaticvoidmain(String[] args){
//定义变量
//byte b = 300 ;
//byte类型的取值范围-128-127;已经超出了范围,默认int类型
//解决方案:强转
//目标类型 变量名 = (目标类型)(初始化值或者表达式) ;
byteb= (byte)300;
//System.out.println(b) ;
//double x = 1.1/0.0 ;
System.out.println(x) ;
}
}
/*
300---默认int类型 4个字节
最高符号位 数值位
0 0000000 00000000 00000001 00101100 原码,反码,补码
计算机底层是补码进行数据的计算
byte b = (byte)300;
(0 0000000 00000000 00000001) 00101100
截取之后:就是00101100---补码--反码--原码 44
*/
/*
面试题:
byte b1 =10,b2=20,b;
1)b = b1+b2;
2)b = 10+20;//常量相加
上面1)和2)哪句编译失败呢?为什么
2)不会有问题
基本类型数据:
变量操作和常量操作
常量相加:先相加,然后看结果是否在前面接收类型的范围内,如果在,可以用,如果不在范围内,考虑类型转换!
*/
classDataTypeDemo{
publicstaticvoidmain(String[] args){
//定义三个变量
byteb1=10,b2=20,b;
//b = b1 + b2 ;
//java隐式类型转换:byte,short,char三者之间不转换,一旦参与运算,先提升为int---long--float--double
//b1--先提升为int类型的10
//b2--先提升为int类型的10
//=号右边 结果是int类型 4个字节
//=号左边 byte类型 无法接收4个字节数据,编译报错!
//解决方案:必须强转类型转换
//目标类型 变量名 = (目标类型)(初始化值/表达式) ;
b= (byte)(b1+b2) ;
System.out.println(b) ;
System.out.println("-----------------------------------") ;
//2)句
//b = 10 + 20 ;
//System.out.println(b) ;
}
}
classDemo{
publicstaticvoidmain(String[] args){
inta=10 ;
//a = null ; //a基本类型,不能直接基本类型null(null是用在引用类型)
System.out.println(a) ;
//jdk提供的Integer是int类型的包装类类型
Integeri=null ;
System.out.println(i) ;
}
}
算术运算符
/*
运算符:就是程序中的操作符号
算术运算符
赋值运算符
关系(比较)运算符
逻辑运算符
三目运算符
扩展:位运算符
算术运算符:
基本算术运算符: +,-,*,/,%
注意:
/:默认取整 (java是强类型语言,弱类型javascript前端语言不会默认取整)
%:模:求余数
扩展的算术运算符:++和-- (使用比较多的)
*/
classOperatorDemo{
publicstaticvoidmain(String[] args){
//定义变量a,b
inta=3 ;
intb=4 ;
System.out.println("a+b:"+(a+b)) ;
System.out.println("a-b:"+(a-b)) ;
System.out.println("a*b:"+(a*b)) ;
//3/4 可以在分母上*1.0
System.out.println("a/b:"+(a*1.0)/b) ;
System.out.println("a/b:"+(a/b)) ;
System.out.println("a%b:"+(a%b)) ;
System.out.println("-------------------------------") ;
//小数计算 - 或者/ 计算机计算的时候,"伪计算"
//jdk提供一个类(后面讲这个常用类:BigDecimal 会对小数进行精确计算!)
//System.out.println(1.01/0.4) ;
}
}
/*
扩展的算术运算符:++和-- (使用比较多的)
两种用法:
1)单独使用----流程语句中--循环语句使用居多
++或者--在数据的前面:
++或者--在数据的后面:
结论:无论在数据的前面还是数据的后面:都是自增1或者自减1
2)参与运算使用
++或者--在数据的前面:
先进行自增或者自减,然后参与运算
++或者--在数据的后面:
先运算,然后当前变量本身自增或者自减
*/
classOperatorDemo2{
publicstaticvoidmain(String[] args){
//定义两个变量
intx=3 ;
inty=4 ;
System.out.println("x:"+x) ;//x:3
System.out.println("y:"+y) ;//y:4
System.out.println("----------------------------") ;
//1)单独使用
//++或者--在数据的前面
//++ x ;
//-- y ;
//++或者--在数据的后面
//x ++ ;
//y -- ;
//2)参与运算使用
//如果++或者--在数据的前面
//定义两个变量同时赋值
//int m = ++ x ;//先自增,赋值给m,m就是4
//int n = -- y ;//先自减,赋值给n,n就是3
//如果++或者--在数据的后面
intm=x++ ;//将x的值赋值给m =3, x的值本身还在内存中自增1 -->4
intn=y-- ;//将y的值赋值给n =4, y的值本身在内存中还要自减1--->3
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("m:"+m) ;
System.out.println("n:"+n) ;
}
}
/*
看程序,写结果
1) int a = 10;
int b = 10;
int c = 10;
a = b++; //a=10,b=11 c=10
c = --a; //a=9, b=11,c=9
b = ++a; //a=10,b=10, c=9
a = c--; //a=9, b=10,c=8
//请分别计算出a,b,c的值
2:比较复杂的题目
int x = 4; //x=4 -->5---6
int y = (x++)+(++x)+(x*10);
//y= 4 + 6 + 60
=70
*/
classOperatorTest{
publicstaticvoidmain(String[] args){
inta=10;
intb=10;
intc=10;
a=b++; //a=10,b=11 c=10
c=--a; //a=9, b=11,c=9
b=++a; //a=10,b=10, c=9
a=c--; //a=9, b=10,c=8
System.out.println("a:"+a+",b:"+b+",c:"+c) ;
System.out.println("-----------------------------") ;
intx=4; //x=4 -->5---6
inty= (x++)+(++x)+(x*10);
//y= 4 + 6 + 60
//y =70
System.out.println("x:"+x+",y:"+y) ;
}
}
赋值运算符
/*
基本的赋值运算符:=
将=号右边的值赋值给左边指定类型的变量
举例:
int x = 10 ;
将10赋值给int类型的变量x
注意:
=不能写成==,==不能写成= (==是比较运算符)
扩展的赋值运算符
+=,-=,*=,/=,%= :将等号右边的数据和左边的变量值操作,在赋值给左边的变量
举例:
int x = 10 ;
x += 20 ;----->等价于 x = x + 20 ;(前提条件:类型相同)
将=等号左边的变量和右边的值相加在赋值给左边的变量x
*/
classOperatorDemo{
publicstaticvoidmain(String[] args){
//定义一个变量
intx=10 ; //将10给int类型变量x
//int y == 20 ; //==是比较运算符,y是没有值的;
System.out.println("x:"+x) ;
System.out.println("----------------------------------") ;
//定义一个变量m
intm=100 ;
m+=200 ; //等价于 m = m + 200 ;
System.out.println("m:"+m) ;
}
}
/*
面试题:
已知变量 s
short s = 1 ;
1)s = s + 1;
2)s += 1 ;
1)和2)两个代码哪一句会编译失败?为什么?如果失败,怎么解决
哪一句编译成功,为什么?
1)句代码会编译失败
short s = 1;
s= s+1 ;//byte,short,char,之间不转换,参与运算优先提示int,而=号左边
是一个short,无法接收int类型的结果
解决方案:
强转类型转换: s = (short)(s+1) ;
2)会成功
扩展的赋值运算符:
+=,-=,*=./=,%=隐藏了强转类型转换
short s = 1 ;
s+=1 ; ----->等价于 s = (short)(s+1) ;
*/
classOperatorTest{
publicstaticvoidmain(String[] args){
shorts=1 ;
//s = s +1 ;
//目标类型 变量名 = (目标类型)(初始化值或者表达式) ;
// s = (short)(s+1) ;
s+=1;
System.out.println(s) ;
}
}
关系比较运算符
/*
关系(比较)运算符(最简单一种运算符)
<,>,<=,>=,==,!=
这些符号连接的表达式无论简单还是复杂的结果都是boolean值!
==:在基本数据类型中,比较两个数据值是否相等
注意事项:
==不能写成 "="
数学表达式
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提供给我们 "文本扫描器"
可以键盘录入数据,让程序灵活一些
键盘录入数据的操作步骤:
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 ScannerDemo{
public static void main(String[] args){
//2)创建文本扫描器对象
Scanner sc = new Scanner(System.in) ;
//3)提示并录入数据(没有提示类型,默认录入int)
System.out.println("请您输入一个数据:") ;
int a = sc.nextInt() ;
//4)使用变量a
System.out.println("a的值是:"+a) ;
}
}
//(没有明确要求数据类型默认int)
//键盘录入两个int类型的数据,求两个变量的最大值
//键盘录入两个数据,比较两个数据是否相等
//键盘录入三个数据,比较三个数据中的最大值;
//1)导包
import java.util.Scanner ;
class Test{
public static void main(String[] args){
//2)创建文本扫描器对象
Scanner sc = new Scanner(System.in) ;
//3)提示并录入数据(int)
System.out.println("请您输入第一个数据:") ;
int a = sc.nextInt() ;
System.out.println("请您输入第二个数据:") ;
int b = sc.nextInt() ;
//4)比较两个数据中的最大值
int max = (a>b)?a:b;
System.out.println("最大值是:"+max) ;
}
}
day5
位运算符
/*
扩展(了解概念)
位运算符:它是针对数据直接进行运算的!
基本的位运算符:
位与&:有0,则0
位或|:有1,则1
位异或^:相同则为0,不同则为1
反码~:所有的二进制位全部按位取反,0变1,1变0
面试题:(考点移位符号)
请用有效的方式计算出2*8的结果
*/
classOperatorDemo{
publicstaticvoidmain(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
*/
移位运算符
/*
位运算符里面的移位符号(扩展)
<<(左移):
将"<<"左边的数据向左移动指定的位数(补码进行移动),
将高位丢弃掉,空位补0
结论:将"<<"左边的数据乘以2的移动次幂
>>(右移):
将">>"左边的数据使用补码向右移动,如果最高符位是0,左边补0;
如果最高符号位是1,左边补1;
结论:将">>"左边的数据除以2的移动次幂
>>>(无符号右移):
将">>>"左边的数据使用补码向右移动,无论最高符号位是1
还是0,永远左边空位补0;
*/
classOperatorDemo2{
publicstaticvoidmain(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) ;
}
}
/*
整数默认int
3的原码-反码--补码相同
00000000 00000000 00000000 00000011
(00)000000 00000000 00000000 0000001100
00000000 00000000 00000000 00001100(补码---反码---原码)
24 >> 2
24的原码,反码,补码相同
00000000 00000000 00000000 00011000
0000000000 00000000 00000000 000110(00)
00000000 00000000 00000000 00000110 ---补码--反码---原码
6
-24 >> 2
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 000000000 00000000 00000000 000110 原码
- 6
-24>>>2
11111111 11111111 11111111 11101000 补码
0011111111 11111111 11111111 111010 (00) 补码--反码---原码
*/
位异或特点
/*
位异或^特点
一个数据被另一个数据位异或^两次,其值是它本身
*/
classOperatorDemo3{
publicstaticvoidmain(String[] args){
inta=10 ;
intb=20 ;
System.out.pritnln( a^b^b) ;
}
}
/*
位异或^概念:
相同则为0,不同则为1
a ^ b
00000000 00000000 00000000 00001010 --原码,反码,补码
00000000 00000000 00000000 00010100 --原码,反码,补码
------------------------------------------
00000000 00000000 00000000 00011110 --补码--反码---原码
00000000 00000000 00000000 00010100
-----------------------------------
00000000 00000000 00000000 00001010 10
*/
两个变量交换
/*
请实现两个变量数据交互(思考)
举例:
int a = 10 ;
int b = 20 ;
最终结果:a = 20
b = 10 ;
*/
classTest{
publicstaticvoidmain(String[] args){
//定义两个变量
inta=10 ;
intb=20 ;
System.out.println("互换前:") ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("--------------") ;
//方式1:中间变量(开发中常用)
inttemp=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中流程控制语句
/*
Java中流程控制语句:
顺序结构语句
从main方法这个入口进去,代码由上而下依次加载!
特例:
只要在main方法之前,jvm退出了!
jdk提供一个类System.exit(0) ;正常终止jvm(后面常用类中)
选择结构语句
循环结构语句
*/
classShunXuDemo{
publicstaticvoidmain(String[] args){
System.out.println("程序开始了...") ;
//System.exit(0) ; //终止jvm
System.out.println("我爱高圆圆...") ;
intx=100 ;
System.out.println("helloworld"+x) ;
System.out.println("程序结束,over...") ;
}
}
if else
/*
选择结构语句之If
三种格式
if(条件表达式){
语句;
}
if(条件表达式){ (开发中使用居多的)
语句1;
}else{
语句2;
}
if(条件表达式1){
语句1;
}else if(条件表达式2){
语句2;
...
...
}else{
语句n;
}
格式1的执行流程
if(条件表达式){
语句;
}
条件表达式成立,则执行语句,否则不执行;
if格式1应用场景:针对单个条件进行判断!
*/
//导包
importjava.util.Scanner ;
classIfDemo{
publicstaticvoidmain(String[] args){
//创建文本扫描器对象
Scannersc=newScanner(System.in) ;;
//提示并录入数据
System.out.println("请输入一个数据x的值:") ; //默认int
intx=sc.nextInt() ;
//if格式1
if(x>=10){ //如果if格式1里面单条语句,可以省略{},不建议!
System.out.println("x的值是:"+x) ;
}
System.out.println("over!") ;
}
}
if格式2
/*
if格式2:
if(条件表达式){ (开发中使用居多的)
语句1;
}else{
语句2;
}
执行流程:
1)首先判断条件表达式是成立,如果成立,则执行语句1
2)否则,不成立,则执行语句2
注意:else后面不能带()
举例:模拟用户登录操作(String类 第三周讲)
1)有两个字符串,分别代表用户名和用户的密码
String username = "admin" ; //用户名
String password = "123456" ; //密码
键盘录入的时候,录入用户名和密码,和上面已经存在的用户名和密码进行对比
如果都一致,提示"登录成功",否则登录失败!
提示:
引用数据类型:String代表字符串,比较的时候,比较的是两个内容是否相同
jdk提供了String类的一个方法:字符串1.equals(字符串2)
*/
//导包
importjava.util.Scanner ;
classIfDemo2{
publicstaticvoidmain(String[] args){
//已知存在用户名和密码
Stringusername= "高圆圆" ;
Stringpassword="123456" ;
//创建文本扫描器对象
Scannersc=newScanner(System.in) ;
//提示并录入数据 :jdk提供的文本扫描器的nextLine()录入字符串的
System.out.println("请您输入用户名:") ;
StringinputName=sc.nextLine();
System.out.println("请您输入密码:") ;
StringinputPwd=sc.nextLine();
//if格式2进行判断: 针对两种情况进行操作
//使用键盘录入的用户名和密码,跟已知存在的用户名和密码两个必须同时
//满足内容一致,才能提示"登录成功"
//字符串1.equals(字符串2)
if(inputName.equals(username) && (inputPwd.equals(password))){
System.out.println("恭喜您,登录成功!") ;
}else{
System.out.println("对不起,用户名或者密码输入错误!") ;
}
}
}
扫一扫
545
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
