关键字: JavaSE基础知识
文章目录
JAVA入门
程序的概念
程序是为了模拟现实世界,解决现实问题的由计算机语言编写的一系列有序指令的集合.
JAVA语言平台版本:
1)JavaSE: java标准版
2)JavaEE: java企业版
3)JavaME: java微型版
JAVA语言特点:
简单性 解释性 面向对象 高性能 分布式处理 多线程 健壮性 动态 结构中立 安全性 开源 跨平台
JDK JRE JVM
JDK: Java开发工具包,包含了JRE和类库和一些工具.
JRE: Java运行环境,包含了JVM,解释器,核心类库.
jVM: Java虚拟机,在不同的操作系统中模拟相同的环境.我们编写的程序运行在JVM 上,而JVM 运行在操作系统上.
注意: 1)三者关系：JDK > JRE > JVM
2)我们想要运行一个已有的Java程序,那么只需安装JRE即可. 我们想要开发一个全新的Java程序,那么必须安装JDK.
JDK安装注意事项:
1)将本地的杀毒软件:360/安全卫士
2)安装任何的Java软件:不要存在中文路径以及特殊符号(空格符号)
3)不要安装c盘,尽量在别的盘符下
4)中途提示:是否安装jre(可以安/不安)
5)安装完成:校验是否安装完成了
进入dos控制台
1)win7/win8---->在桌面空白处:安装shift+鼠标右键---->在此处打开命令行窗口
2)在计算机开始菜单—>输入cmd---->命令行提示符—>点击 直接进入
3)windows键+r键----->输入cmd---->进入dos(推荐)
配置JDK环境变量:
1)JAVA_HOME (JDK的安装目录): D:\JAVA_software
2)path(JDK的bin目录): D:%JAVA_HOME%\bin
计算机的执行机制
1)编译执行
将源文件编译成平台相关的机器码文件,一次编译,多次运行,它的执行效率高,但是不可以跨平台.
2)解释执行
将源文件交给不同的平台独有的解释器,执行效率低,可以跨平台.
3)JAVA的执行机制
先编译后解释,即先将源文件编译为字节码文件,再将字节码文件解释执行.(JAVA是跨平台的)
程序开发步骤说明:
Java程序开发三步骤: 编写、编译、运行.
常见的Dos操作命令:
1)更换盘符: d:
2)查询当前目录下的文件和文件夹: dir
3)进入文件夹: cd 文件夹名称
4)返回上一级: cd…
5)返回根目录: cd/
6)删除文件: del 文件名
7)删除文件夹: rd 文件夹名称
8)编译: javac 原文件名.java
9)运行: java 类名
关键字概述
被Java语言赋予特定含义的单词 HelloWorld案例中，出现的关键字有public、class、static、void等，这些单词已经被Java定义好，全部都是小写字母，notepad++中颜色特殊。 关键字比较多，不能死记硬背，学到哪里记到哪里即可。
1):用于定义数据类型值的关键字 class interface byte short int long float double char boolean void
2)用于定义数据类型值的关键字true false null
3)用于定义流程控制的关键字 if else switch case default while do for break continue return
关键字举例
//单行注释
/*
多行注释
*/
/*
关键字:被Java语言赋予特定的含义的单词!
class:类(最基本的单元)
public:权限修饰符 (公共的,公开的)
static:静态修饰符(面向对象部分讲解)
void:(Java中方法没有具体返回值:使用void代替:讲方法的时候说!)
数据类型:
基本类型.... int,boolean,double,float,long,byte,short...
运算符号:
面向对象部分:extends(继承) interface(接口) abstract(抽象)
main:不是关键字:main(): 程序的入口 (能够被Java虚拟机 jvm识别)
*/
class KeyWord{
public static void main(String[] args){
System.out.println("关键字的 认识!") ;
}
}
关于main方法
main方法：称为主方法. 写法是固定格式不可以更改。main方法是程序的入口点或起始点，无论我们编写多少程序，JVM在运行的时候，都会从main方法这里开始执行。
类的注意事项:
1)同一个源文件中可以有多个类,编译后每个类都可以生成.class文件.
2)同一个类,只能有一个主方法,每个类都可以有自己的主方法.
3)public修饰的类,称为公开类,类名必须和源文件名保持一致,并且一个源文件只能有一个公开类.
包的注意事项:
1)包的作用:对字节码文件进行管理,相当于文件夹
2)包的格式: package 包名 ,必须写在源文件的第一行
3)带包编译: javac -d.源文件名.java
4)带包运行: java 包名.类名
5)包名采用域名倒置的规则: 例如: cn.com.baidu.xxx
代码注释:
1)单行注释:
//这是单行注释
2)多行注释:
/*
这是多行注释
*/
3)文档注释:
/**
文档注释
*/
注释举例
/*
注释: 提高代码阅读性
注释的划分:
1)单行注释 //注释的文字
2)多行注释 /星 注释的文字 星/
3)文档注释 /星星 注释的文字 星/
注意:
写代码:养成写注释的习惯
*/
//定义一个类名
class CommentsDemo{
/*
main方法:能够被jvm:java虚拟机识别调用,它是整个程序的入口
*/
public static void main(String[] args){
//想要输出结果,必须要输出语句 ,固定格式
System.out.println("注释,提高代码阅读性的!") ;
}
}
标识符的命名规则:
1)标识符由字母,数字,下划线,$组成,但是不能以数字开头.
2)不能与关键字(public static void break int等),保留字重名.
3)望文生义,见名知义.
4)类名每个单词的首字母必须大写.
5)方法名,变量名第一个单词的首字母小写,后面单词的首字母必须大写.
6)包名所有单词的字母全部小写.
7)常量名全部大写,单词之间用’_'隔开.
常见命名 :
包：com.qianfeng.zhangyang
类或者接口：Student,HelloWorld
方法和变量：name,main,studentName
常量：MAX,STUDENT_MAX_AGE
标识符举例
/*
标识符:
给类,接口,变量以及方法等起名字的字符序列! (见名知意)
包: 目录/文件夹(面向对象中讲):字母全部小写
定义格式:package
单级包
com
HelloWorld.java
多级包:开发中(公司域名反写) :中间用点隔开(分包)
cn.hsbc.dev
cn
hsbc
dev
HelloWorld.java
package cn.hsbc.dev; 后面讲包的编译
给类(接口)的命名规则:
1)一个单词:第一个字母大写,其余小写
举例: class Demo{} class Hello{}
class Student{} 学生类 class S{} (不符合规则:见名知意)
2)多个单词:每一个单词的首字母大小写,其余小写 (大驼峰命名法)
举例: class MakeNameDemo{}
class HelloWorld{}
给变量,(方法)的命名规则:
1)一个单词:单词全部小写
定义一个整数类型: int price = 10 ;
现在这个main main()
2)多个单词:第一个单词全部小写,从第二个单词开始,首字母大写,其余小写 (小驼峰命名法)
自定义方法名:
checkName()
checkPassword()
给常量的命名规则:
1)一个单词: 字母全部大写
举例: "HEELO"
2)多个单词:每个单词字母全部大写,单词和单词之间使用下划线隔开
举例
"HELLO_WORLD"
标识符的组成规则:
1)数字字符
2)英文大小写字母
3)_和$符号
注意事项:
1)数字不能开头
2)Java严格区分大小写
3)起名字:给类,变量等,不能是Java中的关键字
*/
//给类起名字:多个单词:每个单词首字母大写!
class MakeNameDemo{
public static void main(String[] args){
//定义变量
int a = 10 ;
//标识符:不能以数字开头
//int 1y = 20 ;
//int class = 200 ;
//虽然可以定义,但是不满足 见名知意!
//int Class = 200 ;
int user_active = 1 ; //下划线_和$符号都可以
//非法字符: '#'
//int user#active = 2 ;
}
}
常量分类
字面值常量
整数常量 小数常量 字符常量 字符串常量 布尔常量 空常量
自定义常量
常量举例
/*
什么是常量?
常量:
在程序的执行过程中,其值不发生改变的量!
分为两大类:
1)字面值常量
字符串常量
使用双引号括起来的内容
举例:"我爱高圆圆","helloworld","aa"
字符常量
使用单引号括起来的单个内容
举例: 'ab'错误的 '0','a','A'
整数常量:
整数:默认十进制数据
100,65,1000
进制---整数常量范畴!
小数常量
3.1415926
12.34
布尔常量
true/false
空常量:null
2)自定义常量(后面:面向对象部分讲解) 关键字:final有关
*/
class ConstantDemo{
public static void main(String[] args){
//测试
//字符串常量
System.out.println("helloworld") ;
System.out.println("我爱高圆圆") ;
System.out.println("100") ;//"100"
System.out.println("----------------") ;
//字符常量
//单独使用
System.out.println('A');
System.out.println('0');
System.out.println('a');
System.out.println("-------------------") ;
//System.out.println('ab');
//如果当前字符不参与运算: 'A','0','a'....
//但是如果字符参与运算的时候,这些字符会在ASCII码表中寻找对应的整数值进行计算
System.out.println('A'+1);//ASCII码表:'A' -- 65 大写字母字符
System.out.println('0' +1);//ASCII码表:'0' -- 48 数字字符
System.out.println('a' + 1);//ASCII码表: 'a' -- 97 小写字母字符
System.out.println("-------------------") ;
//整数和小数常量
System.out.println(100) ;
System.out.println(1000) ;
System.out.println(3.1415926) ;
System.out.println("-------------------") ;
//布尔常量
System.out.println(true) ;
System.out.println(false) ;
//空常量
String str = null ;//String类(很重要:常用类中的)
//String str ="" ;//空字符串
System.out.println(str) ; //null:关键字
}
}
/*
二进制:组成:0,1, 以0b开头
八进制:组成:0,...7组成,以0开头
十六进制:组成:0...9,a..f,组成,以0x开头
十进制:整数默认十进制
任意进制---十进制
4
64
100
256
*/
class Demo{
public static void main(String[] args){
System.out.println(0b100) ;//表示二进制
System.out.println(0100) ;//表示八进制
System.out.println(100) ;//整数
System.out.println(0x100) ;//表示十六进制
}
}
进制概述
不同进制的组成规则
二进制 由0，1组成。以0b开头
八进制 由0，1，…7组成。以0开头
十进制 由0，1，…9组成。整数默认是十进制的
十六进制 由0，1，…9，a，b，c，d，e，f（大小写均可），以0x开头
十进制和二进制的快速转换
8421码 : 8421码是中国大陆的叫法，8421码是BCD代码中最常用的一种。在这种编码方式中每一位二值代 码的1都是代表一个固定数值，把每一位的1代表的十进制数加起来，得到的结果就是它所代表的 十进制数码。
扩展一下: 256 128 64 32 16 8 4 2 1
有符号位的数据表示法(扩展)
在计算机内，有符号数有3种表示法：原码、反码和补码。所有数据的运算都是采用补码进行的。
原码 就是二进制定点表示法，即最高位为符号位，“0”表示正，“1”表示负，其余位表示数值的大小
反码 正数的反码与其原码相同；负数的反码是对其原码逐位取反，但符号位除外。
补码 正数的补码与其原码相同；负数的补码是在其反码的末位加1。
变量概述
变量：常量是固定不变的数据，那么在程序中可以变化的量称为变量。
数据类型分类
基本数据类型：
包括 整数、浮点数、字符、布尔。
引用数据类型：
包括 类、数组、接口。
变量的定义
变量定义的格式包括三个要素：数据类型 、 变量名 、 数据值。
格式代码如下： 数据类型 变量名 = 数据值；
long类型：建议数据后加L表示。 float类型：建议数据后加F表示。
注意事项 变量名称：在同一个大括号范围内，变量的名字不可用相同 变量赋值：定义的变量，不赋值不能使用。
数据类型转换
Java程序中要求参与的计算的数据，必须要保证数据类型的一致性，如果数据类型不一致将发生类型的 转换
自动转换
将取值范围小的类型自动提升为 取值类型大的范围。
转换规则
范围小的类型向范围大的类型提升，byte 、short 、 char 运算时直接提升为int。
byte、 short 、 char – >int – >long – >float – >double
强制类型转换
将取值范围大的类型 强制转换成 取值范围小的类型。
转换格式
数据类型 变量名 = （数据类型） 被转数据值；
强烈注意 浮点转成整数，直接取消小数点，可能造成数据损失精度。 int 强制转成 short 砍掉2个字节，可能造成数据丢失
ASCII编码表
转义字符
变量举例
/*
变量的三要素:
1)数据类型
2)变量名(遵循标识符的规则)
3)初始化值
Java中数据类型划分:(重点)
A)基本数据类型:四类8种
以后开发中:int(最多),double,long,char,boolean(判断时用)
整数类型:(默认int),
byte:字节类型 占1个字节 取值范围;-128~127(考点)
short:短整型 占2个字节
int:整数 占4个字节
long:长整型 占8个字节
浮点类型:默认是double
单精度:float :占4个字节
双精度:double :占8个字节
字符类型
char: 占2个字节
布尔类型
boolean 占1个字节
B)引用数据类型:数组,接口,类(具体类,抽象类)
面向对象讲
JavaWEB/JavaEE:研究引用类型!
定义long类型的注意事项:
需要在当前变量值的加上标记:L或者l(建议大写L):描述当前变量是长整型
long类型---------------->系统时间(精确到毫秒),时间.....
定义float类型的注意事项:
在变量值的后面标记当前是一个单精度变量:F/f
*/
class DataTypeDemo{
public static void main(String[] args){
//测试
//字节类型 byte
byte b = 100 ;
//byte b = 20 ; //重复定义变量 byte已经指定!
b = 20 ;
//字符串+任何数据=字符串
System.out.println("b:"+b) ;//b:值 +:字符串拼接符号
System.out.println("---------------------------------") ;
//short:短整型
short s = 100 ;
System.out.println("s:"+s) ;
System.out.println("---------------------------------") ;
//int:整数 占4个字节
//long:长整型 占8个字节
int i = 10000 ;
System.out.println("i:"+i) ;
System.out.println("---------------------------------") ;
//int i = 100000000000000000000; //过大的整数: 100000000000000000000
//超过了int类型的范围:需要使用long去接收
long ii = 1000000000000000000L ;
//标记当前这个数据是long类型,需要在当前初始值的后面加上标记:L,l(建议L)
System.out.println("ii:"+ii) ;
System.out.println("---------------------------------") ;
//浮点类型:默认double
//单精度:float
//双精度:double
double d = 12.34 ;
System.out.println(d) ;
System.out.println("---------------------------------") ;
//定义float类型
//float f = 12.56 ; //不兼容的类型: 从double转换到float可能会有损失
//需要在单精度的值的后面加上标记:F/f,标记单精度
float f = 12.56F;
System.out.println(f) ;
System.out.println("---------------------------------") ;
//字符变量:char
char ch1 = 'A' ;
char ch2 = '0' ;
char ch3 = 'a' ;
char c = '中' ; //中文存储:默认的编码格式:dos控制台:
//编码格式:
//gbk:中国中文编码表 :一个中文对两个字节
//gb2312:gbk升级版本(包含特殊的中文字符)
//utf-8:一个中文对应三个字节
//iso-8859-1:拉丁文码表
System.out.println(ch1) ;
System.out.println(ch2) ;
System.out.println(ch3) ;
System.out.println(c) ;
System.out.println("---------------------------------") ;
//布尔类型
//boolean
boolean flag = true ;
System.out.println(flag) ;
flag = false ;
System.out.println(flag) ;
//基本类型:四类八种
//引用类型: (重点)
//数组:...
//类
//代表:String :字符串类...
//接口 :有自己的写法规则
}
}
/*
定义变量的注意事项:
1)给变量命名的时候:见名知意
2)变量尽量给一个初始化值,或者在使用之前给定一个初始化值
如果使用之前都没有初始化,报错(在方法定义中变量:局部变量)
3)Java是一种强类型语言,规定了同一个变量名不能定义多次(提示:已经定义了!)
强:语法规则
书写格式
前端:javascript:(js):弱类型语言
var a = 10
var a = 20
4)定义变量的时候,书写格式
数据类型 变量名 = 初始值 ; (分号一定要带,表示语句结束!)
在同一行上,一般定义一个变量(有的面试题:一行定义多个变量)
*/
class DataTypeDemo2{
public static void main(String[] args){
//定义了一个int类型变量
int a = 10 ;
//int b ; //可能尚未初始化变量b
int b ; //定义两个变量名
b = 2 ;
System.out.println(b) ;
System.out.println("------------------------");
//定义两个变量
int m = 20 ;
//int m = 30 ; //重复定义变量(已在方法 main(String[])中定义了变量 m)
m = 30 ;//对已经定义变量m重新赋值
System.out.println("m:"+m) ;
int n = 20 ;//分号的问题(英文的)
//int z ,int x , int y ;错误的写法
int z ,x , y ;
//int z ; int x ; int y ;
//分别赋值
z = 10 ;
x = 20 ;
y = 30 ;
//+:字符串拼接符号
System.out.println("x:"+x+",y:"+y+",z:"+z) ; //x:20,y:30,z:10
}
}
/*
变量在进行运算的时候,需要保证变量的类型一致:最终使用的该数据类型接收即可!
在运算的时候,变量的数据类型不一致的情况:
隐式类型提升:
byte,short,char,三者之间互相不转换,一旦他们参与运算,
数据类型优先提升int类型(考点)
基本类型中:四类八种
boolean 类型不进行数据转换(判断去使用)
*/
class DataTypeDemo3{
public static void main(String[] args){
//定义两个变量
int a = 3 ;
int b = 4 ;
//a和b要进行求和
int result = a + b ;
System.out.println("result:"+result) ;
System.out.println("---------------------") ;
//两个数据类型不一致
byte m = 3 ; //byte:1个字节
int n = 4 ; //int:占4个字节
int result2 = m + n ; //byte m---->int类型 + int 类型的n变量进行求和
// 错误的 byte result2 = m + n ; // 等号右边的结果:int类型(不兼容的类型: 从int转换到byte可能会有损失)
System.out.println("result2:"+result2) ;
}
}
/*
Java中强制类型转换的书写格式:
目标数据类型 变量名 = (目标数据类型)初始化值;
强制类型转换:
不要随意使用,除非一些业务需求必须使用的时候才能用!
强制类型:会损失数据的精度
*/
class DataTypeDemo4{
public static void main(String[] args){
//定义两个变量
int m = 3 ;
byte n = 4 ;
//byte result = m + n ; // 不兼容的类型: 从int转换到byte可能会有损失
//目标数据类型 变量名 = (目标数据类型)初始化值;
byte result = (byte)(m+n);
System.out.println("结果是:"+result) ;
}
}
/*
两个思考题
1)以下代码有没有问题
double d = 12.34 ;
float f = 12.56 ;
2)以下代码有什么区别
float f = 34.5F; //本身定义的单精度类型:占4个字节
float f = (float)12.78 ; //也是float类型,强制转换来的
//将double类型----->float类型(会损失精度!)
*/
class DataTypeDemo5{
public static void main(String[] args){
//定以两个变量
double d = 12.34 ;//定义double类型(浮点类型:默认就是double)
//float f = 12.56 ; // 不兼容的类型: 从double转换到float可能会有损失
//解决方案:
//1)在值的末尾加上标记12.56f/12.56F
//2)强制类型转换
float f = (float)12.56 ;
System.out.println("d:"+d+",f:"+f) ;
System.out.println("---------------------");
float f = 34.5F;
float f = (float)12.78 ;
}
}
/*
面试题:
以下代码存在的问题
byte b ,b1 = 3 ,b2 =4 ;
1)b = b1 + b2 ;
2)b = 3 + 4 ;
存在问题?如何解决?
b = b1 + b2 ;
变量相加:必须考虑 数据类型的问题 (Java中的隐式类型提升:)
b1 + b2 ====>两个变量都需要提升int类型 (结果:int类型的7)
接收的类型:byte b(一个字节)
解决方案:
b = (byte)(b1+b2); 强制类型转换
2)b = 3 + 4 ;
常量相加:将常量进行运算----->运算之后看其结果是否在接收数据类型的范围之内!
byte :范围:-128~127
面试题
byte b = 300 ;(作业)
*/
class DataTypeDemo6{
public static void main(String[] args){
//定义变量
byte b ,b1 = 3 ,b2 =4 ;
//b = b1 + b2; //不兼容的类型: 从int转换到byte可能会有损失
//b = (byte)(b1+b2); //解决方案: 强制类型转换
//常量相加
b = 3 + 4;//7 在byte类型范围之内
System.out.println("b:"+b) ;
}
}
/*
需求:byte类型变量
byte b = 130 ;
有什么问题,如何解决这个问题?
*/
class DataTypeDemo7{
public static void main(String[] args){
//定义变量
//byte b = 130 ;//不兼容的类型: 从int转换到byte可能会有损失
//130大于127(byte范围:-128~127)
//解决方案:130(整数:默认int类型),无法使用小类型接收大类型的结果(强制类型转换)
byte b = (byte)130 ;
System.out.println(b) ;//-126
}
}
/*
130 (默认)int类型
最高符号位 数值位 (正整数:原,反,补相同)
0 0000000 00000000 00000000 10000010
//截取int类型---->byte类型
//byte b = (byte)130 ;
//00000000 00000000 00000000 10000010 ---开始截取
// 10000010 1个字节 (补码) ---- 反码----原码
最高符合位 数值位
1 0000010 补码
- 1
------------------------------------
1 0000001 反码(最高符号位不变,补码的末尾-1)
原码(最高符号位不变,数值位按位取反:0变1,1变0)
-----------------------------------
- 1111110
= - 64+32+16+8+4+2+0
=- 126
127 - 130 = -3
-128 -127 -126 ......125,126,127
序号 1 2 3
*/
/*
关于+
1)表示数据是一个正整数
2)表示算术运算符中的加法运算
3)字符串拼接符号
看程序,写结果
字符串+(拼接符号)任何数据= 新的字符串
*/
class DataTypeDemo8{
public static void main(String[] args){
System.out.println("hello"+'a'+1) ; //"hello"+'a'="helloa"+1 ="helloa1" (字符串拼接符号)
System.out.println('a'+1+"hello") ; //'a'+1=97+1=98+"hello" = "98hello"
//字符一旦参与运算,就需要寻找ASCII码表中的数据值来进行运算
System.out.println("--------------------");
System.out.println("5+5="+5+5) ; //"5+5="+5 = "5+5=5"+5 = "5+5=55"(字符串拼接符)
System.out.println(5+5+"=5+5") ; //"10=5+5"
int a = 10 ;
System.out.println("a:"+a) ;//"a:10"
}
}
常量相加和变量相加的区别
常量相加,先相加,再判断和的范围,进行操作
变量相加,先考虑数据类型的转换,在相加.
运算符
算术运算符
算数运算符举例
/*
Java中运算符:
算术运算符
赋值运算符
比较(关系)运算符
逻辑运算符 (使用居多)
位运算符(了解)
三元(三目)运算符(使用居多)
算术运算符:
基本的算术运算符
+,-,*,/(默认:取值),%(取模:求余数)
扩展的算术运算符:(单独讲)
++
--
*/
class OperatorDemo{
public static void main(String[] args){
//System.out.println(1.0-0.32) ;
// //0.6799999999999999 (小数:-,/,没有精确计算) java提供一种精确运算的机制:类:BigDecimal(常用类中讲)
//定义两个变量
int a = 3 ;
int b = 4 ;
//基本的算术运算符
System.out.println(a+b) ;
System.out.println(a-b) ;
System.out.println(a*b) ;
System.out.println(a*1.0/b) ;//默认:取整
System.out.println(a%b) ;//求余数
}
}
/*
扩展的算术运算符
++
--
分两种情况:
1)单独使用
结论:
无论++还是--在变量前面还是后面:都是对当前该变量值进行自增1或者自减1
应用场景:结合流程控制语句之循环语句去使用!
2)参与运算使用
如果++或者--在变量前面,先自增1或者自减1,然后运算!
如果++或者--在变量后面,先运算(赋值),然后在自增1或者自减1
*/
class OperatorDemo2{
public static void main(String[] args){
//定义两个变量
int a = 10 ;
int b = 20 ;
System.out.println("a:"+a); //a:10
System.out.println("b:"+b) ;//b:20
System.out.println("---------------------------") ;
//A)单独使用
//1)如果++或者--在变量前面
//++a ;
//--b ;
//2)如果++或者--在变量的后面
//a ++;
//b -- ;
//B)参与运算使用
//1)如果++或者--在变量前面
//int m = ++ a ; //10+1 = 11
//int n = -- b ;//20 -1 = 19
//System.out.println("a:"+a) ; //11
//System.out.println("b:"+b) ;//19
//System.out.println("m:"+m) ;//11
//System.out.println("n:"+n) ;//19
//2)如果++或者--变量后面
int m = a ++ ; //先将10赋值给m,然后在自增1
int n = b -- ;//先将20赋值给n.然后在自减1
System.out.println("a:"+a) ; //11
System.out.println("b:"+b) ; //19
System.out.println("m:"+m) ; //10
System.out.println("n:"+n) ;//20
}
}
/*
看程序,写出运算结果
1)
int a = 10;
int b = 10;
int c = 10;
a = b++;
c = --a;
b = ++a;
a = c--;
请分别计算出a,b,c的值
2):比较复杂的题目
int x = 4;
int y = (x++)+(++x)+(x*10);
计算出:x和y的值
*/
class OperatorTest{
public static void main(String[] args){
//1)初始化a,b,c
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, 8
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
System.out.println("c:"+c) ;
System.out.println("---------------------------") ;
int x = 4; //x = 4 x = 5 x = 6
// y = ()代表4 + 6 + (6*10) = 70
int y = (x++)+(++x)+(x*10);
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
}
}
赋值运算符
赋值运算符举例
/*
赋值运算符:
基本的赋值运算符
=
int a = 10 ;
将10这个值赋值给int类型的变量a
注意事项:
=不能写成==:表示比较运算符 ==连接表达式最终true/false
扩展的赋值运算符(细节)
+=,*=,-=,/=,%=
举例:
int x = 10 ;
x += 20 ; 类似于 将等号左边的数据和右边的数据相加,将结果赋值左边数据
x = x + 20 ;
*/
class OperatorDemo{
public static void main(String[] args){
//赋值运算符
int a = 10 ; //将10这个值赋值给int类型的变量a
// int m == 20 ; //==:表示比较运算符 ==连接表达式最终true/false
int x = 20 ;
x += 10 ; //x = x + 10; //x = 30
System.out.println("x:"+x) ;
}
}
/*
面试题
以下代码哪一句会编译失败,如何解决?
short s = 1 ;
1)s = s +1 ;
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可能会有损失
//byte,short,char:三者之间不转换,但是参与运算,先提升int类型(隐式转换)
//解决:强制类型转换
//s = (short)(s+1) ; //显示转换 (强制类型转换)
s += 1 ;//等价于 s = (short)(s+1) ;
System.out.println("s:"+s) ;
}
}
关系运算符
关系运算符举例
/*
比较运算符---关系运算符
>,<,>=,<=,==,!=
变量x范围:
数学表达式: 3<=x<=5
Java表表达式:
x>=3 &&(逻辑运算符) x<=5
|| (逻辑运算符)
比较运算符:连接的表达式无论是简单还是复杂的,最终结果要么true/false
注意事项:
==不能写成=
*/
class OperatorDemo{
public static void main(String[] args){
//定义三个变量
int x = 3 ;
int y = 4 ;
int z = 5 ;
//使用比较运算符
System.out.println(x >= y) ;
System.out.println(x<=y) ; //x<=y
System.out.println(x!=z) ;
System.out.println(x==z) ;
System.out.println(y > z) ;
System.out.println( y < x) ;
System.out.println("-------------------------") ;
boolean flag = (x == y) ; //比较x和y是否相等
//boolean flag = x = y ; //y =4 赋值x,x就是4 不兼容的类型: int无法转换为boolean
System.out.println(flag);
}
}
逻辑运算符
逻辑运算符举例
/*
逻辑运算符
基本的逻辑运算符:
逻辑单与 & (并列关系)
结论:有false,则false
逻辑单或 | (或关系:有一个满足条件就成立了)
结论:有true,则true
逻辑异或 ^
结论:相同则为false,不同则为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)) ;//true & false = false
System.out.println((a>b) & (a<c)) ;//false & true = 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)) ;//true | false = true
System.out.println((a>b) | (a<c)) ;//false | true = 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)) ;//true ^ false = true
System.out.println((a>b) ^ (a<c)) ;//false ^ true = true
System.out.println((a<b) ^ (a<c)) ;//true ^ true = false
System.out.println("----------------------------") ;
//逻辑非!
// 应用场景:在登录/校验验证码等等
System.out.println(!(a>b)) ;//! false : true
System.out.println(!!(a>b)) ;
System.out.println(!!!(a>b)) ;
}
}
/*
扩展的逻辑运算符 (开发中使用逻辑双与/逻辑双或多一些!)
逻辑双与: &&
逻辑双或: ||
面试题
逻辑双与&& 和逻辑单与&有什么区别?
共同点:
结论:有false,则false(有一个不满足条件,就false)
最大的区别:
逻辑双与&& 连接的表达式:如果左表的表达式为false,右边就不执行了,
有false,则false(短路效果)
逻辑双|| :如果连接的表达式左边为true,右边不执行(短路效果!)
开发中:使用逻辑双与&& 或者逻辑双或||
*/
class OperatorDemo2{
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)) ;//true & false = false
System.out.println((a>b) && (a<c)) ;//false & true = false
System.out.println((a<b) && (a<c)) ;//true & true = true
System.out.println("-----------------------------") ;
//定义两个变量x,y
int x = 3 ;
int y = 4 ;
System.out.println("x:"+x) ;
System.out.println("y:"+y) ;
System.out.println("-----------------------------") ;
//true && false
//System.out.println(((++x) ==4) && ((--y) == 4) ) ; //false
//false && true
//逻辑双与&&的短路效果
System.out.println(((x++) == 4) && ((y--) == 4)) ;
System.out.println("x:"+x) ;//4
System.out.println("y:"+y) ;//还是4:没有变化
}
}
三元运算符
三元运算符举例
/*
单目: int a = 5 ;
二目: 两个变量进行比较 x == y
三元运算符---三目运算符
格式
(表达式) ? 执行true的结果:执行false的结果
表达式:可以是简单的或者复杂的表达式------>true/false
执行流程:
1)先判断表达式是否成立,如果成立,执行true的结果
2)如果不成立,执行false的结果
一般没有要求是什么数据类型,默认int类型
需求:定义两个变量
求出两个数据的最大值
需求:
1)求两个数据的最大值
2)求三个数据的最大值
3)求两个数据是否相等
*/
/*
需求:
1)求两个数据的最大值
2)求三个数据的最大值
3)求两个数据是否相等
*/
class OperatorTest{
public static void main(String[] args){
//两个变量
int x = 3 ;
int y = 5 ;
//接收结果
int result = (x > y )? x : y ;
System.out.println("这两个数据中的最大值是:"+result) ;
System.out.println("-------------------------------") ;
//求三个数据的最大值
int a = 10 ;
int b = 30 ;
int c = 5 ;
//使用中间变量的方式(推荐)
//分步执行:
//定义变量temp
int temp = (a > b) ? a: b ;
//在使用temp变量和c进行比较
int max = (temp > c) ? temp : c ;
System.out.println("这三个数据中的最大值是:"+max) ;
System.out.println("-------------------------------") ;
//方式2:一步执行
//直接三元运算符
int max2 = (a > b) ? ((a>c)? a: c) : ((b>c)? b: c) ;
System.out.println("这三个数据中的最大值是:"+max2) ;
System.out.println("-------------------------------") ;
//比较两个数据是否相等
int m = 10 ;
int n = 20 ;
//boolean flag = (m==n)? true: false ;
boolean flag = m==n ;
System.out.println("flag:"+flag) ;
}
}
位运算符
位运算符
基本的运算符号
位与:&
位或:|
位异或:^
~(反码:按位取反:全部1变0,0变1):
位运算符号:连接的是两个具体的数据值----->具体的结果数据!
逻辑运算符号:连接的要么数值/要么表达式—>结果:true/false
位运算符举例
/*
位运算符
基本的运算符号
位与:&
位或:|
位异或:^
~(反码:按位取反:全部1变0,0变1):
位运算符号:连接的是两个具体的数据值----->具体的结果数据!
逻辑运算符号:连接的要么数值/要么表达式--->结果:true/false
*/
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) ;
/*
0
7
7
-4
*/
}
}
/*
3 :11
4 :100
位与:&:有0,则0
3 & 4
00000000 00000000 00000000 00000011
位与& 00000000 00000000 00000000 00000100
-------------------------------------------------- -----
00000000 00000000 00000000 00000000
结果:0
位或:|
有1,则1
3 | 4
00000000 00000000 00000000 00000011
位或| 00000000 00000000 00000000 00000100
------------------------------------------------------------------
00000000 00000000 00000000 00000111
结果:7
位异或:相同则为0,不同则为1
3 ^ 4
00000000 00000000 00000000 00000011
位异或^ 00000000 00000000 00000000 00000100
-------------------------------------------------------------
00000000 00000000 00000000 00000111
结果:7
~3
反码:按位取反 (1变0,0变1)
00000000 00000000 00000000 00000011(原,反,补码)
~
-------------------------------------------------------
11111111 11111111 11111111 11111100 (补码)
- 1
------------------------------------------------------
11111111 11111111 11111111 11111011 (反码)
---------------------------------------------------------------
最高符合位不变,其他数值位按位取反:0变1,1变0
10000000 00000000 00000000 00000100 (原码)
- 4
*/
/*
位运算符 (操作的一个具体的数值!)
移动符号
左移:<<
左移动,将最高符合位丢弃掉,在右边补齐0
特点:将<<符号左边的数据乘以2的移动次幂
右移:>> :
右移动,如果最高符号位为0,左边补0,如果最高符号位为1,左边补齐1
特点:将>>符号左边的数据除以2的移动次幂
无符号右移: >>>
向右移动,无论最高符合位为0还是1,左边补0!
面试题:
请用有效的方式表示 2乘以8的结果!
2 << 3
*/
class OperatorDemo2{
public static void main(String[] args){
System.out.println(2 << 3) ; //将<<符号左边的数据移动3位
//2 * 2^3 = 2 * 8 = 16
//将<<符号左边的数据乘以2的移动次幂
System.out.println(24 >> 2) ;将>>符号左边的数据除以2的移动次幂 6
//24 / 2^2 = 24/4 = 6
System.out.println(-24 >> 2) ;
System.out.println(-24 >>>2 ) ;
}
}
/*
2数据对应的二进制数据:原码
00000000 00000000 00000000 00000010 (原码,反码,补码相同的)
补码 :左移动3位
00000000 00000000 00000000 00000010
(000)00000 00000000 00000000 00000010 000(右边补0:少三位,补三位) 补码
00000 00000000 00000000 00000010 000 补码(----->反码---->原码)
16
24 >> 2
//24数据的二进制数据
00000000 00000000 00000000 00011000 (原码,反码,补码都相同)
补码: 右移动2位
00000000 00000000 00000000 00011000
0000000000 00000000 00000000 000110(00)
移动后的补码:
0000000000 00000000 00000000 000110 (补--->反---原)
6
1 1 1 1 1 1 1 1 1
128*2 128 64 32 16 8 4 2 1
-24 >> 2
10000000 00000000 00000000 00011000 (-24的原码)
---------------------------------------------------------
11111111 11111111 11111111 11100111 (-24的反码)
+1
----------------------------------------------
11111111 11111111 11111111 11101000 (-24的补码)
右移2位
11111111 11111111 11111111 11101000
1111111111 11111111 11111111 111010(00) (补码)
1111111111 11111111 11111111 111010 (补码)
-1
---------------------------------------------------------
1111111111 11111111 11111111 111001 (反码)
---------------------------------------------
1000000000 00000000 00000000 000110 (原码)
- 6
- 24 >>>2
10000000 00000000 00000000 00011000 (-24的原码)
---------------------------------------------------------
11111111 11111111 11111111 11100111 (-24的反码)
+1
----------------------------------------------
11111111 11111111 11111111 11101000 (-24的补码)
11111111 11111111 11111111 11101000
0011111111 11111111 11111111 111010(00) (补码----反码---原码)
十进制的结果: 1,073,741,818
*/
/*
位异或^ 符合特点:
一个数据被另一个数据位异或两次,结果是它本身!
*/
class OperatorTest{
public static void main(String[] args){
int a = 10 ;
int b = 20 ;
System.out.println(a ^ b ^ b) ; //10
System.out.println(a ^ b ^ a) ; //20
}
}
/*
面试题:(面试官:位异或特点)
实现两个变量的结果进行交换?
int a = 10 ;
int b = 20 ;
*/
class OperatorTest2{
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 ; //10
a = b ;//a = 20
b = temp ;//b =temp = 10 ;
*/
//方式2:位异或运算符的特点:一个数据被另一个数据位异或两次,其值是它本身
a = a ^ b ;
b = a ^ b ;//b = a^ b ^ b = a
a = a ^ b ;//a = a ^ b ^ a = b
System.out.println("交换后:") ;
System.out.println("a:"+a) ;
System.out.println("b:"+b) ;
}
}
运算符的优先级
运算符的优先级（从高到低）
-
-
优先级 描述 运算符 1 括号 ()、[] 2 正负号 +、- 3 自增自减，非 ++、–、! 4 乘除，取余 *、/、% 5 加减 +、- 6 移位运算 <<、>>、>>> 7 大小关系 >、>=、<、<= 8 相等关系 ==、!= 9 按位与 & 10 按位异或 ^ 11 按位或 | 12 逻辑与 && 13 逻辑或 || 14 条件运算 ?: 15 赋值运算 =、+=、-=、*=、/=、%= 16 位赋值运算 &=、|=、<<=、>>=、>>>=
-
键盘录入
键盘录入举例
/*
是Java核心类: java.util.Scanenr; (Java中只要不是java.lang包下的类都需要导包)
Scanner
使用步骤:
1)导包:(目前写在class上面) 固定写法
格式 import java.util.Scanner; (用哪个类,导哪个类)
2)固定格式:
创建键盘录入对象
Scanner 键盘录入的对象名 = new Scanner(System.in) ;
3)友情提示: 输出语句 "请您输入一个数据:"
4)接收数据 (接收int类型数据)
int 接收的变量名= 键盘录入的对象名.nextInt() ; //录入下一个int类型的数据
5)输出/完成业务操作
*/
//1)导包
import java.util.Scanner; //import 包名.类名;
class ScannerDemo{
public static void main(String[] args){
//2)创建键盘录入对象
//sc:代表当前键盘录入的对象名(变量)
Scanner sc = new Scanner(System.in) ;
//3)友情提示: 输出语句 "请您输入一个数据:"
System.out.println("请你输入一个int类型数据:");
//4)接收数据
//int 接收的变量名= 键盘录入的对象名.nextInt() ;
int number = sc.nextInt() ;
//5)输出
System.out.println("您输入的数据是:"+number) ;
}
}
/*
需求:
键盘录入两个数据,求两个数据中的最大值 (默认int类型)
键盘录入:三个数据:求最大值
键盘录入两个数据:比较是否相等
*/
import java.util.Scanner;
class ScannerTest{
public static void main(String[] args){
//1)导包
//2)创建键盘录入对象
Scanner scanner = new Scanner(System.in) ;
//3)提示并接收数据
System.out.println("请您输入第一个数据:") ;
int num1 = scanner.nextInt() ;
System.out.println("请您输入第二个数据:") ;
int num2 = scanner.nextInt() ;
//4)两个数据中的最大值
//三元运算符进行比较
int max = (num1 > num2) ? num1: num2 ;
System.out.println("两个数据的最大值是:"+max) ;
System.out.println("-----------------------------------") ;
//键盘录入:三个数据:求最大值
//提示并接收数据
System.out.println("请输入第一个数据:") ;
int a = scanner.nextInt() ;
System.out.println("请输入第二个数据:") ;
int b = scanner.nextInt() ;
System.out.println("请输入第三个数据:") ;
int c = scanner.nextInt() ;
//两种方式:
//1)中间变量
//int temp = (a>b) ? a: b ;
//int result = (temp > c)? temp : c ;
//2)直接三元运算符
int result = (a > b) ? ((a > c) ? a : c) : ((b > c)? b: c) ;
System.out.println("result:"+result) ;
System.out.println("-----------------------------------") ;
//键盘录入两个数据:比较是否相等
//提示并接收数据
System.out.println("请输入第一个数据:") ;
int firNum = scanner.nextInt() ;
System.out.println("请输入第二个数据:") ;
int secNum = scanner.nextInt() ;
boolean flag = firNum == secNum ;
System.out.println("flag:"+flag) ;
}
}
流程控制语句之_顺序结构语句
/*
Java语言基础语法:
1)变量
2)运算符
3)支撑:流程控制语句
流程控制语句:
1)顺序结构语句 (简单)
一旦进入main方法中(由Jvm 调用),从有效行开始依次从上往下执行!
2)选择结构语句
分两种:
if语句
三种格式
if(表达式){}
if(表达式){
}else{
}
if(表达式1){
}else if(表达式2){
}else if(表达式3){
....
}else{
}
switch语句
3)循环结构语句
for循环(使用最多)
while循环(其次)
do-while循环(很少使用)
*/
//顺序结构语句
class OrderDemo{
public static void main(String[] args){
//顺序结构语句 (简单)
//一旦进入main方法中(由Jvm 调用),从有效行开始依次从上往下执行!
System.out.println("程序开始了....") ;
System.out.println("爱Java,爱高圆圆....") ;
System.out.println("程序结束了....") ;
}
}
流程控制语句之_选择结构语句If
/*
if语句的格式:
第一种格式
if(表达式){
语句;
}
执行流程:
判断表达式是否成立,如果是true,成立,执行语句;
如果不成立,不执行!
if语句整体的注意事项:
1)有if的地方需要有一对{}
有{}的地方不能分号;
*/
//导包
import java.util.Scanner ;
class IfDemo{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收
System.out.println("请你输入一个数据:");
int a = sc.nextInt() ;
//if格式1
if(a >= 10){
System.out.println("a的值大于等于10") ;
}
System.out.println("over") ;
}
}
/*
if语句整体的注意事项:
1)有if的地方需要有一对{}
有{}的地方不能分号;
2)在一个方法中(main() )定义一个{xxxd代码}---->局部代码块 (了解)
作用:限定局部变量的生命周期
局部变量:在方法定义中的变量---->随着方法的调用完毕而消失!
内存中:GC 垃圾回收器(自动回收这些对象或者变量)
if格式1)应用场景:
针对单个业务场景进行判断
*/
import java.util.Scanner;
class IfDemo2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收
System.out.println("请你输入一个数据:");
int a = sc.nextInt() ;
//if格式1
//if(a >= 10); //if语句:没有任何意义
//代码块----(局部代码块)
{
System.out.println("a的值大于等于10") ;
}
//局部代码块:作用:限定变量的生命周期
{
//x的值是在当前{}内有效 {}---->作用域
int x = 100 ;
System.out.println(x) ;
}
//找不到符号
//System.out.println(x) ;
System.out.println("over") ;
}
}
/*
if格式2:
if(表达式){
语句1;
}else{
语句2;
}
执行流程:
1)首先判断表达式是否成立,如果是true,执行语句1
2)如果不成立,执行语句2;
需求:
键盘录入一个数据,判断这个是否是偶数!
应用场景
针对两种情况进行判断
需求: 键盘录入两个数据,求最大值!
(使用if...else.../三元)
*/
//导包
import java.util.Scanner;
class IfDemo3{
public static void main(String[] args){
//定义一个变量
int x = 10 ;
if(x >=10){
System.out.println("x大于等于10") ;
}else{
System.out.println("x小于10") ;
}
System.out.println("over...") ;
System.out.println("---------------------------") ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收
System.out.println("请输入一个数据:") ;
int num = sc.nextInt() ;
if(num %2 == 0){ //%:求余: 能够被2整数,余数为0
System.out.println(num+"是偶数!") ;
}else{
System.out.println(num+"是奇数!") ;
}
}
}
/*
if语句的第三种结构:
if(表达式1){
语句1;
}else if(表达式2){
语句2;
...
...
...
}else{
语句n+1 ;
}
执行流程:
1)首先判断表达式1是否成立,如果成立,执行语句1,if语句结束!
2)如果表达式1不成立,再次判断表达式2是否成立,如果成立,执行语句2,语句结束!
3)如果上述表达式都不成立,就执行else中的语句,if语句结束!
应用场景:
针对多种情况进行判断
举例:
键盘录入学生的成绩,判断学生的成绩等级
90~100 突出
80~90之间 优秀
70~80之间 良好
60~70 及格
60以下 不及格
*/
//导包
import java.util.Scanner ;
class IfDemo4{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示,并接收数据
System.out.println("请您录入学生的成绩: ") ;
int score = sc.nextInt() ;
/*
if(score >= 90 && score <=100){
System.out.println("该学生成绩十分突出...") ;
}else if(score >=80 && score< 90){
System.out.println("该学生成绩优秀...") ;
}else if(score >= 70 && score <80){
System.out.println("该学生成绩良好...") ;
}else if(score >= 60 && score <70){
System.out.println("该学生成绩及格...") ;
}else{
System.out.println("该学生成绩不及格...") ;
}
*/
/*
写好一个程序:自己测试
测试错误数据,正确数据以及边界数据
目的:让程序更符合真实场景,保证用户的体验!
*/
if(score >100 || score < 0){
System.out.println("您录入的是一个非法数据...") ;
}else if(score >= 90 && score <=100){
System.out.println("该学生成绩十分突出...") ;
}else if(score >=80 && score< 90){
System.out.println("该学生成绩优秀...") ;
}else if(score >= 70 && score <80){
System.out.println("该学生成绩良好...") ;
}else if(score >= 60 && score <70){
System.out.println("该学生成绩及格...") ;
}else{
System.out.println("该学生成绩不及格...") ;
}
}
}
//键盘录入两个数据,求最大值!if...else方式
//导包
import java.util.Scanner;
class IfTest{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请输入第一个数据:") ;
int firstNumber = sc.nextInt() ;
System.out.println("请输入第二个数据:") ;
int secondNumber = sc.nextInt() ;
//if语句实现
//定义变量
int max ;
if(firstNumber > secondNumber){
max = firstNumber ;
}else{
max = secondNumber;
}
System.out.println("两个数据的最大值是:"+max) ;
System.out.println("---------------------------") ;
//三元
int max2 = (firstNumber > secondNumber) ? firstNumber : secondNumber ;
System.out.println("两个数据的最大值是:"+max2) ;
}
}
流程控制语句_if格式的嵌套
/*
if语句格式2的嵌套:
if(表达式){
//表达式成立
if(表达式1){
语句1;
}else{
语句2;
}
}else{
//不成立
if(表达式11){
语句11;
}else{
语句22;
}
}
流程:
首先判断外层if中表达式是否成立,
如果成立,执行表达式2是否成立
如果表达式2成立,执行语句1;否则,执行语句2;
外层if中表达式不成立,就执行else中的语句
首先判断表达式11是否成立,如果成立,执行语句11,
否则执行语句22;
需求:键盘录入三个数据:求三个数据最大值
*/
//导包
import java.util.Scanner ;
class IfTest{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示,并接收数据
System.out.println("请输入第一个数据:");
int a = sc.nextInt() ;
System.out.println("请输入第一个数据:");
int b = sc.nextInt() ;
System.out.println("请输入第一个数据:");
int c = sc.nextInt() ;
//操作判断
//方式1:中间变量的方式+三元运算符
int temp = (a>b) ? a: b ;
//使用max变量接收
int max = (temp > c ) ? temp : c ;
System.out.println("三个数据中的最大值是:"+max) ;
System.out.println("---------------------------");
//方式2:三元运算符一步走:
int max2 = (a>b) ? ((a > c) ? a: c) :((b > c) ? b : c) ;
System.out.println("三个数据中的最大值是:"+max2) ;
System.out.println("---------------------------");
//方式3:使用if语句格式嵌套
//定义一个变量max3
int max3 ;
if( a > b){
//a>b成立
if(a > c){
//a比c大
max3 = a ;
}else{
//c比a大
max3 = c ;
}
}else{
//不成立
if(b > c){
//b比c大
max3 = b ;
}else{
//c比b大
max3 = c ;
}
}
System.out.println("三个数据中的最大值是:"+max3) ;
}
}
/*
数学表达式:
x >=3 y=2x+1
-1=<x<3 y=2x
x<-1 y=2x-1
键盘录入x的值,求y的值
*/
//导包
import java.util.Scanner ;
class IfTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请输入的x值:") ;
int x = sc.nextInt() ;
//if(){}...else if(){}...else{}...
int y ;
if(x >= 3){
y = 2*x + 1 ;
}else if(x>=-1 && x < 3){
y = 2 * x ;
}else{
y= 2 * x - 1;
}
//y的值
System.out.println("y:"+y);
}
}
/*
键盘录入月份的值,判断季节
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12,1,2 冬季
考虑:
测试:错误数据
正确数据
边界数据
*/
//导包
import java.util.Scanner;
class IfTest3{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请输入一个月份的值: ") ;
int month = sc.nextInt() ;
//判断
/*
if(month == 3 || month == 4 || month == 5){
System.out.println("该月份是春季") ;
}else if(month == 6 || month == 7 || month == 8){
System.out.println("该月份是夏季") ;
}else if(month == 9 || month == 10 || month == 11){
System.out.println("该月份是秋季") ;
}else if(month ==12 || month == 1 || month ==2){
System.out.println("该月份是冬季") ;
}else{
System.out.println("非法数据!") ;
}
*/
if(month > 12 || month < 1){
System.out.println("非法数据!") ;
}else if(month >=3 && month <= 5){
System.out.println("该月份是春季") ;
}else if(month >= 6 && month <= 8){
System.out.println("该月份是夏季") ;
}else if(month >= 9 && month <= 11){
System.out.println("该月份是秋季") ;
}else{
System.out.println("该月份是冬季") ;
}
}
}
选择结构语句之_switch
/*
switch语句的格式
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
...
...
default:
语句n;
break ;
}
执行流程:
1)先判断表达式的值它和case语句值1,是否匹配
如果匹配,执行语句1,遇见break ,switch语句结束了!
2)如果值1不匹配,继续判断值2是否和表达式中的值是否匹配,如果匹配,执行语句2
遇见break,switch语句结束!
3)如果上面的所有case语句都不匹配,执行default语句,执行语句n,直接结束
面试题:
switch表达式可以是byte类型吗?
可以是String类型吗?
可以是char类型吗?
可以是枚举类型吗?
switch(表达式)---->本身可以使用的类型:byte,short,char,int类型
JDK5以后可以枚举enum(引用类型--->定义常量) 后面讲(Java高级部分多线程Thread类: State(枚举类型))
JDK7以后:可以使用String类型
需求:
键盘录入一个数据,判断星期 (使用switc语句完成)
1,星期一
2,星期二
3,星期三
4,星期四
5,星期五
6,星期六
7,星期天
*/
//导包
import java.util.Scanner;
class SwitchDemo{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请您输入一个数据:") ;
int weekDate = sc.nextInt() ;
switch(weekDate){
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 ;
}
}
}
/*
switch语句使用的注意事项:
1)switch语句中的case语句后面跟的常量值,不能跟变量!
对比:javascript:switch语句 中的case可以是常量也可以变量
2)case语句中的break不能轻易省略,否则就会造成"case穿透"
如果没有写break,跟下面case值不进行比较,直接运行语句,直到遇见break结束!
3)switch中的default语句:书写位置默认是在末尾,但是它也可以在switch语句中的任何位置,但是不影响执行流程
都需要先跟case中的值进行比较,如果都没有匹配,都需要执行default...
如果default在语句的末尾,break可以省略,如果在语句中的话,不建议省略break ;
4)关于switch语句的结束问题:
1)遇见break (中断,结束的意思) ,switch语句结束
break:属于跳转控制语句中一种:两种场景:switch中/循环语句中
2)语句默认执行到末尾!
*/
import java.util.Scanner ;
class SwitchDemo2{
public static void main(String[] args){
//break ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请您输入一个数据:") ;
int weekDate = sc.nextInt() ;
//定义变量
int number = 3 ;
switch(weekDate){
default : //末尾
System.out.println("非法数据!!") ;
//break ;
case 1: //1
System.out.println("星期一") ;
break ;
case 2:
System.out.println("星期二") ;
break ;
//case number: // 错误: 需要常量表达式
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 ;
}
}
}
/*
看程序,写结果
*/
class SwitchTest{
public static void main(String[] args){
//两个变量
int a = 2 ;
int b = 3 ;
switch(a){
default :
b ++ ; //b=3 --> 4
break ; //遇见break:switch语句
case 3:
b ++ ;
case 4:
b ++ ;
}
System.out.println("b:"+b) ;
System.out.println("-----------------------") ;
//两个变量
int x = 2 ;
int y = 3 ;
switch(x){//x=2
default :
y++ ; //y=3 ++ ===>4
case 3:
y ++ ; //4 +1===>5
case 4:
y ++ ;//5+1 ===>6
}
System.out.println("y:"+y) ;
System.out.println("-----------------------") ;
int m = 2 ;
int n = 3 ;
switch(m){//m=2
default :
n++ ;
case 2:
n ++ ; //n++ --->4
//break ;
case 4:
n ++ ; //n++--->4+1 = 5
}
System.out.println("n:"+n) ;
}
}
/*
键盘录入月份的值,判断季节(switch语句完成)
3,4,5 春季
6,7,8 夏季
9,10,11 秋季
12,1,2 冬季
*/
//导包
import java.util.Scanner ;
class SwitchTest2{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请输入一个月份的值:") ;
int month = sc.nextInt() ;
//方式1:普通方式
/*
switch(month){
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 ;
case 8:
System.out.println("夏季") ;
break ;
case 9:
System.out.println("秋季") ;
break ;
case 10:
System.out.println("秋季") ;
break ;
case 11:
System.out.println("秋季") ;
break ;
case 12:
System.out.println("冬季") ;
break ;
default:
System.out.println("非法数据!!") ;
break ;
}
*/
//方式2:利用case穿透
switch(month){
case 1:
case 2:
case 12:
System.out.println("冬季");
break ;
case 3:
case 4:
case 5:
System.out.println("春季");
break ;
case 6:
case 7:
case 8:
System.out.println("夏季");
break ;
case 9:
case 10:
case 11:
System.out.println("秋季");
break ;
default:
System.out.println("非法数据!!!");
break ;
}
}
}
/*
需求:
键盘录入一个选择: Scanner类--->录入不了字符类型
模拟一个单项选择题 使用switch语句操作
'A' 'B' 'C' 'D'
ASCII码表
//你喜欢的明星?
输出("65 xxx") ;
66
67
68
Scanner sc = new Scanner(System.in) ;
录入int类型 int choice = sc.nextInt() ;
//强制类型转换--->choice--->char ch = (char)choice ;
switch( ch)}{
case 'A':
case 'B' :
case 'C' :
case 'D' :
..
default:
...
}
*/
//导包
import java.util.Scanner ;
class SwitchTest3{
public static void main(String[] args){
//提供几个选项
System.out.println("您喜欢的明星?") ;
System.out.println("65 高圆圆") ;
System.out.println("66 白百何") ;
System.out.println("67 李小璐") ;
System.out.println("68 马蓉") ;
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请输入一个选项:") ;
int choice = sc.nextInt() ;
//强转
char choiceNumber = (char)choice ;
switch(choiceNumber){
case 'A' :
System.out.println("答案正确!") ;
break ;
case 'B' :
System.out.println("对不起,答案有误!") ;
break ;
case 'C' :
System.out.println("对不起,答案有误!") ;
break ;
case 'D' :
System.out.println("对不起,答案有误!") ;
break ;
default :
System.out.println("没有提供该选项") ;
break ;
}
}
}
/*
Scanner类----->常用类中讲
int nextInt():接收int类型数据
String nextLine():接收字符串类型的数据 (推荐这个:正式的写法)
String next() :也可以录入字符串
*/
//导包
import java.util.Scanner ;
class SwitchTest4{
public static void main(String[] args){
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并接收数据
System.out.println("请您输入一个数据:") ;
//int num = sc.nextInt() ;
// java.util.InputMismatchException(异常类) :输入的类型和结果类型不匹配
//System.out.println("num:"+num) ;
//专门录入字符串的方法
String ss = sc.nextLine() ;
//System.out.println("您输入的数据是:"+ss) ;
//判断用户输入的字符串数据值
switch(ss){//JDK7版本以后可以跟String类型(特殊的引用类型!)
case "hello":
System.out.println("您录入的字符串是hello") ;
break ;
case "world":
System.out.println("您录入的字符串是world") ;
break ;
case "JavaEE":
System.out.println("您录入的字符串是JavaEE") ;
break ;
default:
System.out.println("没有提供这个字符串") ;
break ;
}
}
}
循环结构语句之for
/*
循环结构语句分类:
for循环
while循环
do-while循环
需求:
请求在控制台输出10次 "helloworld"
*/
class Demo{
public static void main(String[] args){
//最原始的做法
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
}
}
/*
for循环的格式:
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
执行流程:
1)初始化语句给变量进行赋值,只执行一次
2)判断这个条件表达式是否成立,
如果成立,就执行循环体语句,在去执行步长语句 (++,--)
3)再次判断条件表达式是否成立,如果成立,继续上面执行方式...
...
...
4)一直循环到条件表达式不成立的时候,for循环结束!
需求:
请求在控制台输出10次 "helloworld"(明确循环次数了)
*/
class ForDemo{
public static void main(String[] args){
//最原始的做法
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("helloworld") ;
System.out.println("----------------------------") ;
/*
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
*/
// 初始化语句 条件表达式 步长语句(控制体语句)
for(int x = 1 ; x <= 10 ; x ++){ //x = 1 1 <=10 x++ :1++ = 2
//x=2 <=10
//x=3 <=10
//...
//x = 10 x++ = 11 <= 10(不成立)
//循环体语句
System.out.println("helloworld") ;//1次 //第二次 第三次........第十次
}
//System.out.println(x) ;
}
}
/*
需求:
控制台输出:
1~10的数据:
*/
class ForTest{
public static void main(String[] args){
//1,2,3,4,5,6,7,8,9,10
//原始的做法:
System.out.println(1) ;
System.out.println(2) ;
System.out.println(3) ;
System.out.println(4) ;
System.out.println(5) ;
System.out.println(6) ;
System.out.println(7) ;
System.out.println(8) ;
System.out.println(9) ;
System.out.println(10) ;
System.out.println("-------------------------------") ;
//上面原始做法:代码冗余(重复度高)
//优化:
//for循环
for(int x = 1; x <= 10 ; x ++){
//x=1,x<= 10 ---->System.out.println(1) ----> x++ --2
//x=2, x<=10 ---->System.out.println(2)----->x++ --3
//x=3 , x <=10 ---->System.out.println(3)
//循环体
System.out.println(x) ;//1,2,.....
}
}
}
/*
求:1-10之间的和 (求和思想)
分析:
1-10之间的和:
0 + 1 = 1
1 + 2 = 3 ;
3 + 3 = 6;
6 + 4 = 10 ;
10 + 5 = 15 ;
15 + 6 = 21 ....
...
两个加数:
第一个加数:是上一次计算的结果:和
第二个加数:就是当前数据本身(1,2,3,4,5,6...)
步骤:
1)定义一个最终的结果变量 :最终的一个值 int sum = 0 ;
2)将1,..10之间的数据遍历(一一获取出来)
3)将当前sum值一次和数据本身做一个 +=
举例:
int sum = 0 ;
sum += 1 ;--> sum = sum + 1 ;
sum += 2 --->sum = sum + 2
sum =1 + 2 = 3
需求:
1-100之间的和
1-100之间的偶数和
*/
class ForTest2{
public static void main(String[] args){
//原始的做法
System.out.println(1+2+3+4+5+6+7+8+9+10) ;
//上面代码:写麻烦
//求和思想
//定义一个最终结果变量
int sum = 0 ;
for(int x = 1 ; x <= 10 ; x ++){
//x =1,2,3,4,5,6,7,8,9,10
sum = sum + x ; //循环体语句
//sum = 0 + 1 ; //sum = 0,x = 1
//sum = sum + 2 //sum = 1 ,x = 2 --- 3
//sum = sum + 3
//0 + 1 = 1
// 1+ 2 = 3 ;
//3 + 3 = 6
//....
//sum += x ;
}
System.out.println("1-10之间的和是:"+sum) ;
}
}
本人技术有限,以上所写内容如有错误,欢迎交流指正.
for循环的格式:
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
执行流程:
1)初始化语句给变量进行赋值,只执行一次
2)判断这个条件表达式是否成立,
如果成立,就执行循环体语句,在去执行步长语句 (++,–)
3)再次判断条件表达式是否成立,如果成立,继续上面执行方式…
…
...
4)一直循环到条件表达式不成立的时候,for循环结束!
需求:
请求在控制台输出10次 "helloworld"(明确循环次数了)
*/
class ForDemo{
public static void main(String[] args){
//最原始的做法
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println(“helloworld”) ;
System.out.println("----------------------------") ;
/*
for(初始化语句;条件表达式;步长语句){
循环体语句;
}
*/
// 初始化语句 条件表达式 步长语句(控制体语句)
for(int x = 1 ; x <= 10 ; x ++){ //x = 1 1 <=10 x++ :1++ = 2
//x=2 <=10
//x=3 <=10
//...
//x = 10 x++ = 11 <= 10(不成立)
//循环体语句
System.out.println("helloworld") ;//1次 //第二次 第三次........第十次
}
//System.out.println(x) ;
}
}
/*
需求:
控制台输出:
1~10的数据:
*/
class ForTest{
public static void main(String[] args){
//1,2,3,4,5,6,7,8,9,10
//原始的做法:
System.out.println(1) ;
System.out.println(2) ;
System.out.println(3) ;
System.out.println(4) ;
System.out.println(5) ;
System.out.println(6) ;
System.out.println(7) ;
System.out.println(8) ;
System.out.println(9) ;
System.out.println(10) ;
System.out.println("-------------------------------") ;
//上面原始做法:代码冗余(重复度高)
//优化:
//for循环
for(int x = 1; x <= 10 ; x ++){
//x=1,x<= 10 ---->System.out.println(1) ----> x++ --2
//x=2, x<=10 ---->System.out.println(2)----->x++ --3
//x=3 , x <=10 ---->System.out.println(3)
//循环体
System.out.println(x) ;//1,2,.....
}
}
}
/*
求:1-10之间的和 (求和思想)
分析:
1-10之间的和:
0 + 1 = 1
1 + 2 = 3 ;
3 + 3 = 6;
6 + 4 = 10 ;
10 + 5 = 15 ;
15 + 6 = 21 ....
...
两个加数:
第一个加数:是上一次计算的结果:和
第二个加数:就是当前数据本身(1,2,3,4,5,6...)
步骤:
1)定义一个最终的结果变量 :最终的一个值 int sum = 0 ;
2)将1,..10之间的数据遍历(一一获取出来)
3)将当前sum值一次和数据本身做一个 +=
举例:
int sum = 0 ;
sum += 1 ;--> sum = sum + 1 ;
sum += 2 --->sum = sum + 2
sum =1 + 2 = 3
需求:
1-100之间的和
1-100之间的偶数和
*/
class ForTest2{
public static void main(String[] args){
//原始的做法
System.out.println(1+2+3+4+5+6+7+8+9+10) ;
//上面代码:写麻烦
//求和思想
//定义一个最终结果变量
int sum = 0 ;
for(int x = 1 ; x <= 10 ; x ++){
//x =1,2,3,4,5,6,7,8,9,10
sum = sum + x ; //循环体语句
//sum = 0 + 1 ; //sum = 0,x = 1
//sum = sum + 2 //sum = 1 ,x = 2 --- 3
//sum = sum + 3
//0 + 1 = 1
// 1+ 2 = 3 ;
//3 + 3 = 6
//....
//sum += x ;
}
System.out.println("1-10之间的和是:"+sum) ;
}
}
本人技术有限,以上所写内容如有错误,欢迎交流指正.
1619
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
