1 关系运算符：>,>=,<,<=,==,!=
案例：Demo1
public class Demo1 {
//偶数：能被2整除的整数
//2,4,6,8,10...
//整除：余数为0
//num%2==0 true num是偶数
// false num不是偶数
public static void main(String[] args) {
int num = 99;
boolean result = num%2==0;
System.out.println(num+"是否为偶数"+
result);
}
}
2 Scanner
sun公司设计的Java的工具类，功能是从控制台输入数据。
1）导入工具类（导包）
import java.util.Scanner; //暂时先跟着我写，下周详细讲解
2）根据Scanner工具来创建对象（下周详细讲解）
Scanner sc = new Scanner(System.in);
sc就是Scanner的一个对象，通过sc调用Scanner工具类的功能
3）输入整数：
sc.nextInt(); 从控制台输入任意的一个int类型整数，一般都建议定义一个int类型变量来接收输入的整数。
案例：Demo2
import java.util.Scanner;
public class Demo2 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = sc.nextInt();
System.out.println("输入的整数是："+num);
}
//Demo3：在main方法中创建一个Scanner对象，从
//控制台输入任意的一个整数，并输出
}
import java.util.Scanner;
public class Demo3 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = sc.nextInt();
System.out.println(num);
}
}
import java.util.Scanner;
public class Demo4 {
//在main方法中，创建一个Scanner对象，从控制台输入
//任意的一个整数，判断该整数是否为偶数，如果是偶数，
//输出true，反之如果不是偶数，输出false
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = sc.nextInt();
boolean result = num%2==0;
System.out.println(num+"是否为偶数"+
result);
}
}
import java.util.Scanner;
public class Demo5 {
//在main方法中，创建一个Scanner对象，输入任意的
//一个整数，判断该整数是否为奇数，如果是奇数，输出
//true，反之如果不是奇数，输出false
//奇数：1,3,5,7,9....
//奇数：不能被2整除的整数
//num%2!=0 true 奇数
// false 不是奇数
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = sc.nextInt();
boolean result = num%2!=0;
System.out.println(num+"是否为奇数"+
result);
}
}
3 逻辑运算符：&&(逻辑与)，||(逻辑或)，!(逻辑非)
1）&&：逻辑与，用来连接两个或者多个并且关系的关系表达式，只有当所有的关系表达式都为true，整个表达式才为true，只要有任何一个关系表达式为false，则整个表达式为false。
eg：
int num1=200,num2=500;
boolean result = num1>=200 && num2<100;
true false
false
案例：Demo6
public class Demo6 {
//&&：逻辑与，用来连接多个并且关系的关系表达式，只有
//当所有的关系表达式都为ture，则整个表达式为ture，
//只要有任何一个关系表达式为false，则整个表达式为
//false。
public static void main(String[] args) {
int num1=100,num2=200,num3=500;
boolean result =
num1!=200 && num2>=100 && num3<=500;
// true true true
System.out.println("result="+result);
}
}
2）运算符优先级：
算术运算符>关系运算符>逻辑运算符>赋值运算符
eg：
int num1=100，num2=1000;
boolean result =(num1+100)*2>=300 && num2%4==0
算术 400>=300 && 0==0
关系 true && true
逻辑 true
赋值 把true赋值给result
案例：Demo7
public class Demo7 {
//运算符优先级：
//算术运算符>关系运算符>逻辑运算符>赋值运算符
public static void main(String[] args) {
int num = 100;
boolean result =
num%4==0 && num%100!=0;
//算术 0==0 && 0!=0
//关系 true && false
//逻辑 false
//赋值 把false赋值给result
System.out.println(result);
}
}
import java.util.Scanner;
public class Demo8 {
//在main方法中，创建一个Scanner对象，从控制台输入
//任意的一个整数，判断该整数是否能被4整除并且不能被
//100整除，如果满足条件，输出true，反之输出false
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = sc.nextInt();
boolean result =
num%4==0 && num%100!=0;
System.out.println(num+"是否满足条件"+
result);
}
}
3）||：逻辑或，用来连接多个或者关系的表达式，只要有任何一个关系表达式为true，则整个表达式都为true，只有当所有的关系表达式都为false，则整个表达式才为false。
eg：
int num1=100,num2=200;
boolean result = num1!=100 || num2>num1;
false true
true
案例：Demo9
public class Demo9 {
//||:逻辑或，用来连接多个或者关系的表达式，只要有
//任何一个表达式为true，则整个表达式都为true，只有
//当所有的表达式都为false，则整个表达式才为false。
public static void main(String[] args) {
int num1=100,num2=200,num3=300;
boolean result =
num1+num2<200 || num1+num2>num3;
// false false
// false
System.out.println("result="+result);
}
}
import java.util.Scanner;
public class Demo10 {
//在main方法中，创建一个Scanner对象，从控制台输入
//任意的一个整数，判断该整数是否能被4整除或者能
//被3整除，如果满足条件，输出true，反之，输出false
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个整数：");
int num = sc.nextInt();
boolean result =
num%4==0 || num%3==0;
System.out.println(num+"是否满足条件"+
result);
}
}
综合案例
闰年：该年份能被4整除并且不能被100整除，或者能被400整除
1）能被4整除并且不能被100整除：
year%4==0&&year%100!=0
2）能被400整除：
year%400==0
3）或者
(year%4==0&&year%100!=0) || year%400==0
Demo11: 在main方法中，创建一个Scanner对象，从控制台输入任意的一个整数作为年份year，判断该年份是否为闰年，如果是闰年，输出true，反之如果不是闰年，输出false
import java.util.Scanner;
public class Demo11 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个年份：");
int year = sc.nextInt();
boolean result =
(year%4==0 && year%100!=0) ||
year%400==0;
System.out.println(year+"是否为闰年："+
result);
}
}
4）如果直接判断整个表达式的true还是false，不需要对每一个表达式都进行判断。
eg：
int num1=100，num2=1000；
boolean result = num1!=100 && num2>=1000;
false false
boolean result2 = num1==100 || num2!=1000;
true true
5) ！：逻辑非，取反
eg：
boolean result1 = ! true;
false
boolean result2 =!(100!=100);
!(false)
true
案例：Demo12
public class Demo12 {
public static void main(String[] args) {
boolean result1 = !true;//false
System.out.println("result1="+result1);
boolean result2 = !false;//true
System.out.println("result2="+result2);
int num1=100,num2=500;
boolean result3 = !(num1+200<=num2);
// !(300<=num2)
// !true
// false
System.out.println("result3="+result3);
}
}
4 条件运算符（三目运算符）
1）格式：
表达式1？表达式2：表达式3
2）语法规则：如果表达式1为true，则表达式2作为当前整个表达式的结果；如果表达式1为false，则表达式3作为当前整个表达式的结果。
eg：
int num1=100，num2=200；
int max = num1>=num2 ? num1 : num2;
案例：Demo13
public class Demo13 {
//条件运算符：
//1 格式： 表达式1 ？ 表达式2 ：表达式3
//2 语法规则：首先判断表达式1，如果表达式1为true，
//则表达式2作为整个表达式的结果；反之如果表达式1为
//false，则表达式3作为整个表达式的结果。
public static void main(String[] args) {
int num1=5000,num2=1000;
int min = num1<=num2 ? num1 : num2;
System.out.println("较小的数是"+min);
}
}
import java.util.Scanner;
public class Demo14 {
//在main方法中，编写一个Scanner对象，从控制台输入
//任意的两个整数，输出其中较大的整数的值
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入第1个整数：");
int num1 = sc.nextInt();
System.out.println("请输入第2个整数：");
int num2 = sc.nextInt();
int max = num1>=num2 ? num1 : num2;
System.out.println("较大的整数是"+max);
}
}
5 Java中语句的结构
1）顺序结构：代码从上往下，每一行都会被执行
2）选择结构：根据条件的不同，选择性执行代码，有的代码被执行，而有的代码没有被执行。
3）循环结构：一段代码反复被执行。
6 if语句（单分支）
1） 格式： if(表达式){
语句
}
2）语法规则：首先判断if中的表达式，如果表达式为true，执行对应if中语句；反之如果表达式为false，不执行任何语句。
eg：
int age = 2；
if(age>=18){
System.out.println("你长大了");
System.out.println("努力工作！");
}
案例：Demo15
public class Demo15 {
//if语句
//1 格式： if(表达式){
// 语句
// }
//2 语法规则：首先判断if中的表达式，如果表达式为
//true，执行if中的语句；如果表达式为false，不执行
//任何语句。
public static void main(String[] args) {
int age = 3;
if(age>=18){
System.out.println("你长大了");
System.out.println("自己养活自己！");
}
}
}
3）注意：
a）if的条件（表达式）跟if语句之间不要出现“；”，容易导致if语句失效。
b）一般把if中的语句都放到一个{}中。
案例：Demo16
import java.util.Scanner;
public class Demo16 {
//在main方法中，创建一个Scanner对象，从控制台输入
//任意的一个整数，判断该整数是否为偶数，如果是偶数，
//输出该整数的值以及是"是偶数"，如果不是偶数，不输出
//任何内容
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入任意的一个整数：");
int num = sc.nextInt();
if(num%2==0){//偶数
System.out.println(num+"是偶数");
}
}
}
import java.util.Scanner;
public class Demo17 {
//在main方法中，创建一个Scanner对象，从控制台输入
//任意的一个整数作为年份year，判断该年份是否为闰年，
//如果是闰年，输出该年份以及"是闰年"，反之不输出
//任何内容。
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入年份：");
int year = sc.nextInt();
if((year%4==0&&year%100!=0)||
year%400==0){
System.out.println(year+"是闰年");
}
}
}
7 if-else语句
1）格式：
if(表达式){
语句1
}else{
语句2
}
2）语法规则：如果if中表达式为true，执行if中语句1；反之如果if中表达式为false，执行else中语句2。
eg:
int age = 27;
if(age>=18){
System.out.println("你长大了");
}else{//age<18
System.out.println("你还小");
}
3）else后面不直接接条件，因为else本身就是if的相反情况。if-else语句必然执行其中之一。
案例：Demo18
public class Demo18 {
//if-else语句
//1 格式：if(表达式){
// 语句1
// }else{
// 语句2
// }
//2 语法规则：首先判断if中的表达式，如果表达式为true，
//执行if中的语句1；反之如果表达式为false，执行else
//中的语句2
//3 if-else语句必然执行其中的某一个分支。
public static void main(String[] args) {
int age=9;
if(age>=18){
System.out.println("你长大了");
System.out.println("自己养活自己");
}else{//age<18
System.out.println("你还小！");
System.out.println("还能幸福几年！");
}
}
}
