2.基本语法

目录

关键字与保留字

标识符(Identifier)         

标识符的使用

标识符的命名规则

Java中的名称命名规范

变量

 Java定义的数据类型     

        一、变量按照数据类型来分：

        二、变量在类中声明的位置：

基本数据类型之间的运算规则

        一、自动类型提升：

        二、强制类型转换

 string     

          进制      

 运算符

    算术运算符

    赋值运算符

    比较运算符

    逻辑运算符

    位运算符    

    三元运算符

程序流程控制   

         顺序结构

         分支结构

                if-else分支语句

                switch-case分支语句

          循环结构

                for循环              

                While循环          

                do-while循环 

break、continue特殊关键字的使用  

---

关键字与保留字

        关键字(keyword)

            定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
            特点：关键字中所字母都为小写

        保留字(reserved word)
                现 Java 版本尚未使用，但以后版本可能会作为关键字使用。

                自己命名标识符时要避免使用这些保留字goto、const

标识符(Identifier)         

        Java 对各种变量、方法和类等要素命名时使用的字符序列称为标识符
                    技巧：凡是自己可以起名字的地方都叫标识符

         标识符的使用

                1.标识符：凡是可以自己起名字的地方都叫标识符
                    涉及到的结构：类名，变量名，方法名，接口名，包名...

          标识符的命名规则

                    由26个英文字母大小写，0-9 ，_或 $ 组成
                    数字不可以开头
                    不可以使用关键字和保留字，但能包含关键字和保留字
                    Java中严格区分大小写，长度无限制
                    标识符不能包含空格

class IdentifierTest{ 
	public static void main(String[] args){
			//int myNumber = 1001;
			//System.out.println(myNumber);
			int mynumber = 1002;
			System.out.println(mynumber);
 }
}

        Java中的名称命名规范

                   包名：多单词组成时所字母都小写：xxxyyyzzz
                   类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz
                   变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个单词首字母大写：xxxYyyZzz
                   常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ 

变量

（用于在内存中保存数据）

  变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值
  注意：
        Java中每个变量必须先声明，后使用
        使用变量名来访问这块区域的数据（相当于输出myAge,myNumber....）
        变量的作用域：其定义所在的一对{ }内
        变量只在其作用域内才效（即出了作用域就失效了）
        同一个作用域内，不能定义重名的变量(变量输出时矛盾)
        定义变量的格式：数据类型    变量名 = 变量值；

class VariableTest {
	public static void main(String[] args) {
		//变量的定义
		int myAge = 19;
		//变量的使用
		System.out.println(myAge);

		//变量的声明
		int myNumber;
		//变量的赋值
		myNumber = 1001;
		//变量的使用
		System.out.println(myNumber);

		//变量没有作用在作用域内
		System.out.println(myClass);
	}
	public void method(){
		int myClass = 1;
	
	}
}

 Java定义的数据类型     

        一、变量按照数据类型来分：

            基本数据类型(记忆):
                整型：byte（1字节=8bit） \ short（2字节） \ int（4字节） \ long（8字节）
                    注：byte范围：-128~127
                            声明long型变量，必须以“L”或“l”结尾
                            通常，定义整型变量时，使用int型
                 浮点型：float （4字节）\ double（8字节）
                    注：浮点型，表示带小数点的数值
                            float表示数值的范围比long还大
                            定义float类型变量时，变量要以“F”或“f”结尾
                            通常，定义浮点型变量时，使用double型
                 字符型：char（1字符 = 2字节）
                    注：定义char型变量，通常使用一对''，内部只能写一个字符
                           表示方式：1.声明一个字符   2.转义字符（'\n'换行符）（'\t'制表符）
                                             3.直接使用Unicode值来表示字符型常量（'\u0043'输出c）
                                a(97)、A(65)
                  布尔型：boolean
                     注：只能取两个值之一:true、false
                             常常在条件判断、循环结构中使用
            引用数据类型
                类（class）
                接口（interface）
                数组（array）

        二、变量在类中声明的位置：

                成员变量 VS 局部变量

class VariableTest1 {
	public static void main(String[] args) {
	//整型：byte（1字节=8bit） \ short（2字节） \ int（4字节） \ long（8字节）
		//注：byte范围：-128~127
		byte b1 = 12;
		byte b2 = -128;
		//byte b2 = 128;//编译不通过
		System.out.println(b1);
		System.out.println(b2);
		// 声明long型变量，必须以“L”或“l”结尾
		short s1 = 128;
		int i1 = 1234;
		long n1 = 82658420L;
		System.out.println(s1);
		System.out.println(i1);
		System.out.println(n1);

	//浮点型：float （4字节）\ double（8字节）
		//注：浮点型，表示带小数点的数值
		//float表示数值的范围比long还大
		double d1 = 123.3;
		System.out.println(d1 + 1);
		//定义float类型变量时，变量要以“F”或“f”结尾
		float f1 = 12.3F;
		System.out.println(f1);
		//通常，定义浮点型变量时，使用double型

	//字符型：char（1字符 = 2字节）
		//定义char型变量，通常使用一对''，内部只能写一个字符
		char c1 = 'a';
		//编译不通过
		//c1 = 'AB';
		System.out.println(c1);

		char c2 = '1';
		char c3 = '王';
		System.out.println(c2);
		System.out.println(c3);

		//表示方式：1.声明一个字符   2.转义字符   3.直接使用 Unicode值来表示字符型常量
		char c4 = '\n';//换行符
		c4 = '\t';//制表符
		System.out.print("hello" + c4);
		System.out.println("world");

		char c5 = '\u0043';
		System.out.println(c5);

	//布尔型：boolean
	//只能取两个值之一:true、false
	//常常在条件判断、循环结构中使用
	boolean bb1 = true;
	System.out.println(bb1);
	Boolean isMarried = true;
	if(isMarried){
		System.out.println("你不能参加\"单身\"party了！");
	}else{
		System.out.println("你可以参加单身party了！");
	}
	}
}

基本数据类型之间的运算规则

前提：这里讨论只是7种基本数据类型变量间的运算，不包含boolean类型（boolean类型不可以转换为其它的数据类型）

        一、自动类型提升：

                结论：当容量小的数据类型变量与容量大的数据类型变量做运算时，结果自动提升为容量大的数据类型
                                    byte、char、short --> int --> long --> float --> double
                说明：此时的容量大小指的是，表示数的范围的大和小（比如：float容量要大于long的容量）
                特别的：当byte、char、short三种类型的变量做运算时，结果为int型

class VariableTest2 {
	public static void main(String[] args) {
		byte b1 = 2;
		int i1 = 12;
		//编译不通过
		//byte b2 = b1 + i1;
		int i2 = b1 + i1;
		System.out.println(i2);
		//long l1 = b1 + i1;
		//System.out.println(l1);
		float f1 = b1 + i1;
		System.out.println(f1);
		//short s1 = 123;
		//double d1 = s1;
		//System.out.println(d1);

		//*********************************************
		char c1 = 'a';//97
		int i3 = 10;
		int i4 = c1 + i3;
		System.out.println(i4);
		//char --> int

		char c2 = 'a';//97
		short s2 = 10;
		//short s3 = c2 + s2;//编译不通过
		//System.out.println(s3);//编译不通过
		//不能证明char --> short
		char c3 = 'a';//97
		short s4 = 10;
		//char c4 = c3 + s4;//编译不通过
		//System.out.println(c4);//编译不通过
		//不能证明short --> char

		char c4 = 'a';//97
		byte b2 = 10 ;
		//char c5 = c4 + b2;//编译不通过
		short s5 = 10;
		byte b3 = 15;
		//short s6 = s5 + b3;//编译不通过

		//short s7 = b2 + b3;//编译不通过
		//char c5 = b2 + b3;//编译不通过
		//*********************************************
		

        二、强制类型转换

                (自动类型提升运算的逆运算)
                1.需要使用强转符:()
                2.注意点:强制类型转换，可能导致精度损失

class VariableTest3{
	public static void main(String[] args) {
		
		double d1 = 12.9;
		int i1 = (int)d1;//截断操作
		System.out.println(i1);//输出12，精度损失

		long l1 = 123;
		short s1 = (short)l1;//输出123，无精度损失
		System.out.println(s1);

		int i2 = 128;
		byte b1 = (byte)i2;
		System.out.println(b1);//-128(精度损失)

	}
}

    补

class VariableTest4 {
	public static void main(String[] args) {
//1.编码情况1
	long l1 = 123213;//{没加L}编译成功，可理解为long的值附给int
	System.out.println(l1);

	//long l2 = 479274297429374; //{没加L}编译失败，容量超过int容量的范围(过大的整数)，无法自动提升为int，故出错
	//System.out.println(l2);    //即不加L，用int(4个字节)去存。加上L，用long(8个字节)去存

	long l2 = 479274297429374L;//编译成功
	System.out.println(l2);

	//float f1 = 12.3;  //{没加F}编译失败
	float f1 = (float)12.3;   //(用了一下强制转换编译成功，还不如直接加个F)
//*************************************************************

//2.编码情况2
	//整型常量，默认类型为int型
	//浮点型常量，默认类型为double型
	byte b1 = 12;
	//byte b2 = b1 + 1;  //编译失败

	//float f1 = b1 + 12.3;  //编译失败
	}
}

         string     

                1.Sring属于引用数据类型，翻译为：字符串
                2.声明String类型变量时，使用一对“”
                3.String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
                4.运算的结果仍然是Spring类型

class StringTest{
	public static void main(String[] args) {
		System.out.println("HelloWorld");

		String s1 = "HelloWorld";
		System.out.println(s1);

		String s2 = "a";
		String s3 = "";

		//char c1 = '';//编译错误

		//*************************************

		int number = 1001;
		String numberStr = "学号：";
		String info1 = numberStr + number;  // +:连接运算
		boolean b1 = true;
		System.out.println(info1);
		
		String info2= info1 + b1;  // +:连接运算
		System.out.println(info2); 

		//*************************************

		//练习1
		char c1 = 'a';//97  A:65
		int num = 10;
		String str = "hello";
		System.out.println(c1 + num + str);//107hello
		System.out.println(c1 + str + num);//ahello10
		System.out.println(c1 + (num + str));//a10hello
		System.out.println((c1 + num) + str);//107hello
		System.out.println(str + num + c1);//hello10a

		//练习2
		//*	*
		System.out.println("*	*");//*	*
		System.out.println('*' + '\t' +'*');//93
		System.out.println('*' + "\t" +'*');//*	*
		System.out.println('*' + '\t' +"*");//51*
		System.out.println('*' + ('\t' +"*"));//* *

		//*************************************************

		//String str1 = 123;  //编译不通过
		String str1 = 123 + "";
		System.out.println(str1); //"123"(String型)

		//int num1 = str1;	//编译不通过
		//int num1 = (int)str1;	 //编译不通过

		int num1 = Integer.parseInt(str1);
		System.out.println(num1);//123(int型)   //String型返回int型，不用记，作为了解
	}
}

    进制      

        二进制(binary)：0,1 ，满2进1.以0b或0B开头。
        十进制(decimal)：0-9 ，满10进1。
        八进制(octal)：0-7 ，满8进1. 以数字0开头表示。
        十六进制(hex)：0-9及A-F，满16进1. 以0x或0X开头表示。此处的A-F不区分大小写                                        如：0x21AF +1= 0X21B0

class BinaryTest {
	public static void main(String[] args) {
		int num1 = 0b110;
		int num2 = 110;
		int num3 = 0127;
		int num4 = 0x110A;

		System.out.println("num1 = " + num1);
		System.out.println("num2 = " + num2);
		System.out.println("num3 = " + num3);
		System.out.println("num4 = " + num4);
	}
}

补：二进制与十进制的相互转化
               二进制的整数如下种形式：
                       原码：直接将一个数值换成二进制数。最高位是符号位
                       负数的反码：是对原码位取反，只是最高位（符号位）确定为1。
                       负数的补码：其反码加1。
            正数是三码合一

 运算符

 算术运算符

%:取余运算
                    结果的符号和被模数的符号相同
                    开发中，经常使用%来判断能否被除尽的情况
                注：自增1不会改变本身变量的数据类型
                        整数之间做除法时，只保留整数部分而舍弃小数部分

                连接符：+：只能使用在String与其他数据类型变量（包括String本身）之间。

class AriTest {
	public static void main(String[] args) {
	
	//除号：/
	int num1 = 12;
	int num2 = 5;
	int result1 = num1 / num2;
	System.out.println(result1);//2
	
	int result2 = num1 / num2 *num2;
	System.out.println(result2);//10

	double result3 = num1 / num2;
	System.out.println(result3);//2.0

	double result4 = num1 / num2 + 0.0;//2.0
	double result5 = num1 / (num2 + 0.0);//2.4
	double result6 = (double)num1 / num2;//2.4
	double result7 = (double)(num1 / num2);//2.0
	System.out.println(result7);

	// %:取余运算
	//结果的符号和被模数的符号相同
	//开发中，经常使用%来判断能否被除尽的情况
	int m1 = 12;
	int n1 = 5;
	System.out.println("m1 % n1 = " + m1 % n1);//m1 % n1 = 2

	int m2 = -12;
	int n2 = 5;
	System.out.println("m2 % n2 = " + m2 % n2);//m1 % n1 = -2

	int m3 = 12;
	int n3 = -5;
	System.out.println("m3 % n3 = " + m3 % n3);//m1 % n1 = 2

	int m4 = -12;
	int n4 = -5;
	System.out.println("m4 % n4 = " + m4 % n4);//m1 % n1 = -2

	//(前)++ :先自增1，后运算
	//(后)++ :先运算，后自增1
	int a1 = 10;
	int b1 = ++a1;
	System.out.println("a1 = " + a1 + ",b1 = " + b1);//a1 = 11,b1 = 11

	int a2 = 10;
	int b2 = a2++;
	System.out.println("a2 = " + a2 + ",b2 = " + b2);//a2 = 11,b2 = 10

	int a3 = 10;
	++a3;//(a3++;)
	int b3 = a3;//a3 = 11, b3 = 11

	//注意点：
	short s1 = 10;
	//s1 = s1 + 1;//编译失败
	//s1 = (short)(s1 + 1);//编译成功
	s1++;//自增1不会改变本身变量的数据类型
	System.out.println(s1);

	//问题：
	byte bb1 = 127;
	bb1++;
	System.out.println("b1 = " + bb1);//b1 = -128

	//(前)--：先自减1，后运算
	//(后)--：先运算，后自减1
	int a4 = 10;
	int b4 = --a4;
	System.out.println("a4 = " + a4 + ",b4 = " + b4);// a4 = 9,b4 = 9
	int a5 = 10;
	int b5 = a5--;
	System.out.println("a5 = " + a5 + ",b5 = " + b5);// a5 = 9,b5 = 10

	}
}

    赋值运算符

        （符号：= ）（=  +=  -=  *=  /=  %=）
          当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理
          支持连续赋值
          +=  -=  *=  /=  %=   不会改变本身的数据类型

练习：随意给出一个三位数的整数，打印显示它的个位数，十位数，百位数的值。

class AriExer{
	public static void main(String[] args) {
		int num = 187;
		int bai = num / 100;
		int shi = num % 100 / 10;//int shi = num / 10 % 10;
		int ge = num % 10;
		System.out.println("百位数：" +bai);
		System.out.println("十位数：" +shi);
		System.out.println("个位数：" +ge);
	}
}

比较运算符

            比较运算符的结果都是boolean型，也就是要么是true，要么是false
            >   <   >=   <=  :只能使用在数值类型的数据之间
            ==   !=：不仅可以使用在数值类型数据之间，还可以使用在其他引用数据类型变量之间
                eg:
                Account acct1 = new Account(1000);
                Account acct1 = new Account(1000);
                boolean b1 (acct1 == acct2);     //false   //比较两个Account是否是同一个账户
                boolean b2 (acct1 != acct2);      //true
            注意区分 == 和 =

class CompareTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 20;
		System.out.println(i == j);//false
		System.out.println(i = j);//20

		boolean b1 = true;
		boolean b2 = false;
		System.out.println(b2 == b1);//false
		System.out.println(b2 = b1);//true

	}
}

逻辑运算符

逻辑与运算符操作的都是boolean类型的变量,结果也是boolean型
         “&”和“&&”的区别
                & 与 && 的运算结果都相同
                &时，左边无论真假，右边都进行运算   &&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算
               开发中，推荐使用&&
        | 和 ||的区别
                | 与 || 的运算结果都相同
                | 时，左边无论真假，右边都进行运算   || 时，如果左边为假，右边参与运算，如果左边为真，那么右边不参与运算
                开发中，推荐使用||
        ^
                两边相同则为True,两边不同则为False

class LogicTest{
	public static void main(String[] args){
		//区分& 与 &&
		//相同点1：& 与 && 的运算结果都相同
		//相同点2：当符号左边是true时，二者都会执行符号右边的运算
		//不同点：当符号左边是false时，&继续执行符号,&&在不执行运算
		//开发中，推荐使用&&
		boolean b1 = true;
		b1 = false;
		int num1 = 10;
		if(b1 & (num1++ > 0)){
			System.out.println("我现在在南京");
		}else{
			System.out.println("我现在在北京");
		}
		System.out.println("num1 = " + num1);

		boolean b2 = true;
		b2 = false;
		int num2 = 10;
		if(b2 && (num2++ > 0)){
			System.out.println("我现在在南京");
		}else{
			System.out.println("我现在在北京");
		}
		System.out.println("num2 = " + num2);

		//区分：| 与 ||
		//相同点1：| 与 || 的运算结果都相同
		//相同点2：当符号左边是false时，二者都会执行符号右边的运算
		//不同点3：当符号左边是true时，|继续执行符号右边的运算，而||不再执行符号右边的运算
		//开发中，推荐使用||
		boolean b3 = false;
		int num3 = 10;
		b3 = true;
		if(b3 | (num3++ > 0)){
			System.out.println("我现在在南京");
		}else{
			System.out.println("我现在在北京");
		}
		System.out.println("num3 = " + num3);

		boolean b4 = false;
		b4 = true;
		int num4 = 10;
		if(b4 || (num4++ > 0)){
			System.out.println("我现在在南京");
		}else{
			System.out.println("我现在在北京");
		}
		System.out.println("num4 = " + num4);


		//练习
		int x1 = 1,y1 = 1;if(x1++==2 && ++y1==2){
			x1 =7;
		}System.out.println("x1="+x1+",y1="+y1);//x1 = 2,y1 = 1

		int x2 = 1,y2 = 1;if(x2++==1 | ++y2==1){
			x2 =7;
		}System.out.println("x2="+x2+",y2="+y2);//x2 = 7,y2 = 2

		//面试题
		boolean x=true; 
		boolean y=false;
		short z=42;
		// if(y == true)  //加上该语句输出z = 43
			if((z++==42)&&(y=true))
				z++;
		 if((x=false) || (++z==45))
				z++;
		System.out.println("z="+z);//z = 46
	
	
	}
}

 位运算符    

         位运算是直接对整数的二进制进行的运算

面试题：最高效的计算2 * 8 ？    2 << 3 或 8 << 1
            结论：
            1.位运算符操作的都是整型的数据变量
            2.<< : 在一定范围内，每向左移一位，相当于 * 2
               >> : 在一定范围内，每向右移一位，相当于 / 2 

注意：

 

 0（看成false）  1（看成true）

        ^   
                m = k ^ n = (m ^ n) ^ n
    
        ~  取反运算

 

class BitTest{
	public static void main(String[] args){
		int i = 21;
		//i = -21;
		System.out.println("i << 2 :" + (i << 2));
		System.out.println("i << 3 :" + (i << 3));
		System.out.println("i << 20 :" + (i << 20));
		System.out.println("i << 26 :" + (i << 26));
		System.out.println("i << 27 :" + (i << 27));
		
		int m = 12;
		int n = 5;
		System.out.println("m & n :" + (m & n));
		System.out.println("m & n :" + (m | n));
		System.out.println("m & n :" + (m ^ n));
		
		//练习：交换两个变量的值
		int num1 = 10;
		int num2 = 20;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);

		//方式一：定义临时变量的方式
		//int tenp = num1;
		//num1 = num2;
		//num2 = tenp;
		
		//方式二：
		//好处：不用定义临时变量
		//弊端：①相加可能超出存储范围 ② 有局限性：只适用于数值类型
		//num1 = num1 + num2;
		//num2 = num1 - num2;
		//num1 = num1 - num2;

		//方式三：使用位运算
		//num1 = num1 ^ num2;
		//num2 = num1 ^ num2;
		//num1 = num1 ^ num2;
		System.out.println("num1 = " + num1 + ",num2 = " + num2);
	}
}

 三元运算符

            1.结构：(条件表达式)？表达式1 : 表达式2
            2. 说明
                ① 条件表达式的结果为boolean类型
                ② 根据条件表达式真或假，决定执行表达式1，还是表达式2.
                      如果表达式为true,则执行表达式1
                      如果表达式为false,则执行表达式2
                ③ 表达式1 和表达式2数据类型可以不同，但必须能统一成一个类型
                ④ 三元运算符是可以嵌套的
            3. 凡是可以使用三元运算的地方，都是可以改写if-else。
                   反之，则不一定成立！！！
            4.如果程序既可以使用三元运算符，又可以使用if-else结构，那么优先选择三元运算符(原因：执行效率高)

class SanYuanTest{
	public static void main(String[] args) {
		//获取两个整数的最大值
		int m = 12;
		int n = 5;
		int max = (m > n)? m : n;
		System.out.println(max);

		double num = (m > n) ? 2 : 1.0;
		//(m > n) ? 2 : "n大";	//编译错误

		//****************************************
		String maxStr = (m > n) ? "m大" : ((m == n)? "m和n相等" : "n大");//可以嵌套
		System.out.println(maxStr);

		//****************************************
		
		//获取三个数中的最大值
		int n1 = 12;
		int n2 = 30;
		int n3 = -43;

		int max1 = (n1 > n2) ? n1 : n2;
		int max2 = (max1 > n3) ? max1 : n3;
		System.out.println("三个数中的最大值是：" + max2);

		//此方法：pass
		int max3 = (((n1 > n2) ? n1 : n2) > n3) ?((n1 > n2) ? n1 : n2) : n3;
		System.out.println("三个数中的最大值是：" + max3);

		//改写成if-else
		if(m > n){
			System.out.println(m);
		}else{
			System.out.println(n);
		}
	}
}

程序流程控制   

        三种基本流程结构         

         顺序结构

                程序从上到下逐行地执行，中间没任何判断和跳出

         分支结构

                根据条件，择性地执行某段代码
                if…else和switch-case两种分支语句

                if-else分支语句

                    第一种：
                        if(条件表达式){
                            执行表达式
                        }
                    第二种：
                        if(条件表达式){
                            执行表达式1
                        }else{
                            执行表达式2
                        }
                    第三种：
                        if(条件表达式){
                            执行表达式1
                        }else if{
                            执行表达式2
                        }else if(条件表达式){
                            执行表达式3
                        }
                        ...
                        else{
                            执行表达式n
                        }

class IfTest{
	public static void main(String[] args){
		//举例1
		int heartBeats = 75;
		if(heartBeats < 60 || heartBeats > 100){
			System.out.println("需要进一步做检查");
		}
		System.out.println("检查结束");

		//举例2
		int age1 = 23;
		if(age1 < 18){
			System.out.println("你还可以看动画片");
		}else{
			System.out.println("你可以看科技电影了");
		}

		//举例3
		int age = 57;
		if(age < 0){
			System.out.println("你输入的数据不合适");
		}else if(age < 18){
			System.out.println("你还是个青少年");
		}else if(age < 35){
			System.out.println("你还是个青壮年");
		}else if(age < 60){
			System.out.println("你还是个中年");
		}else if(age < 120){
			System.out.println("你进入老年了");
		}else{
			System.out.println("你成仙了");
		}
	}
}

（补充）如何从键盘获取不同类型的变量，需要使用Scanner类
        具体步骤：
            1.导包：import java.util.Scanner;
            2.Scanner的实例化;Scanner scan = new Scanner(System.in);
            3.调用Scanner类的相关方法(netx() / nextXxx())，来获取指定类型的变量。
            注意：
                需要根据相应的方法，来输入指定类型的值，如果输入的数据类型与要求的类型不匹配时，会报异常：InputMisMatchException，导致程序终止

//1.导包：import java.util.Scanner;
import java.util.Scanner;//导包

class ScannerTest{

	public static void main(String[] args){
		
		//2.Scanner的实例化;
		Scanner scan = new Scanner(System.in);
		//3.调用Scanner类的相关方法(netx() / nextXxx())，来获取指定类型的变量。
		System.out.println("请输入你的姓名：");
		String name = scan.next();
		System.out.println(name);

		System.out.println("请输入你的年龄：");
		int age = scan.nextInt();
		System.out.println(age);

		System.out.println("请输入你的体重：");
		double weight = scan.nextDouble();
		System.out.println(weight);
		
		System.out.println("你是否相中我了呢？(true/false)");
		boolean isLove = scan.nextBoolean();
		System.out.println(isLove);

		//对于char型的获取，Scanner没有提供获取方法。只能获取一个字符串
		System.out.println("请输入你的性别：(男/女)");
		String gender = scan.next();
		System.out.println(gender);// "男" 、 “女”
		char genderChar = gender.charAt(0);//获取字符串中的某一个字符（从0开始，即第一个字符为0）
		System.out.println(genderChar);
		}
}

练习1

岳小鹏参加Java考试，他和父亲达成承诺：
如果：     成绩为100分时，奖励一辆BMW；
                成绩为(80，99]时，奖励一台iphone xs max；
                当成绩为[60,80]时，奖励一个 iPad；
                其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断
            说明：
            1.else结构是可选的。
            2.针对于条件表达式：
            如果多个条件表达式之间的关系是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓；
            如果多个条件表达式之间是有交集的关系，需要根据实际情况，需要考虑实际情况，考虑清楚应该将哪个结构声明在上面。
            如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会运行。

import java.util.Scanner;
class IfTest{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入岳小鹏期末成绩：(0-100)");
		int score = scan.nextInt();
		
		if(score == 100){
			System.out.println("奖励一辆BMW");//BMW(别摸我)--MSN(摸死你)
		}else if(score > 80 && score <= 99){
			System.out.println("奖励一台iphone xs max");
		}else if(score >= 60 && score <= 80){
			System.out.println("奖励一个 iPad");
		}
		//	else{	//可有可无
		//	System.out.println("没奖励");
		//	}
	}
}

练习2

          由键盘输入三个整数分别存入变量num1、num2、num3，
          对它们进行排序(使用 if-else if-else),并且从小到大输出。
            说明：
            1.if-else结构是可以互相嵌套的
            2.如果if-eles结构中的执行语句只有一行时，对应的一对{}是可以省略的，但是不建议省略（笔试时注意判断题就OK）

import java.util.Scanner;
class IfTest2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入第一个整数:");
		int num1 = scan.nextInt();

		System.out.println("请输入第二个整数:");
		int num2 = scan.nextInt();

		System.out.println("请输入第三个整数:");
		int num3 = scan.nextInt();

		if(num1 > num2){
			if(num3 >= num1){
				System.out.println(num2 + "," + num1 + "," + num3);
			}else if(num3 <= num2){
				System.out.println(num3 + "," + num2 + "," + num1);
			}else{
				System.out.println(num2 + "," + num3 + "," + num1);
			}
		}else{
			if(num3 >= num2){
				System.out.println(num1 + "," + num2 + "," + num3);
			}else if(num3 <= num1){
				System.out.println(num3 + "," + num1 + "," + num2);
			}else{
				System.out.println(num1 + "," + num3 + "," + num2);
			}
		}

	}
}

练习3

我家的狗5岁了，5岁的狗相当于人类多大呢？其实，狗的前两年每一年相当于人类的10.5岁，之后每增加一年就增加四岁。那么5岁的狗相当于人类多少年龄呢？应该是：10.5 + 10.5 + 4 + 4 + 4 = 33岁。

编写一个程序，获取用户输入的狗的年龄，通过程序显示其相当于人类的年龄。如果用户输入负数，请显示一个提示信息。

import java.util.Scanner;
class IfExer {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		System.out.println("请输入狗的年龄:");
		int douAge = scan.nextInt();
		if(douAge <= 2 && douAge >= 0){
			System.out.print("相当于人的年龄：" + douAge * 10.5);
		}else if(douAge >= 2){
			System.out.print("相当于人的年龄：" + (2 * 10.5 + (douAge - 2) * 4));
		}else{
			System.out.print("输入有误");
		}
	
	}
}

练习4

假设你想开发一个玩彩票的游戏，程序随机地产生一个两位数的彩票，提示用户输入一个两位数，然后按照下面的规则判定用户是否能赢。
        1)如果用户输入的数匹配彩票的实际顺序，奖金10 000美元。
        2)如果用户输入的所有数字匹配彩票的所有数字，但顺序不一致，奖金 3 000美元。
        3)如果用户输入的一个数字仅满足顺序情况下匹配彩票的一个数字，奖金1 000美元。
        4)如果用户输入的一个数字仅满足非顺序情况下匹配彩票的一个数字，奖金500美元。
        5)如果用户输入的数字没有匹配任何一个数字，则彩票作废。
        提示：使用(int)(Math.random() * 90 + 10)产生随机数。
        Math.random() : [0,1) * 90 ?[0,90) + 10 ?[10,100) ? [10,99]
            说明：
            如何获取一个随机数：10 - 99
            double value = Math.random();  //[0.0,1.0)
            double value = Math.random(); * 90 + 10;  //[10.0,100.0)
            int value = (int)(Math.random() * 90 + 10);  //[10,99]
            公式：[a,b] : (int)(Math.random() * (b - a + 1) + a);

import java.util.Scanner;
class IfExer2 
{
	public static void main(String[] args) 
	{
		//1、随机产生一个两位数
		//System.out.println(Math.random());//产生[0,1)
		int number = (int)(Math.random()*90 + 10);//得到[10,99]，即[10,100)
		//System.out.println(number);
		
		int numberShi = number/10;
		int numberGe = number%10;
		
		//2、用户输入一个两位数
		Scanner input = new Scanner(System.in);
		System.out.print("请输入一个两位数：");
		int guess = input.nextInt();
		
		int guessShi = guess/10;
		int guessGe = guess%10;
		
		if(number == guess){
			System.out.println("奖金10 000美元");
		}else if(numberShi == guessGe && numberGe == guessShi){
			System.out.println("奖金3 000美元");
		}else if(numberShi==guessShi || numberGe == guessGe){
			System.out.println("奖金1 000美元");
		}else if(numberShi==guessGe || numberGe == guessShi){
			System.out.println("奖金500美元");
		}else{
			System.out.println("没中奖");
		}
		
		System.out.println("中奖号码是：" + number);

	}
}

练习5

    女方家长提出一定的条件：
    高：180cm以上；富：财富1千万以上；帅：是。
        如果这三个条件同时满足，则：“我一定要嫁给他!!!”
        如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
        如果三个条件都不满足，则：“不嫁！”
            说明：
            &&  || (当定义了String数据类型变量时，需要使用&&(||),输出是(否....),其后加 .equals())
                eg:    height >180 && wealth > 1 && isHandsome.equals("是")

import java.util.Scanner;
class IfExer3 {
	public static void main(String[] args) {


		Scanner scan = new Scanner(System.in);
		
		//方法一
		System.out.println("请输入你的身高：(cm)");
		int height = scan.nextInt();		
		System.out.println("请输入你的财富：(千万)");
		double wealth = scan.nextDouble();
		System.out.println("请输入你是否帅：(true、false)");
		boolean isHandsome = scan.nextBoolean();
		
		if(height >180 && wealth > 1 && isHandsome == true){  //(height >180 && wealth > 1 && isHandsome)也OK
			System.out.println("我一定要嫁给他!!!");
		}else if(height >180 || wealth > 1 || isHandsome == true){
			System.out.println("嫁吧，比上不足，比下有余");
		}else{
			System.out.println("不嫁");
		}
		
	
		/*
		方法二
		System.out.println("请输入你的身高：(cm)");
			int height = scan.nextInt();		
		System.out.println("请输入你的财富：(千万)");
			double wealth = scan.nextDouble();
		System.out.println("请输入你是否帅：(true、false)");
			String isHandsome = scan.next();

		if(height >180 && wealth > 1 && isHandsome.equals("是")){
			System.out.println("我一定要嫁给他!!!");
		}else if(height >180 || wealth > 1 || isHandsome.equals("是")){
			System.out.println("嫁吧，比上不足，比下有余");
		}else{
			System.out.println("不嫁");
		}
		*/
	}
}

switch-case分支语句

1.格式
                switch(表达式){
                case 常量1:
                    执行语句1;
                    //break;
                case 常量2:
                    执行语句2;
                    //break;
                ...
                default:
                    执行语句n;
                    //break;
                }
  2.说明:
        ① 根据switch表达式中的值，依次匹配各个case中的常量。一旦匹配成功，进入相应case结构中，执行相关语句。
          当调用完执行语句后，则仍然继续向下执行其他case语句，直到遇到break关键字或末尾结束为止。
        ② break 可以使用switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
        ③ 六种数据类型之一：switch结构中的表达式，只能是如下的byte、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)    
        ④ case 之后之能声明常量。不能声明范围
        ⑤ break关键字是可选的。
        ⑥ default：相当于if-else结构中的else。
            default 结构是可选的，而且位置是灵活的。

class SwitchCaseTest {
	public static void main(String[] args) {
		
	int number = 2;
		switch(number){
		case 0:
			System.out.println("zero");
			break;
		case 1:
			System.out.println("one");
			break;
		case 2:
			System.out.println("two");
			break;
		case 3:
			System.out.println("three");
			break;
		default:
			System.out.println("other");
			break;
		}

		//*********************************
		//运行报错，不能运行boolean类型
/*		boolean isHandSome = true;
		switch(isHandSome){
		case true:
			System.out.println("可乐吗？？");
			break;
		case false:
			System.out.println("薯条吗？？");
			break;
		default:
			System.out.println("输入有误！！！");
		}
*/
		//*********************************
		String season= "summer";
		switch(season) {
		case"spring":
			System.out.println("春暖花开");
			break;
		case"summer":
			System.out.println("夏日炎炎");
			break;
		case"autumn":
			System.out.println("秋高气爽");
			break;
		case"winter":
			System.out.println("冬雪皑皑");
			break;
		default:
			System.out.println("季节输入有误");
			break;
		}

		//**************************************
		//运行报错
/*		
		int age = 10;
		switch(age){			
		case age > 18:
			System.out.println("成年了");
			break;
		default:
			System.out.println("未成年");
			break;
		}	
*/

	}
}

练习

使用switch 把小写类型的char型转为大写。只转换a, b, c, d, e. 其它的输出“other”。
提示：String word = scan.next();  char c = word.charAt(0); switch(c){}

import java.util.Scanner;

class SwitchCaseExer1 
{
	public static void main(String[] args) 
	{
		Scanner scan = new Scanner(System.in);
		String word = scan.next();  
		char c = word.charAt(0); 
		switch(c){
		case 'a':
			System.out.println("A");
			break;
		case 'b':
			System.out.println("B");
			break;
		case 'c':
			System.out.println("C");
			break;
		case 'd':
			System.out.println("D");
			break;
		case 'e':
			System.out.println("E");
			break;
		default:
			System.out.println("other");
		}

	}
}

 对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”
说明：如果switch-case语句中多个相同语句，可以进行合并。

import java.util.Scanner;
class SwitchCaseExer2 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int score = scan.nextInt();

		/*方案一
		switch(score / 10){
		case 0:
		case 1:
		case 2:
		case 3:
		case 4:
		case 5:
			...
		case 59:
			System.out.println("不合格");
			break;
		case 60:
		case 61:
		case 61:
		case 63:
			...
		case 100:
			System.out.println("合格");
			break;
		}
		*/

		//方法2
		switch(score / 10){
		case 0:
			System.out.println("不及格");
			break;
		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;		
		}
		//方法二也可以合并
		switch(score / 10){
		case 0:
		case 1:			
		case 2:			
		case 3:			
		case 4:
		case 5:
			System.out.println("不及格");
			break;
		case 6:			
		case 7:			
		case 8:			
		case 9:			
		case 10:
			System.out.println("及格");
			break;		
		}
		//方法3
		//更优的解法
		switch(score / 60){
		case 0:
			System.out.println("不及格");
			break;
		case 1:
			System.out.println("合格");
			break;
		}

	}
}

根据用于指定月份，打印该月份所属的季节。
3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季

import java.util.Scanner;
class SwitchCaseExer3 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int month = scan.nextInt();
		
		switch(month){
		case 12:
		case 1:
		case 2:
			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;
		}

	}
}

编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序输出输入的日期为2019年的第几天

 

import java.util.Scanner;
class SwitchCaseExer4 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入2019年的month");
		int month = scan.nextInt();
		System.out.println("请输入2019年的day");
		int day = scan.nextInt();

		//定义一个变量来保存总天数
	/*  方法一
	    int sumDays = 0;
		if(month == 1){
			sumDays = day;
		}else if(month == 2){
			sumDays = 31 + day;
		}else if(month == 3){
			sumDays = 31 + 28 + day;
		}else if(month == 4){
			sumDays = 31 + 28 + 31 + day;
		}
		...
		else{
			sumDays = 31 + 28 + 31 + ... + day;
		}
	*/
		int sumDays = 0;

		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			sumDays += 29;
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}

		System.out.println("2019年" + month + "月" + day + "日是当年的第" + sumDays + "天");


	}
}

从键盘分别输入年、月、日，判断这一天是当年的第几天

注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除或
2）可以被400整除
(year % 4 == 0 && year % 100 != 0) || year % 400 == 0) 

import java.util.Scanner;
class SwitchCaseExer5{
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		System.out.println("请输入year");
		int year = scan.nextInt();
		System.out.println("请输入month");
		int month = scan.nextInt();
		System.out.println("请输入day");
		int day = scan.nextInt();

		//定义一个变量来保存天数
		int sumDays = 0;
		
		switch(month){
		case 12:
			sumDays += 30;
		case 11:
			sumDays += 31;
		case 10:
			sumDays += 30;
		case 9:
			sumDays += 31;
		case 8:
			sumDays += 31;
		case 7:
			sumDays += 30;
		case 6:
			sumDays += 31;
		case 5:
			sumDays += 30;
		case 4:
			sumDays += 31;
		case 3:
			//判断是否为闰年
			if((year % 4 == 0 && year % 100 != 0) || year %400 == 0){
				sumDays += 29;
			}else{
				sumDays += 28;
			}
		case 2:
			sumDays += 31;
		case 1:
			sumDays += day;
		}

		System.out.println(year + "年" + month + "月" + day + "日是当年的第" + sumDays + "天");
	}
}

说明： switch-case与if-else可互相嵌套

注意
        1.凡是可以使用switch-case的结构，都可以转换为if-else。反之，不成立     (switch结构中的表达式有要求)
        2.我们写分支结构时,当发现既可以使用switch-case,(同时,switch中表达式的取值情况不太多),又可以使用if-else，我们优先选择使用 switch-case 。原因:switch-case执行效率稍高。

循环结构

        （在某些条件满足的情况下，反复执行特定代码的功能 ）
                根据循环条件，重复性的执行某段代码。
                for、while、do…while、三种循环语句。
                注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。

            循环语句的四个组成部分
                初始化部分(init_statement)
                循环条件部分(test_exp) -->是boolean类型
                循环体部分(body_statement)
                迭代部分(alter_statement)

 for循环              

        For循环结构的使用
                    一、循环结构的4个要素
                        ①初始化条件;
                        ②循环条件;--->是boolean类型
                        ③循环体;
                        ④迭代条件；
                    二、for循环的结构
                            for(初始化条件;循环条件;迭代条件){
                                循环体
                            }
                执行过程：①-②-③-④-②-③-④-②-③-④-.....-②
                说明：
                    循环条件部分为boolean类型表达式，当值为false时，退出循环
                    初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
                    可以有多个变量更新（迭代），用逗号分隔

class ForTest  {
	public static void main(String[] args) {
		for(int i = 1;i <= 5;i++){
			System.out.println("HelloWorld!");
		}
		
	//练习
	int num = 1;
	for(System.out.print('a');num <= 3;System.out.print('c'),num++){
		System.out.print('b');
	}
	//输出结果：abcbcbc

	//例题：遍历100以内的偶数,输出所有偶数的和,输出偶数的个数
	int sum = 0;//接收所有偶数的和
	int count = 0;//接收偶数的个数
	for(int i = 1;i <= 100;i++){
		if(i % 2 == 0){
			System.out.println(i);
			sum += i;
			count++;
		}
	}
	System.out.println("总和为：" + sum);
	System.out.println("偶数个数为：" + count);

	}
}

练习

编写程序从1循环到150，
并在每行打印一个值，
另外在每个3的倍数行上打印“foo”,
在每个5的倍数行上打印“biz”,
在每个7的倍数行上打印“baz”

class ForExer1 {
	public static void main(String[] args) {
		for(int i = 1;i <= 150;i++){
			
			System.out.print(i + "  ");
			
			if(i % 3 == 0){
			System.out.print("foo  ");
			}
			if(i % 5 ==0){
			System.out.print("biz  ");
			}
			if(i % 7 ==0){
			System.out.print("baz  ");
			}
			//换行
			System.out.println();	
		}
	}
}

题目：输入两个正整数m和n，求其最大公约数和最小公倍数。

比如：12和20的最大公约数是4，最小公倍数是60。

说明：break关键字的使用

 

import java.util.Scanner;
class ForExer2 {
	public static void main(String[] args) {

		Scanner scan = new Scanner(System.in);

		System.out.println("请输入第一个正整数:");		
		int m = scan.nextInt();
		System.out.println(m);
		System.out.println("请输入第二个正整数:");
		int n = scan.nextInt();
		System.out.println(n);
		
		//获取最大公约数		
		/*
		//获取两个数中的较小值
		int min = (m <= n)? m : n;
		for (int i = min; i >= 1 ; i--){
			if(m % i == 0 && n % i == 0){
				System.out.println("最大公约数为：" + i);	
				break;//一旦在循环中执行到break，就跳出循环
			}	
		}
		*/

		//获取最小公倍数
		/*
		//获取两个数中的较大值
		int max = (m > n) ? m : n;
		for (int i = max; i <= m * n ;i++ ){
			if(i % m == 0 && i % n == 0){
				System.out.println("最小公倍数为：" + i);
				break;
			}
		}
		*/
	}
}

While循环          

           一、循环结构的4个要素
                ①初始化条件;
                ②循环条件;--->是boolean类型
                ③循环体;
                ④迭代条件；
            二、while循环的结构
                ①
                while(②){
                    ③;
                    ④;
                }
            ①-②-③-④-②-③-④-②-③-④-...-②
            注意：
                    不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
                    for循环和while循环可以相互转换
                    区别：for循环和while循环的初始化条件的作用范围不同

class WhileTest{
	public static void main(String[] args) {
		
		//遍历100以内的所有偶数
		/*int i = 1;
		while (i <= 100)
		{
			if(i % 2 == 0){
				System.out.println(i);
				}
			i++;
		}
		//出了whlie循环以后，仍可以调用
		System.out.println(i);//101
		*/
		int result = 0;
        int i= 1;
        while(i<= 100) {
            result += i;
            i++;
        }
        System.out.println("result="+ result);
	
	}
}

do-while循环 

        一、循环结构的4个要素
            ①初始化条件;
            ②循环条件;--->是boolean类型
            ③循环体;
            ④迭代条件；
        二、do-while循环结构
            ①
            {do
                ③;
                ④;
            }while(②);
        执行过程：①-③-④-②-③-④-②-③-④-...②
        说明：
                do-while循环至少执行一次循环体。
                开发中，基本使用for和while更多，较少使用do-while

class DoWhileTest {
	public static void main(String[] args) {
		
		//遍历100以内的偶数,并计算所有偶数的和即偶数的个数
		int num = 1;
		int sum = 0;//记录总和
		int count = 0;//记录个数
		do{
			if(num % 2 == 0){
			System.out.println(num);
			sum += num;
			count++;
			}
			num++;		
		}while(num <= 100);
		System.out.println("所有偶数的和为：" + sum);
		System.out.println("所有偶数的个数为：" + count);

		//*******************体会do-while至少执行一次*************
		int number1 = 10;
		while(number1 > 10){
			System.out.println("hello:while");
			number1--;
		}

		
		int number2 = 10;
		do{
			System.out.println("hello:do-while");
			number2--;		
		}while(number2 > 10);
		
	}
}

循环语句综合例题
        说明：
            1.不在循环条件部分限制次数的结构：while(true) , for(;;)
            2.结束循环有几种方式
                方式一：循环条件部分返回false
                方式二：在循环体中执行break

练习

从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序

import java.util.Scanner;

class ForWhileTest {
	public static void main(String[] args) {
		
		Scanner scan = new Scanner(System.in);
		
		int positiveNumber = 0;//记录正数的个数
		int negativeNumber = 0;//记录负数的个数
		
		while(true){    //for(;;){
			int number = scan.nextInt();
			
			//判断number的正负情况
			if(number > 0){
			positiveNumber++;
			}else if(number < 0){
			negativeNumber++;
			}else{
				//一旦执行break，就跳出循环
				break;
			}			
		}
		System.out.println("正数的个数：" + positiveNumber);
		System.out.println("负数的个数：" + negativeNumber);



	}
}

嵌套循环
        1.嵌套循环：将一个循环结构A声明在另一个循环结构B的循环体中，就构成了嵌套循环
            外层循环：循环结构B
            内层循环：循环结构A
        2.说明
            ① 内层循环遍历一遍，只相当于外层循环循环体执行了一次
            ② 假设外层循环需要执行m次，内层循环需要执行n次。此时内层循环的循环体一共执行了m * n次
        3.技巧
            外层循环控制行数，内层循环控制列数

class ForforTest {
	public static void main(String[] args) {
		
		//******
		//System.out.prntln("******")
		for(int i = 1;i <= 6;i++){
			System.out.print("*");
		}
		System.out.println("\n");

		/*
		******
		******
		******
		******
		*/
		
		//方法一(4行可以，400行呢)
		/*
		for(int i = 1;i <= 6;i++){
			System.out.print("*");
		}
		System.out.println();
		for(int i = 1;i <= 6;i++){
			System.out.print("*");
		}
		System.out.println();
		for(int i = 1;i <= 6;i++){
			System.out.print("*");
		}System.out.println();
		for(int i = 1;i <= 6;i++){
			System.out.print("*");
		}
		*/
		//方法二：嵌套循环
		for (int j = 1;j <= 4;j++ ){
			for(int i = 1;i <= 6;i++){
			System.out.print("*");
			}
			System.out.println();
		}

		/*			i(行号)		j(*的个数)
		*			1			1
		**			2			2
		***			3			3
		****		4			4
		*****		5			5
		*/
		
		for(int i = 1;i <=5;i++){//控制行数
			for(int j = 1;j <= i;j++){//控制列数
				System.out.print("*");			
			}
			System.out.println();		
		}

		/*			i(行号)		j(*的个数)
		****		1			4
		***			2			3
		**			3			2
		*			4			1
		*/

		for (int i = 1;i <= 4;i++ ){
			for(int j = 1;j <= 5 - i;j++){
				System.out.print("*");	
			}
			System.out.println();
		}

			/*
			*
			**
			***
			****
			*****
			****
			***
			**
			*
			*/

			for(int i = 1;i <= 5;i++){
				for(int j = 1;j <= i;j++){
				System.out.print("*");
				}
			System.out.println();
			}
			for(int i = 1;i <= 5;i++){
				for(int j = 1;j <= 5-i;j++){
				System.out.print("*");
				}
			System.out.println();
			}
/*
    * 
   * * 
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 
   * * 
    * 
*/
		// 上半部分
		for (int i = 0; i < 5; i++) {
			// 输出“*前面的空格”
			for (int j = 0; j < 4 - i; j++) {
				System.out.print(" ");
			}
			// 输出“* ”
			for (int k = 0; k < i + 1; k++) {
				System.out.print("* ");
			}
			System.out.println();
		}
		// 下半部分
		for (int i = 0; i < 4; i++) {
			for (int j = 0; j < i + 1; j++) {
				System.out.print(" ");
			}
			for (int k = 0; k < 4 - i; k++) {
				System.out.print("* ");
			}
			System.out.println();
		}


	}
}

应用：九九乘法表

class NineNineTable {
	public static void main(String[] args) {
		
		for(int i = 1;i <= 9;i++){
			for(int j = 1;j <= i;j++){
				System.out.print(i + " * " + j + " = " + (i * j) + "  ");			
			}
			System.out.println();	
		}
	}
}

100以内的所有质数（典型）

class PrimeNumberTest {
	public static void main(String[] args) {		
		
		boolean isFlag = true;		//标识i是否被j除尽，一旦除尽，修改其值
		
		for(int i = 2;i <= 100;i++){       //遍历100以内的自然数
				
			for(int j = 2;j <= i-1;j++){   //j:被i去除
					
				if(i % j == 0){		//i被j除尽
				isFlag = false;
				}			
			}
			if (isFlag == true){
				System.out.println(i);
			}
			isFlag = true;	//重制isFlag
		}


	}
}

输出质数的一个调优

class PrimeNumberTest1 {
	public static void main(String[] args) {		
		
		boolean isFlag = true;		//标识i是否被j除尽，一旦除尽，修改其值
		
		int count = 0;//记录质数的个数

		//获取当前时间的毫秒数，距离1970-01-01 00:00:00到现在的毫秒数
		long start = System.currentTimeMillis();

		for(int i = 2;i <= 100000;i++){       //遍历100000以内的自然数
			
			//优化2:改成j<根号i(对本身是质数的自然数更有效)
			for(int j = 2;j <= Math.sqrt(i);j++){//for(int j = 2;j < i;j++){     //j:被i去除
					
				if(i % j == 0){		//i被j除尽
				isFlag = false;
				break;		//优化1：只对本身非质数的自然数是有效的
				}			
			}
			if (isFlag == true){
				//System.out.println(i);
				count++;
			}
			isFlag = true;	//重制isFlag
		}


		//获取当前时间的毫秒数，距离1970-01-01 00:00:00到现在的毫秒数
		long end = System.currentTimeMillis();
		System.out.println("质数的个数为：" + count);
		System.out.println("所花费的时间为：" + (end - start));//优化之前:8168(约8秒)
															   //优化1之后:988(约1秒)
															   //优化2之后:405
															   //优化1,2后:298
															   //优化1,2,3后:0
	}
}

class PrimeNumberTest2 {
	public static void main(String[] args) {		
				
		int count = 0;//记录质数的个数

		lable:for(int i = 2;i <= 100000;i++){       //遍历100000以内的自然数
						
			for(int j = 2;j <= Math.sqrt(i);j++){
					
				if(i % j == 0){		//i被j除尽
				continue lable;
				}			
			}	
			//执行到此步骤的都是质数
			count++;
		}
		System.out.println("质数的个数：" + count);
	}
}

break、continue特殊关键字的使用  

                     使用范围            循环中使用的作用(不同点)            相同点
break           switch-case            
                     循环结构中             结束当前循环                    关键字后面不能声明执行语句

continue      循环结构中             结束当次循环                    关键字后面不能声明执行语句

                        //break;    //默认跳出包裹此关键字最近的一层的循环
                        //continue;    //默认跳出包裹此关键字最近一层循环的该次
                        //break lable;//结束指定标识的一层循环结构(要结束lable层循环,eg:  lable:for)
                        //continue lable;//结束指定标识的一层循环结构的当次循环

class BreakContinueTest {
	public static void main(String[] args) {
		
		for (int i = 1;i <= 10;i++){

			if (i % 4 == 0){
				//break;//123
				continue;//123567910
			}
			System.out.print(i);
		}
		
		System.out.println();
		//**********************************
		
		lable:for(int i = 1;i <= 4;i++){
			
				for(int j = 1;j <= 10; j++){
					
					if(j % 4 == 0){
						//break;	//默认跳出包裹此关键字最近的一层的循环
						//continue;	//默认跳出包裹此关键字最近一层循环的该次

						//break lable;//结束指定标识的一层循环结构
						continue lable;//结束指定标识的一层循环结构的当次循环
					}
					System.out.print(j);
				}
				System.out.println();
		}

	}
}

附加：
        return：并非专门用于结束循环的，它的功能是结束一个方法。

        当一个方法执行到一个return语句时，这个方法将被结束

练习

一个数如果恰好等于它的因子之和，这个数就称为"完数"。
例如6=1＋2＋3。编程 找出1000以内的所有完数。（因子：除去这个数本身的其它约数）

class Exer{
	public static void main(String[] args) {
		
		//int factor = 0;
		for(int i = 1;i <= 1000;i++){
			int factor = 0;
			for(int j = 1;j <= i-1;j++){
				if(i % j == 0){
					factor += j;
				}			
			}
			if(i == factor){
				System.out.println(i);
			}
			//factor = 0;//重置factor
		}

		//优化
		/*
		for(int i = 1;i <= 1000;i++){
			int factor = 0;
			for(int j = 1;j <= i/2;j++){
				if(i % j == 0){
					factor += j;
				}			
			}
			if(i == factor){
				System.out.println(i);
			}
		}
		*/
   }
}

练习：输出如下图形

******
*****
****    
***    
**    
*    

class Exer1 {
	public static void main(String[] args) {
		//外层循环控制行数
		//内层循环控制列数
		for(int i = 1;i <= 6;i++){
			for(int j = 1;j <= 7-i;j++){
				System.out.print("*");
			}
			System.out.println();
		}

	}
}