今天给大家带来的是初级Java基础部分的知识：包括初始Java、变量、常量、数据类型、运算符、各种选择结构、循环结构、数组等Java的基础语法部分！最后还有****循环结构的进阶****,步骤超详细，值得收藏(๑•̀ㅂ•́)و✧！！！　　另附有各种案例的源代码（可以直接用O(∩_∩)O~）！！！仔细看完它，扎实的基础不再是空谈，万丈高楼平地起，当有了扎实的基础知识，后面学习面向对象以及项目的开发时，压力就减少了很多，所以基础知识不能被轻易的忽略！！！给个关注奥一、初识Java

使用记事本开发程序的步骤（注意：整个操作过程都是英文）：

1 编写源程序

首先新建一个文本文件，修改其后缀名为“.java" ---->然后再里面编写我们需要的代码

  public  class  HelloWorld{    public  static  void main(string[] args){       system.out.println("Hello Java!!!");   }}

public:公共的公开的，处处可以访问。

class：类，类别，类似狗狗类，电脑类等。

HelloWorld:类名称，有一个要求，必须和文件名称保持一致

public static void main(String[] args){} ---->>> 入口方法，所有需要运行的代码都需要放到这里来，固定写法

static：关键字（计算机中已经使用的名字，我们就不能再使用）

void:返回值类型，void表示没有返回值

main:是入口方法的方法名

易错点：

①大括号要成对出现

②String中的”s”要大写

③我们在每一句话之后都需要使用英文的分号结束

④System中的”s”需要大写

⑤类名需要和文件名保持一致

所有的输出内容需要在引号里面

2 编译源程序

因为编写的是我们人写的，但是计算机是看不懂的，所以需要一个“翻译” 编译成一个 ".class" 结尾的文件（半机器语言）。我们在dos命令中进入到文件所在目录，输入命令 javac xxx.java 类编译同时会生成一个以“class”结尾的字节码文件

3 运行

编译成功之后，即可运行，输入 java xxx 即可.在控制台即可出现在打印语句中双引号中的内容了（所有需要打印的内容都需要在双引号中）

符号的含义：

\t：一个制表符的空格

\n：换到下一行的初始位置

注释的作用：解释说明，不会被编译运行单行注释： //多行注释： /* */文档注释： /** */

二、变量，常量，数据类型和运算符1.变量

引入：人的计算是在大脑中进行的，计算机的计算是在内存中进行的，内存就好比酒店根据人员的多少开辟适当大小的空间(单人OR双人，来存储各种数据。

诞生：内存中的每个空间都是相互独立的，且都有自己的地址值。

找数据：存入数据并不是目的，我们最主要的是存入了方便之后的使用。每个空间都是有其地址值，地址值是相对比较长且不好记忆的，我们可以像宾馆样给每个空间（房间）起一个名字，这个空间有自己的名称（变量名）和类型（数据类型）

1.1 定义：

一个存储空间的表示，其值是可以变化的。（例如买了一双鞋，鞋盒用来孵小鸡，鞋盒就是变量，鞋子和小鸡是里面的值。）

通过变量名可以简单快速的找到它存储的数据！！！1.2 为什么使用变量

案例：

// System.out.println("好好学习");// System.out.println("好好学习");// System.out.println("好好学习");// System.out.println("好好学习");   //.....   //现在我想写好好学习天天向上，那我需要对每一个输出语句进行修改，很麻烦   //其实我们是可以避免这种情况的出现的，就是使用变量 String str="好好学习，天天向上"; System.out.println(str); System.out.println(str); System.out.println(str);

//像以上的情况，我们只需要修改一处即可，这就是变量的好处

1.3 使用步骤：

第一步：声明变量（声明变量的时候变量名不能重复）

即根据数据类型在内存申请空间

数据类型 变量名；int money;（int是数据类型，money是变量名）

第二步：赋值

即将数据存储在对应的内存空间

变量名=数值； money=1000;

上面两步可以合二为一

int money =1000; 其含义是：在内存中开辟了一个int类型的空间，给其命名为money，并为其赋值为1000；

第三步：使用

即取出数据

注意：

在声明变量的时候变量名不能重复

当在程序中使用“+”的时候，符号左右两侧如果有一个数据是字符串则将两个值拼接（如果后面有多个“+”则将多个值拼接），如果都是数值型则计算和

1.4 命名的规则

　一个好的命名规范是一个程序员必备的素质，不遵守规范不一定会错，但一定会被鄙视。（凡是自己起的名字都要遵守以下规范）　　1. 以数字，字母，下划线和$符号组成，其中不能以数字开头；　　2.不能和java中的关键字重名；　　3.尽量遵守见名知意和驼峰命名（有多个单词首个单词首字母小写后面单词首字母大写）规则。

public static void main(String[] args) {　　　　　//1声明        int money;                 //2赋值        money=100;        /**         * 第一第二两步合并         * 声明变量的时候变量名不能重复           */        int m = 100;                 String name="张三";        int age =27;        double score=89.0;        //是否及格  使用 true :  及格     false:不及格        boolean  flag =true;                 //3使用        System.out.println("和"+age+score);        System.out.println("金额:："+money);        System.out.println("姓名："+name);        System.out.println("年龄："+age);        System.out.println("分数："+score);    }

1.5 常见错误

未声明且赋值直接使用

标记位置序错误

在同一个作用域中声明了相同名字的变量名

2.常量2.1 为什么使用常量

在实际开发和生活中有些值是一开始定义了在后面就不能修改的，如:圆周率

2.2 定义：

一个存储空间的表示，其值是不可以发生变化的。

final修饰常量，final修饰的值在声明的时候就赋值且后面不能改变（在数据类型前加final 如 final int）

2.3 优点：

一旦定义后期不能修改，所以其是相对安全的

2.4 命名规则：

优点：

一旦定义后期不能修改，所以其实相对安全的推荐做法：

常量名通常大写；

只能被赋值一次，通常定义时即对其初始化

常量名都要大写，如果是多个单词组成，则使用下划线分割

public static void main(String[] args) {        // TODO Auto-generated method stub/** * 常量的案列演示 * 计算圆的面积 */        final   double       MY_PI =3.14;        /*pi=3;*/        double  r=2;        double  area=MY_PI * r * r;        System.out.println("面积是："+area);             }

3.数据类型分类：3.1 基本数据类型：1、数值型1）整型（可以存放整数）：

byte(1个字节)

short(2个字节)

int(4个字节) （默认使用）

long(8个字节)

2）浮点型（表示小数）：

float(4个字节)

double(8个字节) （默认使用）

2、非数值型1）字符型—————需要给值加上单引号，只能存一个字符

char(2个字节)：本质上是一个整数，是字符的Unicode码值

2）布尔型————结果只有两种 true/false

boolean

3.2 引用数据类型：1）String：可以存储多个字符使用双引号引起来2）数组3）枚举

4.运算符分类：4.1 赋值运算符：

赋值符号：= 将右边的值赋给左边的变量

变量名 =表达式；

表达式举例：

4.2 算术运算符：

符号：+ - * / % ++ --

++放在变量前指先加1在使用；放在变量后指先使用再加1

--放在变量前指先减1在使用；放在变量后指先使用再减1

%只求余数

num+=2;(意思为num=num+2;)

public static void main(String [] args){       //++ --       int a=4;       int b=2;       int c=5;       /*       System.out.println((a+b));       System.out.println((a-b));       System.out.println((a*b));       System.out.println((a/b));       System.out.println((a+b));       System.out.println((a+b));*/               System.out.println(a++);//输出结果为4       System.out.println(a);//输出结果为5       System.out.println(++a);//输出结果为6       System.out.println(c%b);//输出结果为1   }

4.3 关系运算符

运算符含义举例结果==等于5==6false!=不等于5!=6true>大于5>6false<小于5<6true>=大于等于5>=6false<=小于等于5<=6true

注意：

= 为赋值运算符，== 等于运算符

表达式返还给我们的结果类型都是boolean 类型

4.4 逻辑运算符：

运算符含义运算规则&&短路与两个表达式结果都是true结果才是true||短路或只要有一个为true 结果就为true!取反将原来表达式结果取反& |

ABA&&BA||BTTTTTFFTFTFTFFFF

&& 一假必假

|| 一真必真

public static void main(String[] args) {        // TODO Auto-generated method stub      int a=4;      int b=2;      int c=5;             //a>b为T,b>c为F 所以a>b||b>c为T；a<c为T所以整个表达式为T      System.out.println(a>b   ||    b>c    &&    a<c);    }

4.5 三目（元）运算符（条件运算符）：

语法：

boolean表达式？ 表达式1:表达式2;

当boolean表达式的结果为true的时候 执行表达式1

当boolean表达式的结果为false的时候 执行表达式2

案例：

int a=5;    int b=10;    int c= a>b?  0:1;    System.out.println(c);//结果为1 int a=5;    int b=10;    String c= a>b?  "正确":"错误";    System.out.println(c);//结果为错误返回值的数据类型需要和执行的表达式的数据类型一致

运算符优先级

5.类型转换5.1 自动类型转换

好比生活中有两个水杯，一个大的一个小的，如果将装满水的小杯中水倒入空的大杯，是可以的，类似于这样的场景在java中称之为自动类型转换

案例1：

double first=81.99;int duo=2;double  seconde=first+duo;

案例2：

问题: 某班第一次Java考试平均分81.29，第二次比第一次多2分，计算第二次考试平均分？

double firstAvg=81.29;  double secondAvg;  int rise=2;secondAvg=firstAvg+rise;   //一个double类型和一个int类型System.out.println(secondAvg);   // 结果是double类型    83.29

规则：

①在整个表达式中，如果有double数据类型的话，则整个表达式的结果会自动的提升为double类型

②在自动类型转换的表达式中数据类型需要兼容。如：都是数值型

③目标类型要大于原类型

5.2 强制类型转换

好比生活中有两个水杯，一个大的一个小的，如果将装满水的大杯中水倒入空的小杯，是可以的但是会溢出，类似于这样的场景在java中称之为自强制类型转换

语法：

数据类型 变量名=（数据类型）（表达式）；————是先运算表达式，然后将结果转换

如：int seconde=(int) (first+duo); 或 int seconde=(int) (first）+duo;————先将first转换为int类型在计算，最后将结果转换为int类型

缺点：丢失精度，尤其在财务等方面慎用！！！（double转int 丢失的是小数点后面的所有值不是四舍五入）

案例1：

double  first=81.99;int  duo=2;int  seconde=(int) (first+duo);//结果是83

案例2：

问题：

去年Apple笔记本所占市场份额是20，今年增长的市场份额是9.8，求今年所占份额？

解析：

int before = 20; //apple笔记本市场份额

double rise = 9.8; //增长的份额

编译出错的情况：

int now =before + rise; //不能完成自动类型转换

更改为; int now =before+(int)rise; //强制类型转换

5.3 boolean类型

使用场景：

当我们遇到 真 或者 家 , 是 或者 否,类似于这样两种情况的时候可以使用boolean类型的值

boolean 类型的值:false 和 true

如何使用：

案例问题：从控制台输入张三同学的成绩，与李四的成绩（80分）比较，输出“张三的成绩比李四的成绩高吗?“ 的判断结果

6.Scanner

引入:之前我们都是在程序中定义变量，但是如果想让用户从键盘输入怎么办呢?就需要使用Scanner

作用：接收用户在键盘输入的值使用步骤：①导包

import java.util.Scanner; / import java.util.*; (java.util是包名 Scanner是类名，

如果用*则表示取java.util包下的所有类，两种方法都行)

ps:在Eclipse中导包的快捷键：Ctrl + Shift + O。初学者不建议导，熟练之后再运用快捷键更佳！！！

②创建Scanner 对象

Scanner tx = new Scanner (System.in);

③使用 常用方法

接收int型 int age= tx.nextInt();

接收double型 double score=tx.nextDouble();

接收String类型 String name=tx.next();

注意

第二步中新建的Scanner中用的什么名（tx）第三步中就用什么名

由于工具的原因，在编写提示语的时候将ln去掉；如将System.out.println("请输入年龄：");的ln去掉即为System.out.print("请输入年龄：");

package cn.kgc.tx.ketang;​//1、导包import java.util.Scanner;​public class Demo4 {​    public static void main(String[] args) {        // TODO Auto-generated method stub                 //2、创建Scanner  对象     Scanner  tx = new Scanner (System.in);           //3、使用     System.out.print("请输入年龄：");     int age=tx.nextInt();     System.out.print("请输入姓名：");     String name=tx.next();     System.out.print("请输入分数：");     double score=tx.nextDouble();     System.out.print("年龄是："+age+"，姓名是："+name+"，分数是："+score);    }}

7.包的使用

新建的包都使用小写字母组成，不能有中文或者特殊符号

新建的包使用公司域名去掉3w其他内容倒写，如 cn.kgc.公司定义

新建的每个类我们使用的每个单词的首字母大写

在每个类中都会有且只有一个 package+包的名字（且在代码的第一行）

三、程序选择结构3.1基本选择结构语法：

if(不同类型的条件){

​ 如果条件为真，则执行

}

条件为假的时候执行大括号后面的内容

if () { // 括号里必须是布尔条件表达式

//代码块，只有一条语句的时候大括号可以省略，但是不建议那么做

}

流程图案例：

如果张浩的Java考试成绩大于98分，张浩就能获得一个MP4作为奖励

//解析：题目中有 如果 ....就.... 其实是对应我们英文中的单词就可以使用 if 选择结构完成

public static void main(String[] args){       //  如果    。。。java>98       //就有奖励        double   javaScore=100;                 if(javaScore  >98){            //条件为真则执行这里再向下执行            System.out.println("有一个硬盘奖励");        }       //条件结果为假的话，直接跳到这里执行        System.out.println("程序结束");   }　　

3.2复杂程序结构

主要是和我们的各种运算符相互结合使用

如：张浩的Java成绩大于98分，而且音乐成绩大于80分，老师会奖励他；或者Java成绩等于100分，音乐成绩大于70分，老师也会奖励他

public static void main(String[] args) {        // TODO Auto-generated method stub    Scanner tx=new Scanner(System.in);    System.out.print("张浩的Java成绩是：");    int javaScore=tx.nextInt();    System.out.print("张浩的音乐成绩是：");    int musicScore=tx.nextInt();    if((javaScore>98&&musicScore>80)||(javaScore==100&&musicScore>70)){        System.out.println("奖励张浩一个MP5");    }         System.out.println("程序结束");}if-else为什么使用if-else ?

使用传统的if选择结构也可能完成如果否则之类的问题，但是可能造成代码的冗余，浪费时间。

案例1：

如果张浩Java考试成绩大于98分，老师就奖励他一个MP4，否则老师就罚他进行编码

解析：我们可以使用两个 if 选择结构。如：

if (score > 98) {  System.out.println("老师说:不错，奖励一个MP4！");}  if (score <= 98) { System.out.println("老师说:惩罚进行编码！");}

但是这样容易出现一个问题（可以打断点执行看）：

程序都是从上至下执行的，如果第一个条件不满足执行后面的程序没问题，但是如果第一个条件已经成立，后面的不需要执行，但是这种两个if条件写的程序，第一个条件不管是否成立都会执行

就影响性能

如何解决呢？请看后续脑图...

案例2：

if(zhangScore>98){       System.out.println("奖励一个MP4");    }   //使用之前的基本选择结构可以做，但是可能会造成代码的冗余   //执行的效率就降低了   if(zhangScore<60){       System.out.println("俯卧撑30个");   }

所以我们使用 if-else

语法：

if(){    //布尔类型的表达式  //条件为真进入执行代码块1 }else{  //条件为假进入代码块2}

流程图：案例：

if(zhangScore>98){            //如果张浩成绩大于98有奖励        System.out.println("奖励一个MP4");   }else {  //否则俯卧撑30个       System.out.println("俯卧撑30个");       }

多种if选择结构

为什么使用多种if

在我们的之前学习过程中，都是判断两种情况，不是怎么样就是怎么样。在实际生活中是可能出现区间选择的，如：分数的评级

成绩>=80 ：良好 成绩>=60 ：中等成绩<60 ：差

类似这样，单个的if无法完成，多个if又比较麻烦，那就可以使用我们即将学习的多重 if

语法：

if(){}else  if(){}else  if(){}else{ }

流程图：

案例：

//对学员的结业考试成绩评测 成绩>=80 ：良好   成绩>=60 ：中等 成绩<60   ：差    public static void main(String[] args) {        // TODO Auto-generated method stub      Scanner tx=new Scanner(System.in);      System.out.print("请输入考试成绩：");      int score=tx.nextInt();      if(score>=80){          System.out.println("良好");      }else if(score>=60){          System.out.println("中等");      }else {          System.out.println("差");      }        }

在我们执行的程序过程中，程序是自上而下执行的，所以条件判断的时候，会在第一个判断条件满足的时候停下并执行，后面的内容就不会再执行了

所以，在条件判断的时候，条件的语句顺序不能随便的写，要按照一定的顺序

嵌套if选择结构

案例引入：

男：今晚我们去看电影吧？

女：好啊，不过晚于6点还有其他事就不去了

分析：女是答应去的，但是有前提条件就是不能迟于6点钟

这里就相当于有两个if条件,第一个条件满足才会执行后面的内容

语法：

if(条件1){  if(条件2){   // 代码块1 当两个if都满足时才运行  }else{    //代码块2  }}else{  //代码块3}

流程图：案例：

问题：学校举行运动会，百米赛跑跑入10秒内的学生有资格进决赛，根据性别分别进入男子组和女子组

分析：如果进入决赛 再看是男还是女，如果是男进入男子组女就进入女子组。这就使用到了嵌套if选择结构

1

@Test

　 public void demo8(){      System.out.print("请输入你的跑步成绩：");      //输入成绩      double score=tx.nextDouble();      //对成绩进行判断      if(score<=10){          //如果成绩合格再判断性别          System.out.print("请输入你的性别：");          String sex=tx.next();          //判断性别          if(sex.equals("男")){              System.out.println("恭喜进入男子组决赛");             }else if(sex.equals("女")){              System.out.println("恭喜进入女子组决赛");      }    else {              System.out.println("输入错误");      }  }else{      System.out.println("很遗憾你没有进入决赛");  }       }

案例2

1.输入小明的考试成绩，显示所获奖励。成绩==100分，爸爸给他买辆车

100分>成绩>=90分，妈妈给他买MP4 ； 90分>成绩>=60分，妈妈给他买本参考书 ；成绩<60分，什么都不买 Scanner input = new Scanner(System.in); int score = input.nextInt(); // 接收成绩 if (score == 100) {   System.out.println("他爸爸给他买辆车"); } else if (score >= 90) {   System.out.println("他妈妈给他买MP4"); } else if (score < 90 && score >= 60) {   System.out.println("他妈妈给他买本参考书"); } else {   System.out.println("什么都不买"); }  

2.

Scanner input = new Scanner(System.in);     System.out.println("请输入是否是会员：是（y）/否（其他字符）");     String identity = input.next();     System.out.println("请输入购物金额：");     double money = input.nextDouble();     if(identity.equals("y")){ //会员       if(money>200){          money = money * 0.75;       }else{          money = money * 0.8;       }     }else{ //非会员       if(money>100){          money = money * 0.9;       }     }     System.out.println("实际支付：" + money);

3.

/* 输入会员积分 */     System.out.print("请输入会员积分： ");     Scanner input = new Scanner(System.in);     int custScore = input.nextInt();     double discount;       /* 判断折扣 */     if (custScore < 2000) {       discount = 0.9;     } else if (2000 <= custScore && custScore < 4000) {       discount = 0.8;     } else if (4000 <= custScore && custScore < 8000) {       discount = 0.7;     } else {       discount = 0.6;     }     System.out.println("该会员享受的折扣是：" + discount);

　　

switch选择结构语法：

switch(表达式){     //表达式为 int、short、byte、char、枚举、String类型    case常量1:   //计算表达式的值    语句;        //如果等于常量1    break;    case常量2:    语句;       //如果等于常量2    break;   ……    default:    语句;           //如果没有找到匹配的值    break;    }

注意：

switch后面只能跟6种类型

3种整数型：byte、short、int

两个字符相关：char、String

一个枚举型

字符串需要在jdk7.0之后才能使用

案例1:

韩嫣参加计算机编程大赛: 如果获得第一名，将参加麻省理工大学组织的1个月夏令营;如果获得第二名，将奖励惠普笔记本电脑一部;如果获得第三名，将奖励移动硬盘一个;否则，不给任何奖励

   @Test      public void demo3(){          int mc=2;          if(mc==1){              System.out.println("夏令营");          }else if(mc==2){              System.out.println("电脑");          }else if(mc==3){              System.out.println("硬盘一个");          }else{              System.out.println("明年继续努力");          }          System.out.println("程序结束");      }

以上是使用多重if选择结构的完成，但是从代码的结构上看，显得代码冗余，结构复杂，有多次的等值判断。

为了解决上述问题，我们引出switch的选择结构

/**    * 1.常量名不可重复    * 2.每一个case后面要有break结束语    * 3.default可以在任何位置，除了在最后break可以省略在其他位置都不可省略（题意要求的除外）    *   建议都放在最后    * 4.switch后面的表达式类型只能是int byte short char  枚举  和jdk1.7以后的String    * 5.case后面的常量不是一定要连续的    * 6.表达式是哪个就会跳转到相对于的case语句    */   int mingCi=2;   switch(mingCi){   case 1:    System.out.println("参加夏令营活动");    break;   case 2:    System.out.println("奖励笔记本一部");    break;   case 3:    System.out.println("奖励移动硬盘一个");    break;    default:     System.out.println("没有奖励");    break;   }   System.out.println("程序结束");

　　

if选择结构和switch选择结构的使用场景

if选择结构我们一般都是使用在区间判断上，而switch选择结构一般是作用在等值判断

案例2：

@Test    public void demo9(){        System.out.print("输入1到7选择周一到周日大礼包：");        String num=tx.next();        switch(num){        case "1":            System.out.println("早上8点起床写代码");        break;        case "2":            System.out.println("早上9点起床写代码");        break;        case "3":            System.out.println("早上8半点起床写代码");        break;        case "4":            System.out.println("早上7点半起床写代码");        break;        case "5":            System.out.println("早上7点起床写代码");        break;        case "6":            System.out.println("写代码写到晚上12点");        break;        case "7":            System.out.println("早上8点起床写代码");        break;         default:            System.out.println("别想逃，输别的没有用的");        break;        }

switch常见错误

1

常见错误1：

常见错误2：

常见错误3：1

　　

比较switch和多重if选择结构

相同点

都是用来处理多分支条件的结构

不同点

if多用于区间的判断

switch用于等值条件的判断

用switch能做的，用if都能做，但反过来则不行

选择结构的总结

到目前为止我们学习过五种选择结构：

基本if选择结构： 处理单一或者组合条件的情况

if-else选择结构：处理简单的条件分支情况

多重if选择结构：处理复杂的条件分支情况

嵌套if选择结构：用于较为复杂的流程控制

switch:选择结构：多重分支并且条件判断是等值判断的情况。

如何处理系统异常

使用hasNextInt()解决问题2

Scanner input = new Scanner(System.in);       //如果输入的是数字    if (input.hasNextInt()) {        int num = input.nextInt();        switch (num) {        case 1:            //显示系统主菜单；             break;        case 2:            System.out.println("谢谢您的使用！");  break;        default:            System.out.println("输入错误。");break;        }    } else {     //如果输入的不是数字        System.out.println("请输入正确的数字！");    }

　　

四、循环结构（重点）为什么使用循环：

在达到同样的效果的同时可以用较简洁的代码

public void demo1(){        //直接打印：易错、代码量多、效率低        System.out.println("好好学习第一遍");        System.out.println("好好学习第二遍");        System.out.println("好好学习第三遍");             System.out.println("好好学习第四遍");    }

使用循环即可解决

概念：

一直重复做的有开始有结束的事

循环的特征：

循环条件：开始结束的条件

循环操作：一直需要重复做的事

循环变量：能够对循环条件的结果产生影响的量

4.1 while循环特点：

先判断，后执行

如果循环条件开始就不符合的时候，循环操作一遍也不会执行

语法：

while(循环条件//boolean类型表达式){  循环操作}

流程图：

案例1：

/*打印50份试卷     * 循环特征：     *            循环条件：开始结束的条件     *            循环操作：一直需要重复做的事     *            循环变量：能够对循环条件的结果产生影响的量     */    @Test    public void demo3(){        int a=1;        while (a<=50){     //循环条件            //循环操作            System.out.println("打印第"+a+"份试卷");            a++;   //循环变量        }    }　　

案例2（while循环进阶）：

分析：明确是否能用循环做？若能，明确循环结构需要的量。String类型的比较用equals()

 @Test　　Scanner sc = new Scanner(System.in);   System.out.println("老师我合格了么（y/n）: ");   String answer=sc.next();   while(answer.equals("n")){    　　System.out.println("上午阅读教材，下午上机操作");    　　System.out.println("老师我合格了么？（y/n）: ");    　　answer=sc.next();   }   System.out.println("程序结束");

　　

4.2 do—while循环为什么需要使用do—while循环？

在生活中往往会有一些事情是需要我们先做然后再去判断的。如：期末考试之前需要先学习一个学期

语法：

do{  循环操作}while(循环条件)；//循环条件时boolean类型

流程图：执行特点：

先执行，后判断。

条件为假，也至少执行一次循环操作

案例：

经过几天的学习，老师给张浩一道测试题，

让他先上机编写程序完成，

然后老师检查是否合格。如果不合格，则继续编写。……

@Testpublic void demo1(){        String answer;        do {            //循环操作            System.out.println("先上机考试");            System.out.println("老师我合格了吗？");            answer=tx.next();        }while ("n".equals(answer));        System.out.println("程序结束");            }　while 和do...while的区别：不同点：语法不同；执行次序不同；初始情况不满足条件时；while循环一次都不执行；do-while循环不管任何情况都会执行一次。

4.3 for循环（难点）为什么使用for循环：

有很多问题用我们之前的whie循环是可以的，也可以使用我们现在for循环，类似于运动员有的擅长跑，有的擅长短跑，但是都是长跑的。我们的循环也是一样，只是他们都有自己擅长的领域。对比for循环的结构和while循环的结构，其实结构都是一样

的只是每个部分所在的位置有所不同，之前所在的是多行的内容现在放到一个括号里面了。

代码更简洁：while循环中有的表达式在for中都有

适用场景：循环次数固定的情况下使用

语法：

for(初始化循环变量;循环条件;修改循环变量的值){  循环操作}

易错点：

初识化循环变量可以省略但是需要在for上面写

循环条件和修改循环变量的值不能省略否则会死循环

初始化循环变量、循环条件、修改循环变量的值都不写的话（分号不能省）会死循环

案例：

商场对顾客的年龄层次进行调查

计算各年龄层次的顾客比例

@Test    public void demo6(){        double num2=0; //声明30岁以下人员数        double num3=0; //声明30岁以上人员数        for (int i=1;i<=10;i++){            System.out.print("请输入第"+i+"位顾客的年龄：");            int num1=tx.nextInt();            if (num1<=30){                 num2++;            }else {                 num3++;            }              }        System.out.println("30岁以下的比列是："+(num2/(num2+num3)));        System.out.println("30岁以上的比列是："+(num3/(num2+num3)));    }

　　

4.4 break和continue的不解之缘含义：

break：终止本循环，继续向后执行

continue：终止本次循环，继而执行下一次的循环操作

break作用：

改变程序控制流

用于do-while、while、for中时，可跳出循环而执行循环后面的语句

break通常在循环中与条件语句一起使用

continue作用:

中断此次循环，继续下次循环

continue通常与条件语句一起使用加速循环

案例：break：

循环录入某学生5门课的成绩并计算平均分。如果某分数录入为负，停止录入并提示录入错误

循环录入成绩，判断录入正确性。录入错误，使用break语句立刻跳出循环；否则，累加求和

@Test    public void demo7(){        int sum=0;    //成绩总和        boolean flag=false;   // false 表示输入的分数不是负数       true表示输入的分数是负数        for (int i=0;i<5;i++){            System.out.print("请输入第"+(i+1)+"门课的成绩：");            //循环录入的成绩            int score=tx.nextInt();            if (score<0){                flag =true;                break;            }            sum=sum+score;        }        if(flag){            System.out.println("输入错误");            }else {            int avg= sum/5;            System.out.println("平均分为："+avg);                         }      }

　　

continue：

@Test    /*     * 循环录入Java课的学生成绩，统计分数大于等于80分的学生比例     */    public void demo9(){        int sum=0;  //用来累加学生人数的变量        System.out.print("班级总人数为：");        int penNo=tx.nextInt();        for (int i=1;i<=penNo;i++){            System.out.print("输入第"+i+"位学生的成绩：");            double score=tx.nextDouble();            if (score<80){                continue;            }            sum++;        }        double a=(double)sum/penNo*100;        System.out.println("80分以上的学生个数为："+sum);        System.out.println("80分以上学生占比为："+a+"%");    }　

对比break和continue：

使用场合：

break常用于switch结构和循环结构中

continue一般用于循环结构中

作用（循环结构中）：

break语句终止某个循环，程序跳转到循环块外的下一条语句

continue跳出本次循环，进入下一次循环

Ps:补充：return 结束当前方法的执行并退出，返回到调用该方法的语句处。

4.5 调试

为什么需要调试 : 在程序的开发过程中难免会有错误，但是我们不好发现和定位错误，所以我们需要调试

怎么调试，程序的执行一闪而过我们想让其慢点，就可以使用断电。步骤为：

1.分析错误，设置断点

2.启动调试: debug as

3.单步运行: F6

4.观察变量.

5.发现问题，解决问题

篇幅限制，剩下的内容再下一篇，已出，查看主页，去看吧！记得去看奥！