初识java java入门知识 基础知识 打印各种星型图形 源代码

　　今天给大家带来的是初级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  即可.在控制台即可出现在打印语句中双引号中的内容了（所有需要打印的内容都需要在双引号中）

符号的含义：

：一个制表符的空格

：换到下一行的初识位置

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

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

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==6	false
!=	不等于	5!=6	true
>	大于	5>6	false
<	小于	5<6	true
>=	大于等于	5>=6	false
<=	小于等于	5<=6	true

注意：

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

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

4.4 逻辑运算符：

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

A	B	A&&B	A||B
T	T	T	T
T	F	F	T
F	T	F	T
F	F	F	F

&& 一假必假

|| 一真必真

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其他内容倒写，如 www.kgc.cn 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选择结构

@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：

 

常见错误2：

 

常见错误3：

　　

比较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类型

流程图：

执行特点：

先执行，后判断。

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

案例：

经过几天的学习，老师给张浩一道测试题，
让他先上机编写程序完成，
然后老师检查是否合格。如果不合格，则继续编写。…… 
@Test
public 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.发现问题，解决问题

五、数组(重难点)

为什么需要使用数组：

当有多个数值的时候.需要定义多个变量，较为麻烦，使用数组的话只需要定义一个变量直接开辟一串空间

什么是数组：

数组是一个变量，存储相同数据类型的一组数据

数组和变量的对比：

变量:声明一个变量就是在内存中开辟一个合适大小的空间

数组:声明一个数组就是在内存中开辟一连串的连续空间

数组基本要素：

标识符：

数组的名称，用于区分不同的数组

数组元素：

向数组中存放的数据

元素下标：

对数组元素进行编号，从0开始，数组中的每个元素都可以通过下标来访问

元素类型：

数组元素的数据类型

注意：

声明一个变量就是在内存空间划出一块合适的空间

声明一个数组就是在内存空间划出一串连续的空间

数组长度和类型一旦定义不会改变

数组中的所有元素必须属于相同的数据类型

如何使用数组：

1、声明数组

数组类型 数组名 [];

数组类型[] 数组名;  //常用写法

int[] a;

int a[];

String[] name;

2、分配空间(告诉计算机分配几个连续的空间)

数组类型[] 数组名 = new 数据类型[大小];

a=new int[5];

3、赋值（向分配的格子里放数据）

数组名[元素下标] =要赋的值;

a[0]=8;

赋值：

一、边声明边赋值：赋值的时候给了几个值，数组的长度就是多少

数组类型[] 数组名 = {x ; y ; z};

int[ ] score = {89, 79, 76};

数组类型[] 数组名 = {x ; y ; z};

int[ ] score = new int[ ]{89, 79, 76};

二、动态的从键盘录入信息并赋值（需要先定义数组长度）

Scanner input = new Scanner(System.in);
for(int i = 0; i < 30; i ++){
     score[i] = input.nextInt();
}

4、处理数据

a[0]=a[0]*10;

案例：

//计算5位学生的平均分：
 int [ ] score = {60, 80, 90, 70, 85};
 double avg;
 avg = (score[0] + score[1] + score[2] + score[3] + score[4])/5;  
 
但是如果像上面写法的话还是会有弊端的，如：学生的个数有变动，那我们的循环次数和求平均分的时候除以的数都需要修改，我们有一个方法避免修改多处
动态的获取数组的长度。  score.length

5、常见错误　

编译出错：没写明数组的大小：int [] score= new int[];

编译出错：数组下标越界：int [] score= new int[2];

　　　　score[0]=11;
　　　　score[1]=11;
　　　　　score[2]=11; //下标越界了

编译出错：数组的声明和赋值在多行：

　　　　int [] score;
　　　　score={11,22,33,21};

6.、Arrays类

返回值类型	方法名称	说明
boolean	equals(array1,array2)	比较array1和array2两个数组是否相等
	sort(array)	对数组array的元素进行升序排列
String	toString(array)	将一个数组array转换成一个字符串
	fill(array,val)	把数组array所有元素都赋值为val
原数组什么类型复制的新数组也是什么类型	copyOf(array,length)	把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
int	binarySearch(array, val)	查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）

案例：

@Test
    public void test05(){
        int[] array1 ={12,21,13};
        int[] array2 ={12,21,13};
        int[] array3 ={12,21,13,24};
        //int binarySearch(array, val)      查询元素值val在数组array中的下标（要求数组中元素已经按升序排列）
        Arrays.sort(array3);
        int i =Arrays.binarySearch(array3,13);
        System.out.println(i);
        //copyOf(array,length)      把数组array复制成一个长度为length的新数组，返回类型与复制的数组一致
        /*int array4[] =Arrays.copyOf(array3,6);
        System.out.println(Arrays.toString(array4));*/
    
        
        /*//void fill(array,val)    把数组array所有元素都赋值为val
        Arrays.fill (array3,22);
        System.out.println(Arrays.toString(array3));
        
        
        //sort(array)        对数组array的元素进行升序排列
        //String toString(array)    将一个数组array转换成一个字符串
        Arrays.sort(array3);
        System.out.println(Arrays.toString(array3));
        
        
     // boolean equals(array1,array2);        比较 array1 和 array2 是否相等
        boolean a=Arrays.equals(array1,array2);
        boolean b=Arrays.equals(array1,array3);
        System.out.println(a+","+b);*/
    }

　　

 7、多维数组

为什么学习多维数组:如遇5个班各5名学生的信息

概念:从内存角度看只有一-维数组，java是支持多维数据的但是二维以上的数组很少使用，只要用二维数组

二维数组:其实是数组的数组

语法：

<数据类型> [ ][ ]  数Ä名;  或者 <数据类型>  数Ä名 [ ][ ];
int [ ][ ] scores; //定义二维数组
scores=new int[5][50]; //分配内存空间
 
 或者
int [ ][ ] scores = new int[5][50];
 
常见问题
定义二维数组时，要定义最大维数：
int [ ][ ] scores = new int[5][]; 后面的中括号是可以省略的
int [ ][ ] scores = new int[][]; 不能省略前面的或者都省略
二维数组实际上是一个一维数组，它的每个元素又是一个一维数组
 
赋值
int[][] scores=new int[3][5];  
score[0][0]=90; 
score[2][3]=70;
 
方法一：
      int[][] scores=new int[][]{ { 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 }};
 
方法二：
      int scores[][] = {{ 90, 85, 92, 78, 54 }, { 76, 63,80 }, { 87 } }; 

　　

六、equals

最后再补充一点关于equals 和 == 的区别哈！！！

== 和 equals 的区别是？

==

既可以比较数值类型，也可以比较引用数据类型。当比较的是数值类型的时候比较的是值比较的是引用数据类型的是后，比较的就是地址值

equals

如果没有对equals方法进行重写的时候，比较的方式和==是一样的，如果重写的则按照重写的方式进行比较

在使用equals 的时候我们将肯定有值的变量写在前面，避免空指针异常的出现

案例：

@Test
    public void test2(){
        String i =null;//String 的默认值  为空
        if (i.equals("")){
            System.out.println("合格");
        }
        System.out.println("程序结束");
    }//此时运行会报错
@Test
    public void test2(){
        String i =null;
        if ("".equals(i)){
            System.out.println("合格");
        }
        System.out.println("程序结束");
    }//换位后运行正常

　　

七、循环结构进阶

1、为什么使用二重循环:

重复做的事使用循环那如计算3个班级各5名学生的成绩平均分就需要两个循环

2、什么是二重循环:

简单来说，就是循环里面套一个循环

3、方式：

语法：
while的双重循环
while(循环条件1) { 
 //循环操作1
     while(循环条件2) {
    //循环操作2
 }
}
 
do {
 //循环操作1
    do {
   //循环操作2
 }while(循环条件1);
}while(循环条件2);
 
for(循环条件1) {
 //循环操作1
     for(循环条件2) {
      //循环操作2
 }
}
 
while(循环条件1) {
  //循环操作1
      for(循环条件2) {
         //循环操作2
    }
}
  
特点：外层循环一次，内层循环一遍 

4、如何使用二重循环：

案例1：

//计算三个班级的四个学生的成绩平均分
  Scanner sc = new Scanner(System.in);
   double score=0;
   double sum=0;
   for(int i=0;i<3;i++){ //循环的是班级
   　　System.out.println("请输入第 "+(i+1)+"个班级的学生成绩：");
   　　sum=0;
    　 for(int j=0;j<4;j++){   //循环的是班级的每个学生
    　　　　System.out.println("请输入第 "+(j+1)+"个学生的成绩：");
    　　　　score=sc.nextDouble();
    　　　　sum+=score;
  　　 }
  　　 System.out.println("第 "+(i+1)+"个班级学生的总成绩是："+sum);
  　　 System.out.println("第 "+(i+1)+"个班级学生的平均分是："+sum/4);
 　}

:案例2（进阶）：

1.打印各种图形（矩形、直角三角形、倒直角三角形、等腰三角形、平行四边形、菱形、数字菱形、空心菱形）
 打印四边形的星星

提示：外层循环控制行数，内层循环控制列数
//打印矩形的星星
   for(int i=1;i<=5;i++){
    for(int j=1;j<=5;j++){
　　 System.out.print("*");
    }
　　 System.out.println();  
   }

打印直角三角形的图案

//打印直角三角形
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入三角形的行数：");
   int num=sc.nextInt();
   for(int i=1;i<=num;i++){
    　for(int j=1;j<=(2*i-1);j++){
　　   System.out.print("*");
　　  }
     System.out.println();
   }

打印倒直角三角形

//打印直角三角形
 Scanner sc = new Scanner(System.in);
 System.out.println("请输入三角形的行数：");
     int num=sc.nextInt();
     for(int i=1;i<=num;i++){
       for(int j=1;j<=(num+1-i);j++){
 System.out.print("*");
 }
 System.out.println();
 }

打印等腰三角形（如下图效果）

//打印等腰三角形
 Scanner sc = new Scanner(System.in);
 System.out.print("请输入您要打印的行数：");
   int num=sc.nextInt();
   for(int i=1;i<=num;i++){
    for(int j=1;j<=num-i;j++){
 System.out.print(" ");
 }
    for(int k=1;k<=(2*i-1);k++){
 System.out.print("*");
 }
 System.out.println();
 }

打印平行四边形（如下图效果）

//输出平行四边形
        for(int i = 0;i<5;i++){
            //循环输出空格
            for(int j=0;j<5-i-1;j++){
                System.out.print(" ");
            }
            //循环输出*
            for(int k = 0;k<=5;k++){
                System.out.print("*");
            }
            System.out.println();
        }

打印菱形

//输出菱形
        //先输出等腰三角形
        for(int i = 1;i<=5;i++){
            //循环输出空格
            for(int j=5-i;j>0;j--){
                System.out.print(" ");
            }
            //循环输出*
            for(int k = 0;k<2*i-1;k++){
                System.out.print("*");
            }
            System.out.println();
        }
        //再输出一个4行的倒三角形
        for(int i = 1;i<=4;i++){
            //循环输出空格
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            //循环输出*
            for(int k = 0;k<2*(5-i)-1;k++){   // 2*(5-i)-1   9-2i
                System.out.print("*");
            }
            System.out.println();
        }

打印数字菱形

//输出数字菱形
                //先输出等腰三角形
                for(int i = 1;i<=5;i++){
                    //循环输出空格
                    for(int j=5-i;j>0;j--){
                        System.out.print(" ");
                    }
                    //循环输出*
                    for(int k = 0;k<2*i-1;k++){
                        System.out.print((5-i));
                    }
                    System.out.println();
                }
                //再输出一个4行的倒三角形
                for(int i = 1;i<=4;i++){
                    //循环输出空格
                    for(int j=1;j<=i;j++){
                        System.out.print(" ");
                    }
                    //循环输出*
                    for(int k = 0;k<2*(5-i)-1;k++){   // 2*(5-i)-1   9-2i
                        System.out.print(i);
                    }
                    System.out.println();
                }

打印空心菱形

//输出空心菱形
                //先输出等腰三角形
                for(int i = 1;i<=5;i++){
                    //循环输出空格
                    for(int j=1;j<= 5-i;j++){
                        System.out.print(" ");
                    }
                    //循环输出*
                    for(int k = 1;k<=2*i-1;k++){
                        if(k==1 || k==2*i-1){
                            System.out.print("*");
                        }else{
                            System.out.print(" ");
                        }
                    }
                    System.out.println();
                }
                //再输出一个4行的倒三角形
                for(int i = 1;i<=4;i++){
                    //循环输出空格
              for(int j=1;j<=i;j++){
                        System.out.print(" ");
                    }
                    //循环输出*
                        for(int k = 1;k<=2*(5-i)-1;k++){   // 2*(5-i)-1   9-2i
                        if(k== 1 || k==2*(5-i)-1){
                            System.out.print("*");
                        }else{
                            System.out.print(" ");
                        }
                    }
                    System.out.println();
                }

2.//若有3个班级各4名学员参赛，计算每个班级参赛学员平均分，统计成绩大于80分学员数 
  Scanner sc = new Scanner(System.in);
   double avg=0;
   double sum=0;
   double score=0;
   int num=0;
   for(int i=1;i<=3;i++){
   System.out.println("请输入第 "+i+"个班级的成绩：");
   sum=0;
    for(int j=1;j<=4;j++){
    System.out.print("请输入第 "+j+"个同学的成绩：");
    score=sc.nextDouble();
    sum+=score;
     if(score<80){
       continue;
    }
    num++;
   }
   System.out.println("第 "+i+"个班的平均分是："+sum/4);
  }
  System.out.println("80分以上的学院个数为："+num);
===========================================================
3.循环和break相结合的联系
Scanner sc = new Scanner(System.in);
   String answer="";
   int num=0;
   for(int i=1;i<=5;i++){
    System.out.println("欢迎光临第 "+i+"家店");
    
    for(int j=1;j<=3;j++){
     System.out.print("要离开么（y/n）: ");
     answer=sc.next();
        if(answer.equals("y")){
         System.out.println("离店结账");
         break;
        }
        num++;
    }
   }
   System.out.println("一共买了 "+num+"件衣服");

===========================================================

　4. 在数组中添加、修改、删除数据　

//在数组中添加数据
        //首先初始化数组
        String[] arr = {"iphone4","iphone4s","iphone5",null};
        //初始化需要插入的位置下标
        int index = -1;
        System.out.print("初始数组为：");
        for(int i = 0;i<arr.length;i++){
            //如果为空，则可以插入
            if(arr[i] == null){
                //把需要插入的下标赋值给index
                index = i;
                break; //跳出for循环
            }
            System.out.print(arr[i]+" ");
        }
        //判断index是否变化
        //index不等于-1，说明找到可以插入的位置
        if(index != -1){
            //把插入的输入赋值给数组的null值，且下标就是index
            System.out.print("
请输入您要插入的数据：");
            String num = sc.next();
            arr[index] = num;
        }else{
            System.out.println("数组已满，不能插入！");
        }
        //循环遍历数组
        System.out.print("插入后的数组为：");
        for(String arr1:arr){
            System.out.print(arr1+" ");
        }
    }　

 //在数组中修改信息
        String[] arr = {"ipone4","ipone4s","ipone5","ipone6"};
        //初始化需要修改的数组下标
        int index = -1;
        System.out.print("初始数组为：");
        //循环遍历数组
        for(String i:arr){
            System.out.print(i+" ");
        }
        //判断是否可以找到需要修改的数据
        for(int i =0;i<arr.length;i++){
            if(arr[i].equals("ipone6")){
                index = i;
                System.out.println("
您要修改的数据的数组下标为："+index);
                break;
            }
        }
        //判断index是否发生变化
        if(index != -1){
            arr[index] = "iphone5s";
        }else{
            System.out.println("输入的数据不存在");
        }
        //循环遍历输出
        System.out.print("修改后的数组为：");
        for(String i:arr){
            System.out.print(i+" ");
        }
    }

//删除数组中一个数据
    public void test04(){
        //初始化数组
        String[] arr = {"ipone4","ipone4s","ipone5","ipone7","ipone5s"};
        //循环遍历数组
        System.out.print("初始数组为：");
        for(String i:arr){
            System.out.print(i+" ");
        }
        //初始化需要删除的数据下标
        int index = -1;
        System.out.print("
请输入您要删除的数据：");
        String deleteData = sc.next();
        for(int i = 0;i<arr.length;i++){
            //如果在数组中找到了要删除的数据
            if(arr[i].equals(deleteData)){
                index = i;
                break;
            }
        }
        //判断index的值是否改变
        if(index != -1){
            //说明数组中存在输入的数据，可以删除
            //把删除后的数据整体向前移一位
            for(int i = index;i<arr.length-1;i++){
                arr[i] = arr[i+1];
            }
            //把最后一位置空
            arr[arr.length-1] = null;
        }else{
            System.out.println("找不到数据，不能删除！");
            return;
        }
        //循环遍历输出数组
        System.out.print("删除后的数组为：");
        for(String i:arr){
            System.out.print(i+" ");
        }
    }

===========================================================

5.冒泡排序、选择排序、插入排序的代码和对比

一共是比较了数组长度的-1轮，每一轮比较的次数都是比上一次少一次 
//打印冒泡
   int [] arr={21,77,23,32,1,99};
 　System.out.println("排序之前：");
   for(int i=0;i<arr.length;i++){
 　　System.out.print(arr[i]+" ");
   }
   System.out.println();
   
   for(int i=0;i<arr.length-1;i++){
     for(int j=0;j<arr.length-i-1;j++){
       if(arr[j]>arr[j+1]){
         int temp=arr[j];
         arr[j]=arr[j+1];
         arr[j+1]=temp;
      }
    }
  }   
 System.out.println("排序之后：");
   for(int i=0;i<arr.length;i++){
 System.out.print(arr[i]+" ");
 }

//插入排序
        int[] arr = {3,42,54,2,56,7,76}; 
        for(int i =1;i<arr.length;i++){  //从i=1开始比，和arr[0]比。比较的轮数就是arr.length-1，即i从到小于arr.length
            int temp = arr[i];  //把第一个要比较的数54赋值给temp
            int j = 0;
            for(j = i-1;j>=0;j--){  //j就是被比较的数：42，j>=0是从i向前比较，直到数组的下标为0.
                //判断temp是否大于被比较的数42
                if(arr[j] > temp){
                    //如果temp小于被比较的数42，就要交换位置，即把arr[j]的值赋值给后面一位arr[j+1].此时不用担心后面的数被覆盖后找不到，
                     //因为已经赋值给了temp
                    arr[j+1] = arr[j];  //赋值之后返回单for循环，j--，此时j相当于i-2
                }else{
                    //如果temp大于别比较的数42，不需要交换位置 .此时break后,j不用--，即j的值没变
                    break;
                }
            }
            
            //接着判断是否发生了交换。如果没有交换，此时arr[j+1] == temp ; 如果交换了,j也减了1,此时arr[j+1] != temp
            if(arr[j+1] != temp){
                //说明发生了交换。则把temp赋值给arr[j+1]
                arr[j+1] = temp;
            }
        }
        //遍历输出数组，检测
        for(int i:arr){
            System.out.print(i+" ");
        }

//选择排序
        //int[] arr = {1,3,42,54,2,56,7,76,4};
        int index = 0;
        for(int i = 0;i<arr.length-1;i++){
            index = i;  //如果第一个数是最小的，第一轮之后，把最小值下标i+1后赋值给index
            for(int j = i+1;j<arr.length;j++){
                if(arr[index]>arr[j]){
                    index = j;
                }
            } 
            if(index != i){
                arr[index] = arr[index]+arr[i];
                arr[i] = arr[index] - arr[i];
                arr[index] = arr[index] - arr[i];
            }
        }
        for(int i:arr){
            System.out.print(i+" ");
        }

　

　　至此，Java基础语法部分大致完成，下面该是Java的重难点：面向对象！！！下次博主会给大家带来更为详细的关于面向对象的博客，期待小伙伴们的收藏、支持和评论，加油！！！