Java语言基础(4)

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("还能幸福几年！");
	}
  }
}