1. 注释
同C++等其它编程语言一样，注释就是对代码的解释和说明文字。（区别可能是注释的方式不同，例如python是#，matlab是%）
Java中的注释分为三种：
-
单行注释：
// 这是单行注释文字
-
多行注释：
/* 这是多行注释文字 这是多行注释文字 这是多行注释文字 */ 注意：多行注释不能嵌套使用。
-
文档注释：
/** 这是多行注释文字 这是多行注释文字 这是多行注释文字 */
使用的技巧
如果我们要对代码进行解释，那么就可以使用注释。
当注释的内容比较少，一行就写完了，可以用单行注释。
如果注释的内容比较多，需要写在多行，那么可以使用多行注释。
注意点
注释的内容不会参与编译和运行的，仅仅是对代码的解释说明而已。
所以，不管在注释当中写什么内容，都不会影响代码运行的结果。
2. 关键字
概念
被Java赋予了特定含义的英文单词。
关键字很多，不用刻意去记。
| abstract | assert | boolean | break | byte |
|---|---|---|---|---|
| case | catch | char | class | const |
| continue | default | do | double | else |
| enum | extends | final | finally | float |
| for | goto | if | implements | import |
| instanceof | int | interface | long | native |
| new | package | private | protected | public |
| return | strictfp | short | static | super |
| switch | synchronized | this | throw | throws |
| transient | try | void | volatile | while |
第一个关键字class
表示定义一个类。创建一个类。
类：Java项目最基本的组成单元，一个完整的Java项目有可能会有成千上万个类来组成的。
class后面跟随的就是这个类的名字，简称：类名。
在类名后面会有一对大括号，表示这个类的内容。
举例：
public class HelloWorld{
}
解释：class表示定义类。
类名：HelloWorld
HelloWorld后面的大括号表示这个类的范围。
3. 字面量
作用：告诉程序员，数据在程序中的书写格式。
| 字面量类型 | 说明 | 程序中的写法 |
|---|---|---|
| 整数 | 不带小数的数字 | 666，-88 |
| 小数 | 带小数的数字 | 13.14，-5.21 |
| 字符 | 必须使用单引号，有且仅能一个字符 | ‘A’，‘0’， ‘你’ |
| 字符串 | 必须使用双引号，内容可有可无 | “HelloWorld”，“宝贝” |
| 布尔值 | 布尔值，表示真假，只有两个值：true，false | true 、false |
| 空值 | 一个特殊的值，空值 | 值是：null |
public class Demo {
public static void main(String[] args) {
System.out.println(10); // 输出一个整数
System.out.println(5.5); // 输出一个小数
System.out.println('a'); // 输出一个字符
System.out.println(true); // 输出boolean值true
System.out.println("欢迎来到黑马程序员"); // 输出字符串
}
}
区分技巧
-
不带小数点的数字都是整数类型的字面量。
-
只要带了小数点，那么就是小数类型的字面量。
-
只要用双引号引起来的，不管里面的内容是什么，不管里面有没有内容，都是字符串类型的字面量。
-
字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个。
-
字符类型的字面量只有两个值，true、false。
-
空类型的字面量只有一个值，null。
4. 变量
4.1 什么是变量？
变量就在程序中临时存储数据的容器。但是这个容器中只能存一个值。
4.2 变量的定义格式
数据类型 变量名 = 数据值；
4.2.1 格式详解
数据类型：限定了变量当中能存储什么类型的数据。
如果要存10，那么数据类型就需要写整数类型。
如果要存10.0，那么数据类型就需要写小数类型。
变量名：其实就是这个容器的名字。
当以后想要使用变量里面的数据时，直接使用变量名就可以了。
数据值：真正存储在容器中的数据。
分号：表示语句的结束，就跟以前写作文时候的句号是一样的。
4.2.2 常用的数据类型
整数：int
小数（浮点数）：double
其他数据类型稍后讲解
举例：
public class VariableDemo{
public static void main(String[] args){
//定义一个整数类型的变量
//数据类型 变量名 = 数据值;
int a = 16;
System.out.println(a);//16
//定义一个小数类型的变量
double b = 10.1;
System.out.println(b);//10.1
}
}
4.2.3 变量的注意事项
-
变量名不能重复
-
在一条语句中，可以定义多个变量。但是这种方式影响代码的阅读，所以了解一下即可。
-
变量在使用之前必须要赋值。
案例：
public class VariableDemo2{
public static void main(String[] args){
//1.变量名不允许重复
//int a = 10;
//int a = 20;
//System.out.println(a);
//2.一条语句可以定义多个变量
//了解。
//int a = 10, b = 20, c = 20,d = 20;
//System.out.println(a);//?
//System.out.println(b);//?
//3.变量在使用之前必须要赋值
int a = 30;
System.out.println(a);
}
}
4.3 变量的练习
题目：说出公交车到终点站之后，车上一共有多少乘客？
一开始没有乘客。
第一站：上去一位乘客，没有下来乘客。
第二站：上去两位乘客，下来一位乘客。
第三站：上去两位乘客，下来一位乘客。
第四站：没有上去乘客，下来一位乘客。
第五站：上去一位乘客，没有下来乘客。
问：到了终点站之后，车上一共多少乘客？
代码
public class VariableTest1{
//主入口
public static void main(String[] args){
//一开始没有乘客。
int count = 0;
//第一站：上去一位乘客
//在原有的基础上 + 1
count = count + 1;
//System.out.println(count);
//第二站：上去两位乘客，下来一位乘客
count = count + 2 - 1;
//第三站：上去两位乘客，下来一位乘客
count = count + 2 - 1;
//第四站：下来一位乘客
count = count - 1;
//第五站：上去一位乘客
count = count + 1;
//请问：到了终点站，车上一共几位乘客。
System.out.println(count);//3
}
}
5. 数据类型
5.1 Java语言数据类型的分类
-
基本数据类型
-
引用数据类型（面向对象的时候再深入学习）
5.2 基本数据类型的四类八种
字面量（数据在程序中的书写形式）
-
整数类型
-
小数类型
-
字符串类型 双引号
-
字符类型 单引号而且内容只有一个
-
布尔类型
-
空类型 值是
null（不能直接打印）
/t制表符
在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最多补1个空格，最多补8个空格。
基本数据类型
-
整数
byte范围（-128~+127）shortint（默认）long若要定义long类型的变量，要在数据值的后面加一个L后缀 -
浮点数
float定义float类型变量时要加F后缀double（默认） -
字符
char -
布尔
boolean
取值范围关系：double > float > long > int > short > byte
String类型是字符串类型
标识符就是给类、方法、变量等起的名字
-
由数字、字母、下划线和美元符（
$）组成 -
不能以数字开头
-
不能是关键字
-
区分大小写
Scanner类可以接收键盘输入的数字
-
导包
import java.util.Scanner; -
创建对象
Scanner sc = new Scanner(System.in); -
接收数据
int i = sc.nextInt();
| 数据类型 | 关键字 | 内存占用 | 取值范围 |
|---|---|---|---|
| 整数 | byte | 1 | 负的2的7次方 ~ 2的7次方-1(-128~127) |
short | 2 | 负的2的15次方 ~ 2的15次方-1(-32768~32767) | |
int | 4 | 负的2的31次方 ~ 2的31次方-1 | |
long | 8 | 负的2的63次方 ~ 2的63次方-1 | |
| 浮点数 | float | 4 | 1.401298e-45 ~ 3.402823e+38 |
double | 8 | 4.9000000e-324 ~ 1.797693e+308 | |
| 字符 | char | 2 | 0-65535 |
| 布尔 | boolean | 1 | true，false |
说明
e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。
在java中整数默认是int类型，浮点数默认是double类型。
需要记忆以下几点
byte类型的取值范围：
-128 ~ 127
int类型的大概取值范围：
-21亿多 ~ 21亿多
整数类型和小数类型的取值范围大小关系：
double > float > long > int > short > byte
最为常用的数据类型选择：
-
在定义变量的时候，要根据实际的情况来选择不同类型的变量。
比如：人的年龄，可以选择
byte类型。比如：地球的年龄，可以选择
long类型。 -
如果整数类型中，不太确定范围，那么默认使用
int类型。 -
如果小数类型中，不太确定范围，那么默认使用
double类型。 -
如果要定义字符类型的变量，那么使用
char -
如果要定义布尔类型的变量，那么使用
boolean
5.3 定义8种基本数据类型变量
public class VariableDemo3{
public static void main(String[] args){
//1.定义byte类型的变量
//数据类型 变量名 = 数据值;
byte a = 10;
System.out.println(a);
//2.定义short类型的变量
short b = 20;
System.out.println(b);
//3.定义int类型的变量
int c = 30;
System.out.println(c);
//4.定义long类型的变量
long d = 123456789123456789L;
System.out.println(d);
//5.定义float类型的变量
float e = 10.1F;
System.out.println(e);
//6.定义double类型的变量
double f = 20.3;
System.out.println(f);
//7.定义char类型的变量
char g = 'a';
System.out.println(g);
//8.定义boolean类型的变量
boolean h = true;
System.out.println(h);
}
}
注意点
-
如果要定义 一个整数类型的变量，不知道选择哪种数据类型了，默认使用
int。 -
如果要定义 一个小数类型的变量，不知道选择哪种数据类型了，默认使用
double。 -
如果要定义一个long类型的变量，那么在数据值的后面需要加上
L后缀。（大小写都可以，建议大写。） -
如果要定义一个float类型的变量，那么在数据值的后面需要加上
F后缀。（大小写都可以）
5.4 练习1
题目：定义5个变量记录老师的信息并打印
代码示例：
public class VariableTest1{
public static void main(String[] args){
//1.定义字符串类型的变量记录老师的姓名
String name = "黑马谢广坤";
//2.定义整数类型的变量记录老师的年龄
int age = 18;
//3.定义字符类型的变量记录老师的性别
char gender = '男';
//4.定义小数类型的变量记录老师的身高
double height = 180.1;
//5.定义布尔类型的变量记录老师的婚姻状况
boolean flag = true;
//输出5个变量的值
System.out.println(name);
System.out.println(age);
System.out.println(gender);
System.out.println(height);
System.out.println(flag);
}
}
5.5 练习2
题目：将（电影名称，主演，年份，评分）四个信息选择不同类型的变量，随后打印出来。
代码示例：
public class VariableTest2{
public static void main(String[] args){
//1.定义字符串变量记录电影的名称
String movie = "送初恋回家";
//2.定义三个变量记录主演的名字
String name1 = "刘鑫";
String name2 = "张雨提";
String name3 = "高媛";
//3. 定义整数类型的变量记录年龄的年份
int year = 2020;
//4.定义小数类型的变量记录电影的评分
double score = 9.0;
//打印变量的信息
System.out.println(movie);
System.out.println(name1);
System.out.println(name2);
System.out.println(name3);
System.out.println(year);
System.out.println(score);
}
}
5.6 练习3
题目：选择其中一部手机，将（手机价格，手机品牌）两个信息选择不同类型的变量，随后打印出来。
代码示例：
public class VariableTest3{
public static void main(String[] args){
//1.定义小数类型的变量记录手机的价格
double price = 5299.0;
//2.定义字符串类型的变量记录手机的品牌
String brand = "华为";
//输出变量记录的值
System.out.println(price);
System.out.println(brand);
}
}
6. 标识符
业内大多数程序员都在遵守阿里巴巴的命名规则。
在day02的资料文件夹中有。
6.1 硬性要求
必须要这么做，否则代码会报错。
-
必须由数字、字母、下划线_、美元符号$组成。
-
数字不能开头
-
不能是关键字
-
区分大小写的。
6.2 软件建议
如果不这么做，代码不会报错，但是会让代码显得比较low。
6.2.1 小驼峰命名法
适用于变量名和方法名
-
标识符是一个单词的时候，全部小写，比如：name
-
标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写，比如：firstName、maxAge
6.2.2 大驼峰命名法
适用于类名
-
标识符是一个单词的时候，首字母大写。例如：
Demo、Test。 -
标识符由多个单词组成的时候，每个单词的首字母大写。比如：
HelloWorld
不管起什么名字，都要做到见名知意。
阿里巴巴命名规范细节
-
尽量不要用拼音。但是一些国际通用的拼音可视为英文单词。
正确：
alibaba、hangzhou、nanjing错误：
jiage、dazhe -
平时在给变量名、方法名、类名起名字的时候，不要使用下划线或美元符号。
错误：
_name正确：
name
7. 运算符与表达式
运算符
就是对常量或者变量进行操作的符号。
比如： + - * /
表达式
用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。
比如：a + b 这个整体就是表达式。
而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。
7.1 算术运算符
分类：
+ - * / %
运算特点：
+ - * :跟小学数学中一模一样没有任何区别.
/： 1.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。 2.小数直接参与运算，得到的结果有可能是不精确的。 案例： System.out.println( 10 / 3);//3 System.out.println(10.0 / 3);//3.3333333333333335
%：取模、取余。 他做的也是除法运算，只不过获取的是余数而已。 案例： System.out.println(10 % 2);//0 System.out.println(10 % 3);//1 应用场景： //可以利用取模来判断一个数是奇数还是偶数 System.out.println(15 % 2);//1 奇数
练习：数值拆分
题目要求
键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台
原理：
个位：数字 % 10
十位：数字 / 10 % 10
百位：数字 / 100 % 10
千位：数字 / 1000 % 10
以此类推......
代码示例：
//1.键盘录入一个三位数
//导包 --- 创建对象 --- 接收数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();//123
//2.获取这个三位数的个位、十位、百位并打印出来
//公式：
//针对于任意的一个数而言
//个位： 数字 % 10
int ones = number % 10;
//十位： 数字 / 10 % 10
int tens = number / 10 % 10;
//百位： 数字 / 100 % 10
int hundreds = number / 100 % 10;
//输出结果
System.out.println(ones);
System.out.println(tens);
System.out.println(hundreds);
7.2 隐式转换与强制转换
7.2.1 隐式转换
概念
也叫自动类型提升
就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的.
简单记忆
就是小的给大的，可以直接给.
两种提升规则
-
取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算.
-
byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算.
取值范围从小到大的关系
byte short int long float double
练习
请看下面案例是否有误，如果有问题，请说出原因，如果没有问题，请说出运算过程和运算结果
案例一
double d = 10; System.out.println(d);//10.0
解释：
10是整数，整数默认是int类型的。
而在取值范围的顺序中：byte short int long float double
在赋值的时候把一个int类型的赋值给了一个double类型的，把一个小的赋值给一个大的是可以直接给的.
案例二
byte b = 100; int i = b;//可以成功赋值
解释：
因为byte的取值范围是小的，int的取值范围是大的，在底层进行了隐式转换，不需要我们额外写代码单独实现，是可以直接赋值。
案例三
int i = 10; long n = 20L; ??? result = i + n; 问变量result是什么类型的？
解释：
变量i是int类型的，变量n是long类型的。
而在取值范围的顺序中：byte short int long float double
变量i里面的值会自动提升为long类型的，最终的结果其实就是两个long相加，那么最终的result是long类型的。
案例四
int i = 10; long n = 100L; double d = 20.0; ??? result = i + n + d; 问变量result是什么类型的？
解释：
变量i是int类型的，变量n是long类型，变量d是double类型。
而在取值范围的顺序中：byte short int long float double
所以变量i和变量n里面的值在参与运算的时候，都会进行类型提升，变成double。
最终其实就是三个double进行相加，那么最终的结果就是double类型的。
案例五
byte b1 = 10; byte b2 = 20; ??? result = b1 + b2;//int 问变量result是什么类型的？
解释：
因为b1和b2都是byte类型的，所以在参与计算的时候，变量b1和变量b2里面的值都会自动提升为int类型的。最终其实就是两个int类型的相加，最终结果也是int类型的。
案例六
byte b = 10; short s = 20; long n = 100L; ??? result = b + s + n; 问变量result是什么类型的？long
解释：
变量b是byte类型的，变量s是short类型的，变量n是long类型的。
byte，short，char类型的变量在参与运算的时候，变量里面的值会直接先提升为int。
第一步：变量b和变量s里面的值会先提升为int参与运算。
int + int + long
第二步：而long类型的取值范围是大于int的取值范围的。
所以变量b和变量s里面的值会再次提升为long。
long + long + long
所以最终结果是long类型的。
7.2.2 强制转换
概念
如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。
如果一定要这么干，就需要加入强制转换。
书写格式
目标数据类型 变量名 = （目标数据类型）被强转的数据；
简单理解：
要转成什么类型的，那么就在小括号中写什么类型就可以了。
案例：
public class OperatorDemo2 {
public static void main(String[] args) {
double a = 12.3;
int b = (int) a;
System.out.println(b);//12
}
}
注意点：
强制转换有可能会导致数据发生错误。（数据的精度丢失）
7.3 自增自减运算符
分类
++ 自增运算符 -- 自减运算符
++：就是把变量里面的值+1
--：就是把变量里面的值-1
使用方式
-
放在变量的前面，我们叫做先++。 比如：++a
-
放在变量的后面，我们叫做后++。 比如：a++
注意点
不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。
案例
int a = 10; int b = a++;//先用后加,b=10
int a = 10; int b = ++a;//先加后用,b=11
public class Test{
public static void main(String[] args){
int x = 10;
int y = x++;//把10赋给y,再加1
int z = ++x;//先把x(11)加1再赋给z
System.out.println("x:"+x); //12
System.out.println("y:"+y); //10
System.out.println("Z:"+z); //12
}
}
自增自减运算符的应用场景
某些情况下，变量需要进行加1或者减1的时候使用。
比如：过生日多一岁，就用到了自增运算符。
比如：购物商场中，选择商品数量，也用到了自增或者自减运算符。
比如：统计很多数据中，有多少个数据满足要求，也用到了自增运算符。
7.4 赋值运算符
符号：=
运算过程：就是把等号右边的结果赋值给左边的变量
案例
public class OperatorDemo6 {
public static void main(String[] args) {
//1.最为简单的赋值运算符用法
int a = 10;//就是把10赋值给变量a
System.out.println(a);
//2.如果等号右边需要进行计算。
int b = 20;
int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
System.out.println(c);
//3.特殊的用法
a = a + 10;//先计算等号右边的，把计算的结果赋值给左边的变量
System.out.println(a);//20
}
}
扩展赋值运算符
分类
+=，-=，*=，/=，%=
运算规则
就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。
案例
public class OperatorDemo7 {
public static void main(String[] args) {
//扩展赋值运算符
int a = 10;
int b = 20;
a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响
// 相当于 a = a + b;
System.out.println(a);//30
System.out.println(b);//20
}
}
注意点
扩展的赋值运算符中隐层还包含了一个强制转换。
以+=为例。
a += b ;实际上相当于 a = (byte)(a + b);
案例
short s = 1; s += 1; //并不完全等同于s = s + 1,而是等同于s = (short) (s + 1); System.out.println(s); //2 //+=,-=,*=,/=,%=都隐藏了一个强制类型转换
public class OperatorDemo8 {
public static void main(String[] args) {
byte a = 10;
byte b = 20;
//a += b;
a = (byte)(a + b);
System.out.println(a);//30
}
}
7.5 关系运算符
分类
| 符号 | 解释 |
|---|---|
| == | 就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false |
| != | 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false |
| > | 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false |
| >= | 就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false |
| < | 就是判断左边是否小于右边，如果成立就是true，如果不成立就是false |
| <= | 就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false |
注意点
-
关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
-
在写==的时候，千万不要写成=
7.6 逻辑运算符
将5<x<15拆分成x>5&x<15
-
&（逻辑与）
-
|（逻辑或）
//& System.out.println(true & true);//true System.out.println(false & false);//false System.out.println(true & false);//false System.out.println(false & true);//false //| System.out.println(true | true);//true System.out.println(false | false);//false System.out.println(true | false);//true System.out.println(false | true);//true
-
^（逻辑异或） 相同为false，不同为true
-
!（逻辑非）
//^ System.out.println(true ^ true);//false System.out.println(false ^ false);//false System.out.println(true ^ false);//true System.out.println(false ^ true);//true //! System.out.println(!true);//false System.out.println(!false);//true
& 和 | 的使用
&：逻辑与（而且）
两边都为真，结果才是真，只要有一个为假，那么结果就是假。
|：逻辑或（或者）
两边都为假，结果才是假，只要有一个为真，那么结果就是真。
代码示例：
// & //两边都是真，结果才是真。
System.out.println(true & true);//true
System.out.println(false & false);//false
System.out.println(true & false);//false
System.out.println(false & true);//false
System.out.println("===================================");
// | 或 //两边都是假，结果才是假，如果有一个为真，那么结果就是真。
System.out.println(true | true);//true
System.out.println(false | false);//false
System.out.println(true | false);//true
System.out.println(false | true);//true
使用场景
根据固定的场景，来选择使用&还是使用|
-
用户登录。
用户名输入正确 & 密码输入正确
因为只有用户名和密码同时都正确了，那么才能成功登录，只要有一个失败了都不行。
使用技巧：
当我们需要同时满足左边和右边两种情况时，可以使用且
-
丈母娘选女婿
丈母娘：女婿啊，你要么买个房子，要么买辆车。就可以把我的小棉袄穿走了。
买个房子 | 买辆车
两个条件中，只要满足其中一个，就可以穿走小棉袄了。
使用技巧：
当两种条件只要满足其中一个的时候，可以使用或
^（异或）的使用
在以后用的不多，了解一下即可。
计算规则：如果两边相同，结果为false，如果两边不同，结果为true
代码示例：
//^ //左右不相同，结果才是true，左右相同结果就是false System.out.println(true ^ true);//false System.out.println(false ^ false);//false System.out.println(true ^ false);//true System.out.println(false ^ true);//true
!（取反）的使用
是取反，也叫做非。
计算规则：false取反就是true，true取反就是false
温馨提示：取反最多只用一个。
代码示例：
System.out.println(!false);//true System.out.println(!true);//false System.out.println(!!false);//注意点：取反最多只用一个。
7.7 短路逻辑运算符
分类： && ||
&&
运算结果跟&是一模一样的，只不过具有短路效果。
||
运算结果跟|是一模一样的。只不过具有短路效果。
逻辑核心
当左边不能确定整个表达式的结果，右边才会执行。
当左边能确定整个表达式的结果，那么右边就不会执行了。从而提高了代码的运行效率。
//&& System.out.println(true && true);//true System.out.println(false && false);//false System.out.println(true && false);//false System.out.println(false && true);//false //|| System.out.println(true || true);//true System.out.println(false || false);//false System.out.println(true || false);//true System.out.println(false || true);//true
int a = 10; int b = 10; boolean result = ++a<5 && ++b<5; System.out.println(result);//false System.out.println(a);//11 System.out.println(b);//10
int a = 10; int b = 10; boolean result = ++a<5 & ++b<5; System.out.println(result);//false System.out.println(a);//11 System.out.println(b);//11
举例
-
用户登录案例
用户名正确 & 密码正确
如果使用一个&，不管用户名是否正确都会去验证密码。
思考：
如果用户名输入正确了，那么我们再判断密码是否正确，是符合业务逻辑的。
但是如果用户名输入错误了，那么现在还有必要去比较密码吗？没有不要了。
如果使用一个&，那么左边和右边不管什么情况下，都会执行。
用户名正确 && 密码正确
如果用户名输入正确了，那么才会验证密码是否输入正确。
如果用户名输入错误了，那么就不会再去验证密码是否正确，最终的结果直接为false。从而提高了程序运行的效率。
-
丈母娘选女婿
有房 | 有车
首先先看看有没有房，发现有，然后再去看看有没有车。
思考：
既然都有房子，干嘛还要去看车呢？多此一举。
有房 || 有车
首先先看看有没有房，如果有，那么右边就不执行了。最终的结果直接为true。
如果没有房子，才会去看右边有没有车。
总结
&& 和 & 、||和|的运行结果都是一模一样的。
但是短路逻辑运算符可以提高程序的运行效率。
建议
最为常用： && || ！
7.8 三元运算符
三元运算符又叫做：三元表达式或者问号冒号表达式
格式
关系表达式 ? 表达式1 : 表达式2;
计算规则
-
计算关系表达式的值
-
如果关系表达式的值为真，那么执行表达式1
-
如果关系表达式的值为假，那么执行表达式2
注意点
三元运算符的最终结果一定要被使用，要么赋值给一个变量，要么直接打印出来
案例
public class OperatorDemo12 {
public static void main(String[] args) {
//题目：求两个数的较大值
int a = 10;
int b = 20;
//格式：关系表达式 ？ 表达式1 ： 表达式2 ；
//注意点：
//三元运算符的最终结果一定要被使用。
//要么赋值给一个变量，要么直接输出。
int max = a > b ? a : b ;
System.out.println(max);
System.out.println(a > b ? a : b);
}
}
练习
练习1-两只老虎
题目
动物园里有两只老虎，两只老虎的体重分别为通过键盘录入获得， 请用程序实现判断两只老虎的体重是否相同
代码示例
//1.获取两只老虎的体重
Scanner sc = new Scanner(System.in);
System.out.println("请输入第一只老虎的体重");
int weight1 = sc.nextInt();
System.out.println("请输入第二只老虎的体重");
int weight2 = sc.nextInt();
//2.利用三元运算符求出最终结果
String result = weight1 == weight2 ? "相同" : "不相同";
System.out.println(result);
练习2-求三个数的最大值
题目
一座寺庙里住着三个和尚，已知他们的身高分别为150cm、210cm、165cm 请用程序实现获取这三个和尚的最高身高
代码示例
//1.定义三个变量记录和尚的身高 int height1 = 150; int height2 = 210; int height3 = 165; //2.利用三元运算符求出两个数中的较大值。 int temp = height1 > height2 ? height1 : height2; //3.求出最终的结果 int max = temp > height3 ? temp : height3; System.out.println(max);
8. 键盘录入
键盘录入的实际功能Java已经帮我们写好了，不需要我们自己再实现了，而Java写好的功能都放在了Scanner这个类中，所以，我们只要直接使用Scanner这个类就可以了。
使用步骤：
第一步：
导包：其实就是表示先找到Scanner这个类在哪。
第二步：
创建对象：其实就表示申明一下，我准备开始用Scanner这个类了。
第三步：
接收数据：也是真正干活的代码。
代码示例：
//导包，其实就是先找到Scanner这个类在哪
import java.util.Scanner;
public class ScannerDemo1{
public static void main(String[] args){
//2.创建对象，其实就是申明一下，我准备开始用Scanner这个类了。
Scanner sc = new Scanner(System.in);
//3.接收数据
//当程序运行之后，我们在键盘输入的数据就会被变量i给接收了
System.out.println("请输入一个数字");
int i = sc.nextInt();
System.out.println(i);
}
}
1046
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
