Java从新手到技术专家（day01）

原创已于 2025-08-18 14:18:16 修改 · 301 阅读

10 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2025-07-28 15:27:06 首次发布

Java从新手到专家专栏收录该内容

3 篇文章

订阅专栏

用365天从Java开发新手到技术专家

一、Java基础入门

1.编程语言的发展

语言：人与人沟通交流的桥梁

计算机语言：人与计算交流的桥梁

1.1 机器语言

机器语言是机器能直接识别的程序语言或指令代码，无需经过翻译，每一操作码在计算机内部都有相应的电路来完成它，或指不经翻译即可为机器直接理解和接受的程序语言或指令代码。机器语言使用绝对地址和绝对操作码。不同的计算机都有各自的机器语言，即指令系统。从使用的角度看，机器语言是最低级的语言。

机器是只能识别 0和 1的，01010101010101010

1.2 汇编语言

汇编语言（assembly language) 是一种用于电子计算机、微处理器、微控制器、或其他可编程器件的低级语言，亦称为符号语言。在汇编语言中，用助记符(Mnemonics) 代替机器指令的操作码，用地址符号(Symbol)或标号(Label)代替指令或操作数的地址

1.3高级语言

面向人类的高级语言

高级语言 (High-level programming language) 是一种独立于机器，面向过程或对象的语言。高级语言是参照数学语言而设计的近似于日常会话的语言

高级语言分为两类

一类是面向过程的语言例如C语言

一类是面向对象的语言例如Java语言，C#,C++,Python

2.Java特点分析

1.Java是跨平台的

2.Java是简单的

3.Java是安全的取消了指针，垃圾回收机制

4.Java是完全面向对象的

5.Java是健壮的有完整的生态体系

3.什么是JDK什么是JRE什么是JVM

JVM

Java Virtual Marchin java虚拟机

1.JVM 是一种规范，Oracle实现了这种规范

2.JVM是跨平台的基础

3.一次编译到处运行

JRE

java Runtime Environment Java运行时环境

1.JRE 中提供了java程序运行时需要用到的核心jar(类，接口等)

2.如果我们希望一个Java程序能够运行的话，那么我们必须要安装JRE

JDK

java Development Kit java开发工具包

1.提供了很多像java.exe,javac.exe,javap.exe等开发工具，帮助我们开发java程序

2.如果我们希望在自己的电脑上面开发Java程序，那么我们就必须安装JDK

JDK包含了JRE，JRE包含了JVM。所以我们开发的时候就只需要安装JDK即可

4.HelloWorld程序的实现

在除C盘(有可能因为系统的原因，不能在该目录下创建文件)任意目录下创建一个HelloWorld.java文件(在此之前需要安装JDK并配置环境变量)

打开该文件，在文件中写入如下内容：

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

代码写完也就意味着我们的开发完成了。接下来我们就可以借助JDK中提供的开发程序来执行我们的程序。

javac.exe. 将我们的Java文件编译成为class文件

javac HelloWorld.java

如果出现了"拒绝访问"的错误提示，那么一般是权限的原因。所以这个时候我们需要通过“系统管理员身份”来打开命令行窗口

编译成功后我们就可以借助另一个开发工具"java.exe"来执行我们的class文件

java HelloWorld

注意：java后面跟的不是class文件名称而是我们在代码中定义的类名

二、Java基础语法

1.关键字

java关键字：是Java语言保留供内部使用的，比如class用户与定义类。关键字也可以称为保留字，他们的意思是一样的。

2.标识符

标识符：等同于现实生活中取名字，Java中对包、类方法、参数、和变量等要素命名的时候使用的字符序列称为标识符。简而言之就是给类，接口，方法等起名字。

2.1 标识符的命名规则

规则：一定要遵守的，如果违反那么编译会报错

是由字母、数字、下划线_、美元符$组成
不能以数字开头
区分大小写
不能使用java中的关键字

2.2标识符的命名规范

规范：大家相互约定，都会遵守，如果不遵守编译不会报错

驼峰命名法(schoolName)
见名知意(使用有意义的英文单词)
命名的长度不要超过31字符

2.3开发中标准的规范

针对开发中对包、类、抽象类、接口、和实现类、变量、方法、常量的命名规范

2.3.1包

也就是文件夹

一般都是用公司域名的反写
所有的单词使用”."隔开
每个单词都是小写的

2.32类（抬头骆驼)

1.所有的单词首字母大写，其他字母小写

2.见名知意

2.3.3接口（抬头骆驼）

1.所有的单词的首字母大写，其他字母小写interface

2.一般会在第一个单词的前面添加一个大写的"I"

2.3.4接口的实现类（抬头骆驼）

1.所有的单词首字母大写，其他字母小写

2.一般我们会在最后一个单词后面追加”Impl" implements

2.3.5抽象类（抬头骆驼）

1.所有的单词首字母大写，其他字母小写

2.在单词的开头一般都会加上“Abs" Abstract

2.3.6变量（低头骆驼）

1.第一个单词首字母小写，其他单词首字母大写

2.一般都是名词

2.3.7方法（低头骆驼）

1.第一个单词首字母小写，其他单词首字母大写

2.一般是动词

2.3.8常量

1.所有的单词都是大写

2.每个单词间都有”_"分割

3.注释

注释的概念：

为程序进行解释说明的，编译期不会对注释进行编译操作

注释的好处：

是代码的可读性提高
开发中工作项目交接更加顺畅
程序调试更方便

单行注释： //

多行注释：/* 在此处写我们的注释内容 */ 多行注释是不能嵌套的

文档注释：/** */

注意：

文档注释可以是javadoc工具来生成API，后续会介绍
初学者一定要养成良好的习惯，先写注释，再写代码
开发中的注释不能随便删除

public class zhushi
{
    /**
    *  我们的第一个main方法
    **/
    public static void main(String[] args){
        // 声明一个变量 测试
        /*
            注释1
            注释2
            注释3
        */
        String userName = "张三";
    }
}

4.常量和变量

4.1.1什么是常量

在程序的执行过程中，值不会发生改变的量

4.1.2为什么要用常量

一周有7天

PI: 3.1415926

一年有12个月

4.1.3常量的分类

字面值常量

就是具体的值

1.)整数常量

大家要注意整数的进制。

2.)小数常量

1.float 单精度小数 0.5F

2.double 双精度 0.5D 默认

float,double后面会具体的来介绍这两个类型

3.)布尔型常量

用来表示“真”“假”，在程序中布尔型只有两个值true false

4.)字符常量

什么是字符：字符串中的最小单位，包括字母，数字，运算符，标点符号和其他符号

字符本质上还是数字

针对有特殊含义的字符我们需要通过转义符来实现“\"

\t制表 \n换行 \r\n换行 \R 换行 \' \""

5.)字符串常量

由双引号包裹
里面可以有一个字符也可以有多个字符还可以没有字符

public class ConstantDemo
{
    public static void main (String[] args)
    {
       //  整数 常量
       System.out.println(10);
       //  二进制常量 13
       System.out.println(0b01101);
       //  八进制 10
       System.out.println(012);
       //  十六进制 65535
       System.out.println(0xFFFF);
        
       System.out.println(5.5f);
       System.out.println(5.5D);

       System.out.println(true);
       System.out.println(false);
       // 字符 '' 单引号不能为空
       System.out.println('\'');
       // 字符串常量 必须写一对 双引号之内
       System.out.println(HelloWorld);
       System.out.println("");
       //  System.out.println(null);
    }
}

1.3.2 自定义常量

放到到后面的章节

4.2.变量

变量的定义：在程序的执行过程中，其值可以发生改变的量。类似于数学中的未知数X

变量的本质：就是一个地址

变量的三要素：

1.声明

2.赋值

3.使用

public class VariableDemo{
    public static void main(String[] args){
        //定义一个变量  租房子  我要租一个两室一厅的房子
        int a;// 声明了一个变量
        a = 20;  // 赋值操作  将一个常量赋值给了一个变量
        System.out.println(a);   //使用
        a = 50;
        System.out.println(a);   //使用
        int b = 100;  // 声明和赋值一块执行
        System.out.println(b);
        int c,d,e;  //声明多个变量可以通过连接
        c = 1;
        d = 2;
        e = 3;
        int c1 = 20,d1 = 30,e1 =40; //这种方式语法上支持，但是不推荐 推荐一行声明一个变量
    }
}

注意点：

变量一定要先声明再赋值再使用(Java要求变量先声明再赋值再使用，是为了确保类型安全、内存管理的正确性、避免未初始化错误、提高代码可读性以及满足编译器的要求。而C++由于其语言设计的灵活性和历史原因，允许在某些情况下不遵循这一规则)
变量的定义不能够重复
不能够连续定义变量 int x=y=z=123;
建议一行只写一条语句

5.基本数据类型和转换

5.1计算机单位

计算机能识别是只有二进制文件0和1

5.2数据类型

java是一门强类型的语言。针对于每一种数据都提供的对应的数据类型

5.2.1基础数据类型有八种

Java中的数据类型分为两类一类是基础数据类型一类是引用数据类型

基础数据类型可以分为：

数值型
- 整数类型
  - byte
  - short
  - int
  - long
- 浮点类型
  - 单精度-float
  - 双精度-double
字符型
- char
布尔型
- boolean

5.2.2引用数据类型

后面专门介绍

1.类(class)

2.接口(interface)

3.数组([])

6.运算符

6.1.1 +号

正数
加号
连接符号

System.out.println(+20);  //  表示 正数
System.out.println(3+4);  //  表示 两数相加
System.out.println("Hello" + 666);  //  拼接

6.1.2 - * / %

System.out.println(5-3); //2
System.out.println(-3);  //-3
System.out.println(5*3)  //15
System.out.println(5/3)  //1
System.out.println(5%3)  //2
System.out.println(2%4)  //2

System.out.println(5/(double)3);  // 1.666667
System.out.println((double)5/3);  // 1.666667

6.1.1 ++/--

++ -- 属于单目运算

++表示自增1

--表示自减1

单独使用

表示自增或者自减，没有任何的区别

public static void main(String[] args)
{
    int a = 10;
    int b = 20;
    //  a = 10 b = 20
    System.out.println("a = " + a + " b = " + b);
    //a ++;
    //b --;
    //  a = 11  b = 19
    //System.out.println("a = " + a + " b = " + b);
    

    ++ a ;
    -- b ;
    // a = 11 , b = 19
    System.out.println("a = " + a + " b = " + b);
}

参与运算

1.如果++ 放在操作数的左边，就表示先自增再参与运算

2.如果++ 放在操作数的右边，就表示先参与运算然后在自增1或者自减1

//  ++  --  参与运算
int a1 = 3;
int a2 = 4;
int result = (a1++)/3 + (--a2)*2 -(a1--)%6 + (a2++)*3 - (a2--);
System.out.println("a1=" + a1 + "a2=" + a2 + "result =" + result);

三个练习：

1.int x = 3;int res = (x++)%(++x)请推断res的值，及x此时的值

2.int n = 5; n=++n ++n 求n的值

3.int n = 3; n=++n + n++;求n的值

6.2赋值运算符

普通的 =

扩展的 += -= *= /= %=

public static void main(String[] args)
{
     //  赋值运算符  这个不是==赋值语句
     int a = 10 ;  //  表示将常量10赋值给变量a地址所对应的内存区域中
    
     a += 3;      //等价于a = a + 3
     System.out.println(a);
    
     a -= 3;     //等价于 a = a - 3
     System.out.println(a);
}

面试题1：short s1= 1 ;? s1 = s1 + 1; 有什么错？

short s1 = 1;s1 += 1;又有什么错？

short s1 = 1;
s1 = s1 + 1; // 报错 需要强制类型转换
s1 += 1; // 不会 += 会帮助我们自动完成强制类型转换

面试题2：如何交换两个数？

int x = 10;
int y = 20;    //  互换x和y的值

int c = x;
x = y;
y = c;

解决方案：声明一个中级变量即可

6.3 关系运算符

关系运算符得到的结果都是boolean类型的数据(true和false)

public static void main(String[] args)
{
    int a = 10;
    int b = 20;
    
    System.out.println(a > b);  // false
    System.out.println(a < b);  // true
    System.out.println(a >= b); // false
    System.out.println(a <= b); // true
    System.out.println(a != b); // true
    System.out.println(a == b); // false
}

6.4逻辑运算符

连接多个boolean类型的表达式

6.4.1 位逻辑运算符

&按位于

| 按位或

^异或

public static void main(String[] args)
{
    int a = 10;
    int b = 20;
    //  按位  & 都为true  结果true
    System.out.println((a > b) & (a < b)); // false & true = false
    System.out.println((a < b) & (a > b)); // true & false = false
    System.out.println((a < b) & (a < b)); // true & true = true
    System.out.println((a > b) & (a > b)); // false & false = false
    System.out.println("----------------------------------------------");
    //  按位  | 有true 就为true
    System.out.println((a > b) | (a < b));// false | true = true
    System.out.println((a < b) | (a > b));// true | false = true
    System.out.println((a < b) | (a < b));// true | true = true
    System.out.println((a > b) | (a > b));// false | false = false
    System.out.println("----------------------------------------------");
    // 按位  异或 相同为false 不同为true
    System.out.println((a > b) ^ (a < b));// false ^ true = true
    System.out.println((a < b) ^ (a > b));// true ^ false = true
    System.out.println((a < b) ^ (a < b));// true ^ true = false
    System.out.println((a > b) ^ (a > b));// false ^ false = false
        
}

6.5条件运算符

条件运算符又称为'三目运算'

格式： x ? Y : Z ;
x 表达式必须是boolean类型的表达式
计算流程：
       1. 首先计算X的值
       2. 如果X为true,那么整个表达式的结果就是Y的值
       3. 如果X为false,那么整个表达式的结果就是Z的值

三、分支语句

1.1if语句

为什么要用分支结构？

如果小明考试成绩大于90分，周末去海底世界游玩，这样的场景我们应该怎么来实现？

1.1.1单if语句

语法结构

if(关系表达式){
    //语句体
}

针对语法结构的说明：

表达式的类型必须是boolean类型，不能是其他类型
如果if语句下面只有一行代码，那么大括号可以省略，但是不推荐省略

执行的流程：

首先判断if语句的表达式的结果是true还是false
如果是true那么执行语句体
如果是false不执行语句体

案例：

package com.bobo.ifdemo;

import java.util.Scanner;

public class IfDemo01{


    /**
    * if语句
    *   需求：如果小明考试成绩大于90分，周末去海底世界游玩，
    *         这样的场景我们应该怎么来实现？
    * @param args
    */
    public static void main (String[] args) {
        // 获取一个Scanner 对象
        Scanner in = new Scanner(System.in);
        System.out.println("请输入小明的考试成绩：");
        int score = in.nextInt();
        if (score > 90) {
            System.out.println("周末去海底世界游玩....");
        }
        System.out.println("--------------------------");
    }
}

面试题：

int i = 99;
if ( i > 100 ); {
   System.out.println("HelloWorld");
}

这段程序有没有问题？如果有问题什么原因？如果没有问题那么输出的结果是什么？

public static void main(String[] args) {
    int i = 99;
    if ( i > 100)


    ; // 这是一行代码
   // 这是一个代码块
   {
        System.out.println("HelloWorld");
   }
}

不会报错，输出的结果是HelloWorld

课堂练习

张三Java成绩大于98分，而且音乐成绩大于80分，老师给他奖励，或者Java成绩大于等于100分，音乐成绩大于70分，老师也可以给奖励

package com.bobo.ifdemo
import java.util.Scanner;
public class ifdemo03{

    /**
    * 张三Java成绩大于98分，而且音乐成绩大于80分，老师给他奖励
    * 或者  Java成绩大于等于100分，音乐成绩大于70分，老师也可以给奖励
    * @param args
    */
    public static void main(String[] args) {
        
        // 获取 Scanner对象
        Scanner in = new Scanner(System.in);
        System.out.println("请输入张三的Java成绩：");
        int javaScore = in.nextInt();
        System.out.println("请输入张三的音乐成绩：");
        int music = in.nextInt();
        // 表达式可以很简单也可以很复杂，但是最终要求的结果的类型必须是boolean
        // 复杂的表达式 最好通过() 括起来增强可读性
        if( (javaScore > 98 && music > 80)
            || javaScore >= 100 && music > 70
            ) {
            System.out.println("奖励一个苹果");
        }
        System.out.println("****************");
    }
}

1.1.2 if-else语句

如果小明考试成绩大于90分，周末去海底世界游玩，否则在家打扫卫生。这样的场景我们应该怎么来实现？if-else语句的语法格式：

if(条件表达式){
    // 代码块1
}else{
    
    // 代码块2

}

执行顺序：

判断条件表达式的结果，true或者false
如果结果是true就执行代码块1
否则执行代码块2

案例：

package com.bobo.ifdemo

import java.util.Scanner;

public class IfDemo04 {

    /**
    * 如果小明考试成绩大于90分，周末去海底世界游玩，否则在家打扫卫生。
    * @param args
    */
    public static void main(String[] args) {
        //获取一个Scanner对象 shift+Tab
        Scanner in = new Scanner(System.in);
        System.out.println("请输入小明的考试成绩：");
        int score = in.nextInt();
        /*if  (score > 90) {
            System.out.println("周末去海底世界游玩..");
        }

        if (score <= 90){
            System.out.println("周末在家打扫卫生...);
        }*/
        if  (score > 90) {
            System.out.println("周末去海底世界游玩..");
        }else{
            System.out.println("周末在家打扫卫生...);
        }
        // 三目运算符适合比较简单的场景
        String prize = score > 90 ? "周末去海底世界游玩.." : "周末在家打扫卫生...";
        
        System.out.println("*********" + prize);
    }
}

课堂练习：

1.如果体彩中了500万，我买车、资助希望工程、去欧洲旅游

如果没中，我买下一期体彩，继续烧高香

2.输入四位数的会员号的百位数字等于产生随机数字即为幸运会员，提示恭喜您中奖了，否则没中奖

提示：生成随机数的方法 int random = (int)(Math.random()*10);

package com.bobo.ifdemo;

import java.util.Scanner;

public class IfDemo05 {

    /**
    * 输入四位数字的会员号的百位数字等于产生的随机数字即为幸运会员，
    * 提示恭喜您中奖了，否则没中奖
    * Math.random();   获取一个0~1.0 不包含1.0的小数
    * 5678
    * 8    5678%10
    * 7    5678/ 10%10       5678%100/10
    * 6    5678/ 100%10      5678%1000/100
    * @param args
    */
    public static void main(String[] args){
        // 生成一个个位数的随机值
        // System.out.println(Math.random());
        int random = (int)(Math.random()*10);
        System.out.println("random:" + random);
        Scanner in  = new Scanner(System.in);
        System.out.println("请输入一个四位数的整数：");
        int code = in.nextInt();
        if(code >= 1000 && code <= 9999){
            //  1000 < code < 9999 5678
            int i = code/100%10;  //5678/100%10
            if(i==random){
                System.out.println(random + "恭喜您成为幸运的会员")
            }
        }else{
            System.out.println("请输入合法的数字...")
        }

        /*System.out.println(5678%10);
        System.out.println(5678/10%10);
        System.out.println(5678%100/10);*/
    }
}

1.1.3多重if-else语句

有这样一个场景：

老师在批改试卷，成绩在90分以上的为优秀，成绩在80-90分之间为良好，成绩在60-80之间的为合格，60分以下的为差，这个应该要怎么来实现？

多重if-else语句语法:

if(条件1){
    // 代码1
}else if(条件2){
    // 代码2
}else if(条件3){
    // 代码3
}...{

}else{
    // 代码N
}

执行顺序：

判断条件1，结果为true或者false
如果为true, 直接执行代码1，然后结束
如果为false,那么看条件2是否为true
如果为true,直接执行代码2
否则判断条件3以此类推，如果所有的else - if语句都返回的是false,那么执行else中的代码

注意：

else if 可以有0到多个
else语句最多只能有一个

案例：

package com.bobo.ifdemo

import java.util.Scanner;

public class IfDemo06{
    
    /**
    * 老师在批改试卷，成绩在90分以上的为优秀
    * 成绩在80-90分之间为良好
    * 成绩在60-80分之间的为合格
    * 60分以下的为差
    * @param args
    */
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入考试成绩：");
        int score = in.nextInt();
        String info = "";
        if (score >= 90){
            info = "成绩优秀";
        }else if(score >= 80){
            info = "成绩良好，继续加油";
        }else if(score >= 60){
            info = "成绩刚好及格，努力加油";
        }else {
            info = "成绩很差，明天叫家长过来....";
        }
        System.out.println(info);

    }
}

本章练习：

键盘输入一个月份值，然后输出对应的季节

package com.zzz.ifdemo;

import java.util.Scanner;

public class IfDemo07{

    /**
    * 键盘输入一个月份值，然后输出对应的季节
    * @param args
    */
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入一个月份");
        int month = in.nextInt();
        if(monnth >= 1 && month <= 12){
            if( month <= 3){
                // 表示是春节
                System.out.println(month + "月份对应的是春季");
            }else if ( month <= 6){
                System.out.println(month + "月份对应的是夏季");
            }else if ( month <= 9){
                System.out.println(month + "月份对应的是秋季");
            }else{
                System.out.println(month + "月份对应的是冬季");
            }
        }else{
            System.out.println("请输入一个合法的月份...");
        }
    }
}

1.1.4嵌套if语句

语法结构：

if(条件1){
    if(条件2){
        //  代码1
    }else{
        //  代码2
    }
}else{
    //  代码3
}

执行流程：

首先判断条件1是否为true
为true再判断条件2是否为true
条件如果为true执行代码1，否则执行代码2
条件1为false,则执行代码3

1.2 switch语句

1.2.1switch语句介绍

switch语句是根据表示的不同值做出不同的执行的，针对特定的值来出来

语法格式：

switch(表达式){
    case 值1:
        代码1；
    case 值2:
        代码2；
    ....N
    default:
        默认语句;
        break;
}

注意：

表达式的值得类型必须是如下几种(int shor byte char String)String是jdk7之后支持的
case子句中的取值必须是常量，且所有case子句中的取值是不同的
case子句中的取值数据类型必须得是表达式返回的类型
default子句是可选的，同时default块顺序可以变动，但要注意执行顺序，通常default块放在末尾，也可以省略
break语句的作用是在执行完一个case分支后是程序跳出switch语句块

案例：

package com.zzz.switchdemo;

import java.util.Scanner;

public class SwitchDemo01{

    
    /**
    * 模拟：拨打中国电信客户的案例
    * 按1：办理宽带业务
    * 按2：办理手机业务
    * 按3：办理投诉业务
    * 按4：转人工服务
    * 没有上面的选项： 对不起您的输入有误
    * @param args
    */
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        System.out.println("请输入您服务编号：");
        int num = in.nextInt();
        switch (num) {
            case 1:
                System.out.println("办理宽带业务");
            break;
            case 2:
                System.out.println("办理手机业务");
            break;
            case 3:
                System.out.println("办理投诉业务");
            break;
            case 4:
                System.out.println("转人工服务");
            break;
            default:
                System.out.println("对不起您的输入有误");
                break;
        }
    }
}

1.2.2switch和if对比

if语句

表达式的结果是boolean类型
常用于区间的判断

switch语句

表达式的类型不能是boolean类型,可以是byte,short,int,char和String枚举类型
常用于等值判断

选择语句的选取

能switch语句实现的就一定能够有if语句实现，但是反之就不一定了
如果是区间范围的采用if语句，如果是等值判断的使用switch语句

四、循环语句

循环语句就是重复执行某块代码，能够大大提高我们的效率

/**
    * 输出一个 好好学习，天天向上 这个信息到控制台上
    * 输出两遍
    *     10遍呢
    *     100遍
    *     10000遍？
    *  @param args
    */
    public static void main(String[] args) {
        /*System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");
        System.out.println("好好学习，天天向上");*/
        for(int i = 0 ; i < 10000 ; i ++){
            System.out.println("好好学习，天天向上" + i);
        }
    }

1.for循环

1.1for循环的语法格式

for(表达式1 ; 表达式2 ; 表达式3)
{
    //  循环体语句    
}

语法格式说明：

for( 初始化语句 ; 循环条件语句 ; 控制条件语句 ){
    //  循环体语句
}

1.2for循环的注意事项

1.2.1 大括号可以省略

如果循环体大括号省略，循环体默认执行for语句后面的一条语句(;结尾)

public class ForDemo09 {

    public static void main(String[] args){
        // 作用域: i 的作用域 是在for 循环以内  表达式  1 2 3 4 中使用
        for(int i = 0 ; i < 4 ; i ++){
            //;
            System.out.println(i);// 这个是我们的循环体
        System.out.println("------------");
        }
    }
}

1.2.2表达式2的值是一个boolean类型

表达式2如果有多个条件我们需要用逻辑运算符连接

int a = 10;
int b = 20;
for(int i = 10 ; i < 10 && (a > 0 || b < 30) ; i ++){

}

1.2.3表达式2可以省略，但是";"不能省略

如果表达式2省略的话，那么程序会一直执行，直到资源耗尽，死循环

public static void main(String[] args){
    for ( int i = 0 ; ; i ++){
        System.out.println("-->" + i);
    }
}

1.2.4 表达式1 省略，表达式3 省略

表达式1和表达式3也省略

package com.zzz.fordemo

public class ForDemo11{

    /**
    * 表达式1 初始化变量的
    * @param args
    */
    public static void main(String[] args){
        int i = 0; // 表示i的作用域在方法中
        for (; i < 10 ;){
            System.out.println(i);
    

            //  将表达式4的信息  写到循环体的尾部
            i ++;
        }

        /*for ( int i = 0 ; i < 10; i++) {

        }*/
    }
}

1.4.5 表达式123都可以省略

表达式123都可以省略，但是两个";"是不能够省略的，出现死循环的情况

public class ForDemo12 {

   /**
   * 表达式1 初始化变量的
   * @param args
   */
   public static void main(String[] args) {
        for(;;){
            System.out.println("----");
        }
   }
}

2.while循环

while是java使用频率也比较高的一种循环方式。while语句的语法结构要比for循环简单些

2.1语法格式

while (条件表达式){
    //  循环语句
}

/** 
      * while循环
      * @param args
      */
public static void main(String[] args) {
    int i = 0;
    while( i < 10){
        System.out.println("i = " + i);
        i ++;
    }

    System.out.println("循环结束...");
}

3.do while循环

do while循环的特点：先执行一次循环体，然后在判断条件是否成立

3.1语法格式

public static void main(String[] args){
    int i = 0;
    do{
        //循环在循环条件判断之前执行一次
        System.out.println("----" + i);
    }while(i < 0);
    System.out.println("循环执行结束...");
}

4.while循环和for循环的对比

for循环和while循环都是先判断再执行， do-while是先执行再判断，并且一定会执行一次循环体
在循环结束之后，还希望能够使用循环变量，使用while循环，否则使用for循环，for循环的变量i只能作用于循环体
死循环的方式

while

while (true) {}

do-while:

do{

}while(true);

for:

for(;;){

}

循环方式的选择：

如果循环条件是一个区间范围(循环次数确定的),推荐使用for循环
如果循环次数不明确的情况下，推荐使用while循环
在第二个基础上如果要先执行再判断就使用do-while循环，否则使用while循环

5.break、continue、return关键字

1.break关键字

在循环过程中我们要跳出循环的时候那么可以通过break关键字来实现，改变程序控制流。

用户do-while、while、for循环中,可以跳出循环而执行循环以后的语句

2.continue

作用：continue关键字用于跳过某个循环语句的第一次执行，下一次循环还会继续

使用的场合：跳过循环体中剩余语句而执行下一次循环

3.break和continue的对比

使用场合

1.break可以用于switch语句和循环结构中

2.continue只能用于循环结构中

作用：

break语句终止某个循环，程序跳转到循环块外的下一条语句
continue跳出本次循环，进入下一次循环

4.return关键字

return关键字的作用是从当前方法中退出。返回调用该方法的语句处，并且从该语句处的下一条语句处开始执行。

五、方法讲解

1.方法概念的引入

1.1方法和没有使用方法的对比

package com.zzz.funcation

public class FunDemo01{

    /**
    * 为什么要使用方法
    * @param args
    */
    public static void main(String[] args) {
        //  在控制台输出 1 到 100的偶数
        for (int i = 1 ; i <= 100 ; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
        // 在控制台输出300到500的偶数
        for (int i = 300 ; i <= 500 ; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
        // 在控制台输出100到1000的偶数
        for (int i = 200 ; i <= 1000 ; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

使用方法的情况

package com.zzz.funcation

public class FunDemo02 {

    /**
    * 为什么要使用方法
    * @param args
    */
    public static void main(String[] args) {
        //  在控制台输出 1 到 100 的偶数
        printEven(1, 100);
        //  在控制台输出 300 到 500 的偶数
        printEven(300, 500);
        //  在控制台输出 200 到 1000 的偶数
        printEven(200, 1000);
    }

    /**
    * 我们定义的第一个方法
    *    作用: 输入 x 到 y之间的所有的偶数
    * @param x
    * @param y
    */
    public static void printEven(int x,int y){
        for (int i = x ; i <= y ; i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}

1.2 方法的概念

一段用来完成特定功能的代码片段

 /**
    * 我们定义的第一个方法
    *    作用: 输入 x 到 y之间的所有的偶数
    * @param x
    * @param y
    */
    public static void printEven(int x,int y){
        for (int i = x ; i <= y ; i++){
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }

1.3 为什么使用方法

程序中多次使用到的功能
便于程序的阅读
提供程序的重用性

在其他语言中，方法又称为函数

2.方法的定义

2.1方法的语法规则

访问修饰符 返回值类型  方法名称(参数类型 参数1  , 参数类型 参数2  ....){
    方法体;
    return 返回值;
}

访问修饰符：暂时使用 public static.后面我们会在面向对象的章节中详细介绍这部分的内容

返回值类型：该方法的返回结果的数据类型，可以是八大基本数据类型也可以是引用类型[后面介绍]

方法名称：自定义的，符合标识符的命名规则即可，见名知意

参数：表明该方法要完成特定功能所需要的支持

实际参数【实参】：水果榨汁机案例中，具体放进榨汁机中的水果，比如苹果，西瓜等。

方法调用时的参数，也就是实际参与运算的参数

形式参数【形参】：水果榨汁机案例中，这个机器在设计的时候定义外部要给与的类型

方法定义时的参数，用于接收实际的参数。

参数类型：参数的数据类型，可以是八大基本数据类型和引用类型

参数名：就是变量名，满足标识符的命名规则几个

方法体：就是完成特定功能的代码，具体根据需求来确定

返回值：方法特定功能的结果，通过return返回给调用者的，哪里调用的就返回到哪里去

2.2方法的具体实现

2.2.1 方法写在哪？

//  位置  5
public class FunDemo03 {


      //  位置  1

    
      public static void main(String[] args){
            // 位置  2


      }
      // 位置  3

}
// 位置  4

1.首先方法和方法是平级的关系，main方法也是一个方法，所以方法是不能写在main方法中的

2.方法只能定义在类以内。不能单独写到类以外

3.一个类中可以包含任意个方法，没有先后顺序

2.3方法的调用

方法在定义完成之后，如果没有被调用是永远不会执行的! main方法之所以不会被调用，是因为main方法是由Java虚拟机调用的,main方法是程序的唯一入口。

方法的调用三要素：

需要什么类型的参数就传什么类型的参数
返回什么类型的值就拿什么类型的变量来接收
实参的数目、数据类型、和次序必须和调用方法声明的形参列表匹配

方法的调用的三种方式

输出调用：输出调用适用于直接显示结果
赋值调用：适用于有返回结果的，并且返回值可以后续继续使用
直接调用：适用于没有返回值，只需要执行方法即可

方法没有返回结果，可以省略掉return关键字;

public static void show(){
    System.out.println("HelloWorld");
    return ;
}

3.方法的重载

在一个类中可以定义有相同的名称，但参数列表不同的多个方法，调用的时候会根据不同的参数列表类选择对应的方法。

参数列表不同：参数的个数，顺序，类型不同

重载的特点：

发生在同一个类中
方法名称相同
参数列表不同(类型、个数、顺序)
和返回类型没有关系

public class FunDemo08 {
    /**
    *  方法的重载
    *    1.方法名称相同
    *    2.方法参数列表不同
    *        参数个数
    *        参数类型
    *        参数顺序
    * @param args
    */
    public static void main(String[] args) {
        System.out.println(add(1,2));
        System.out.println(add(2,3,4));
        System.out.println(add(12.3,45.6));
        System.out.println(add(2.3,6));
    }

    /**
    * 两个int类型求和
    * @param a
    * @param b
    * @return
    */
    public static int add(int a,int b){
        return a + b;
    }
    public static double add(double d1 , double d2){
        return d1 + d2;
    }
    public static double add(double d1 , int d2){
        return d1 + d2;
    }
    public static double add(int d1 , double d2){
        return d1 + d2;
    }
    public static double add(int a ,int b,int c){
        return a + b + c;
    }
}

4.面试题：介绍下Java中的重写和重载的区别？

重载（Overloading）-------- 同名不同参

“一家奶茶店，招牌都叫'波霸奶茶'，但你可以选：”
大杯、中杯（参数个数不同）
冰的、热的（参数类型不同）
加糖、无糖（参数顺序不同）**
-------店员根据你点的具体要求做奶茶，但都算‘波霸奶茶’！

重写（Overriding) --------- 儿子盖过爹

“你爸做红烧肉（父类方法），你觉得太淡了。”
你继承了他的菜谱（子类extends父类），但自己重新写了个做法：
肉要炒糖色
多放两勺盐
菜名还是叫'红烧肉'，但味道按你的来！

核心：子类把父类的方法彻底重新实现(方法名、参数、返回值必须一模一样！)

总结√

重载➡横向拓展（同类不同做法）

举个例子：add(int a,int b) 和 add(double a,double b) 共存！

2.重写➡纵向覆盖（儿子覆盖爹的方法)

举个例子：父类run()会走路，子类run()改成飞，调用时用儿子的版本！

终极总结：

“重载是同行内卷(参数不同抢生意)！”

重写是儿子造反(覆盖老爹的方法)！5.递归

5.1什么是递归

方法中调用本地方法，自己调自己

5.2递归的注意事项

递归一定要有出口，否则很容易出现死递归，走不出来，类似死循环
递归的次数太多，容易出现内存溢出的情况
构造方法不能递归【后面的内容】

5.3递归的案例

5.3.1 n的阶乘计算

package com.zzz.funcation

public class FunDemo11 {

    /**
    * 求n的阶乘    5  ！  5*4*3*2*1
    * @param args
    */
    public static void main(String[] args) {
        //System.out.println(getFactorial(10));
        System.out.println(getFactorialRecursion(10));
    }

    /**
    *  通过递归的方式来实现N的阶乘计算
    *  分析  递归的出口
    *  5!=5*4!=5*4*3!
    *  @param num
    *  @return
    */
    public static int getFactorialRecursion(int num){
        if(num < 0){
            return 0;
        }
        //  先确定递归的出口
        if( num == 0 || num == 1){
            return 1;
        }else{
            return num * getFactorialRecursion(num - 1);
        }
    }



    /**
    * 普通的获取num 的阶乘
    * @param num
    * @return
    */
    public static int getFactorial(int num){
        if(num <=0 ){
            return 0;
        }
        int factorial = 1;
        for( int i = 1 ; i <= num;i++){
            factorial *= i;
        }
        return factorial;
    }
}

5.3.2斐波那契数列

斐波那契数列，又称黄金分割数列，因数据列昂多·斐波那契以兔子繁殖为例而引入，又称"兔子数列"

计算第N个位的值是多少

package com.zzz.funcation

public class FunDemo12 {


    public static void main(String[] args){
        //  TODO  Auto0generated method stub
        System.out.println(getFibonacci(9));
    }
    /**
    * 获取斐波那契数列
    * @return
    */
    public static int getFibonacci(int n){
        // 定位到 出口
        if(n == 1 || n == 2){
            return 1;
        }

        return getFibonacci(n-1) + getFibonacci(n-2);
    }
}

六、数组讲解

1.为什么要使用数组

byte short int long

double float

boolean

char

String

问题：Java考试结束后，需要统计全班学员的平均分(30个人)

解决方案:定义30个变量，然后相加求和，并计算平均分。

更好的解决方案：数组数据容器

2.内存分配

2.1硬盘

持久化我们的数据

2.2内存

运行时存储，在软件(程序)运行的时候开辟空间，软件运行结束后，内存中的数据就会消失

Java程序运行的时候，系统分配的内存Java程序是怎么利用的?

FunDemo01.java这个Java文件肯定是存储在硬盘上的。但是我们通过javac FunDemo01.java -->

FunDemo01.class -->

java FunDemo01执行这个过程中内存是怎么分配的?

2.3Java程序的内存分区

名称	描述
方法区	又称为代码区/永久区，存放类元数据、常量池、静态变量和JIT编译后代码
堆	存放的是new出来的东西
本地方法栈	专用于Native方法(如C/C++库调用)，功能类似虚拟机栈，但处理非Java代码的执行环境
Java虚拟机栈	存放局部变量的
程序计算器	每个线程独立拥有，记录当前执行字节码的指令位置，确保线程切换后恢复执行点；它是唯一不会发生内存溢出的区域

局

局部变量：方法体内定】

局部变量：方法体内定义的变量或者方法定义时声明的变量【形参】

public class ArrayDemo01 {

    
    //  定义一个全局变量
    int sum = 30;
    
    public static void main(String[] args) {
        //  定义一个局部变量
        int i = 10;

    
    }
}

2.4Java虚拟机栈的特点

先进后出(Firt in last out FILO),类似于子弹夹
栈区中的数据仅在作用域内有效，使用完毕之后立马自动释放
栈内的变量没有默认值，如果没有给出默认值就直接报错

2.5堆区的特点

1.堆区中的每个变量都有默认值

byte short int long 默认的都是 0

float double 默认的是0.0

char 默认的是 '\u0000'就是一个空字符串

boolean 默认值 false

引用类型默认值是 null

2.凡是new出来的东西都在堆区开辟空间，堆区开辟的空间都会有地址值

3.在堆区中的对象，一旦使用完毕之后，不会立刻消失，会等待垃圾回收器空闲的时候自动回收

3.数组的初始化

3.1数组的语法格式

数据类型[] 数组名 = new 数据类型[数组的长度];
数据类型 数组名[] = new 数据类型[数组的长度];

public static void main(String[] args) {
    // 定义一个数组
    int[] array1 = new int[5];
    int array2[] = new int[10];
}

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

作用：告诉计算机数据类型是什么

特点：

数据类型相同
数组名实际上就是一个变量，既然是变量，那就必须先赋值再使用
数组的每一个元素既可以是基本数据类型，也可以是引用数据类型

3.2数组的内存分配

上面的数组的语法格式其实有两步组成

1.数组的声明

int[] array1;

声明的变量会在内存中划分一块合适的空间，栈区

2.数组的赋值

array1 = new int[5];

将内存划分出来的一串连续的内存空间地址赋值给了变量

3.3数组的赋值

在前面介绍的array1 = new int[5];数组中的每个元素会根据数组的类型赋予默认值，那么我们可以通过数组中的各个位置上的元素，在java中数组的下标是从0开始的，最大的下标length-1

如果我们从数组中获取元素的下标超过数组的长度会报错，下标越界

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 3

下标不能是负数

java.lang.ArrayIndexOutOfBoundsException: -1

我想要修改数组中对应位置中的元素

public static void main(String[] args){
    int i = 10;
    // 定义一个数组
    int[] array1 = new int[3];
    array1[0] = 5;
    array1[1] = 6;
    array1[2] = 7;
    System.out.println(array1[0]);
    System.out.println(array1[1]);
    System.out.println(array1[2]);
}

简化的初始化方式

在初始化的时候就为每个元素赋值，不需要指明长度

public static void main(String[] args) {
    //int[] a1 = new int[7];
    //  声明变量后直接将一个数组赋值给了这个变量
    int a1[] = {1,2,3,4,5,6,7,8,9};
    System.out.println(a1[0]);
    System.out.println(a1[1]);
    System.out.println(a1[2]);
    System.out.println(a1[3]);
    System.out.println(a1[4]);
    System.out.println(a1[5]);
}

注意事项：

标识符：数组的名称，用于区分不同的数组
数组元素：向数组中存放的数据
元素下标,从0开始，数据中的每个元素都可以通过下标来访问
元素类型：数组元素的数据类型

4.数组的遍历

前面我们是通过下标一个个从数组中取出元素的，这种在数组中元素比较多的情况下，会比较麻烦这时我们可以考虑使用前面介绍的循环来实现。

public static void main(String[] args) {
    //int[] a1 = new int[]{1,2,3,4,5,6,7,8,9};
    int a1[] = {1,2,3,4,5,6,7,8,9};
    // 通过遍历的形式获取数组中的每个元素
    System.out.println(a1[0]);
    System.out.println(a1[1]);
    System.out.println(a1[2]);
    System.out.println(a1[3]);
    System.out.println(a1[4]);
    System.out.println(a1[5]);
    System.out.println(a1[6]);
    System.out.println(a1[7]);
    System.out.println(a1[8]);
    for(int i = 0 ; i < a1.length ; i ++){
        System.out.println(a1[i]);
    }
}

案例：将数组转换为如下的字符串

[33,55,77,999]

/**
       * 将数组转换为如下格式的字符串
       * [33,55,77,999]
       * 解决的思路：
       *    1.声明一个字符串 String arrayString = "[";
       *    2.变量获取数组中的每个元素 拼接在 arrayString 中
       *    3.在循环结束后 将 "]" 拼接到 arrayString的结尾
       * @param a
       * @return
       */
public static String arrayToString(int[] a){
    String arrayString = "[";
    for(int i = 0 ; i < a.length; i ++){
        if(i == a.length-1){
            //  获取数组中的最后一个元素
            arrayString += a[i];
        }else{
            arrayString += a[i]+",";
        }
    }
    arrayString += "]";
    return arrayString;
}

5.课堂案例

5.1 计算5个学员的平均分

public class ArrayDemo05 {

     /**
     *  计算5个学员的平均分
     *
     * @param args
     */
    public static void main(String[] args)  {
        double[] score = {67,89,87,68,54};
        // 记录学员总分
        double sum = 0;
        for(int i = 0 ; i < score.length; i ++){
            sum += score[i];
        }
        System.out.println("5个学员的平均分是：" + sum/5);
    }
}

6.排序

将一个无序的数组转换为一个有序的数组

6.1冒泡排序

冒泡排序：从第一个数据开始，依次比较相邻元素的大小。如果前者大于后者，则进行交换操作。把大的元素往后交换。通过多轮迭代，直到没有交换操作为止。冒泡排序就像是在一个水池中处理数据一样，每次都会把最大的那个数据传递到最后。

package com.zzz.array;

import java.util.Arrays;

public class ArrayDemo08 {

    /**
    * 冒泡排序
    *     1 4 3 5 2
    *       1 3 4 2 5
    * @param args
    */
    public static void main(String[] args){
        int[] a = {1,4,3,5,2};
        System.out.println("排序前：");
        System.out.println(Arrays.toString(a));
        //  第一趟排序
        /*for (int i = 0 ; i < a.length-1-0 ; i++) {
            if(a[i] > a[i+1]){
                int temp = 0;
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        System.out.println("第一趟排序后：");
        System.out.println(Arrays.toString(a));
        //  最后一位的数值肯定是最大的
        //  第二趟排序
        for (int i = 0 ; i < a.length-1-1 ; i++){
            if(a[i] > a[i+1]){
                int temp = 0;
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        System.out.println("第二趟排序后：");
        System.out.println(Arrays.toString(a));
        //  第三趟排序
        for (int i = 0 ; i < a.length-1-1 ; i++){
            if(a[i] > a[i+1]){
                int temp = 0;
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        System.out.println("第三趟排序后：");
        System.out.println(Arrays.toString(a));
         //  第四趟排序
        for (int i = 0 ; i < a.length-1-1 ; i++){
            if(a[i] > a[i+1]){
                int temp = 0;
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
        System.out.println("第四趟排序后：");
        System.out.println(Arrays.toString(a));*/
        bubbleSort(a);
        System.out.println("冒泡排序后：");
        System.out.println(Arrays.toString(a));
    }


    public static void bubbleSort(int[] a){
        for(int i = 0 ; i < a.length-1; i ++){
            for(int j = 0 ; j < a.length-1; j++ ){
                if(a[j] > a[j+1]){
                    int temp = 0;
                    temp = a[j];
                    a[j] = a[j+1]
                    a[j+1] = temp;
                }
            }
        }
    }
}

6.2选择排序

选择排序原理为：随机确认一个标志位（一般为第一个数字）作为最小数，然后向后遍历，找到比标志位更小的数便与标志位互换位置并更新最小数，实现步骤为：

将数组的第一个数字设置为标志位最小数并记录最小数下标。
向后遍历，发现更小数后将该数与标志位互换位置并更新最小数与最小数下标。
循环完成排序

package com.zzz.array;

import java.util.Arrays;

public class ArrayDemo05 {

    /**
    * 选择排序
    * @param args
    */
    public static void main(String[] args) {
        int a[] = {6,1,8,9,2,3,5,4,7};
        System.out.println("排序前：" + Arrays.toString(a));
        int minIndex = 0;
        int minValue = a[0];
        for(int i = minIndex + 1; i < a.length ; i ++){
            if(a[i] < minValue){
                minIndex = i;
                minValue = a[i];
            }
        }
        //  把原来要替换的数据更新到对应的最小的索引位
        a[minIndex] = a[0];
        //  把最小数放到最前面
        a[0] = minValue;
        System.out.println("第一次排序：" + Arrays.toString(a));
        // 第二次排序
         int minIndex = 1;
        int minValue = a[1];
        for(int i = minIndex + 1; i < a.length ; i ++){
            if(a[i] < minValue){
                minIndex = i;
                minValue = a[i];
            }
        }
        // 把原来要替换的数据更新到对应的最小的索引位
        a[minIndex] = a[1];
        // 把最小数放到最前面
        a[1] = minValue;
        System.out.println("第二次排序：" + Arrays.toString(a));
        // 第三次排序
         int minIndex = 2;
        int minValue = a[2];
        for(int i = minIndex + 1; i < a.length ; i ++){
            if(a[i] < minValue){
                minIndex = i;
                minValue = a[i];
            }
        }
        // 把原来要替换的数据更新到对应的最小的索引位
        a[minIndex] = a[2];
        // 把最小数放到最前面
        a[2] = minValue;
        System.out.println("第三次排序：" + Arrays.toString(a));
       }
}

package com.zzz.array;

import java.util.Arrays;

public class ArrayDemo06 {

    /**
    * 选择排序
    * @param args
    */
    public static void main(String[] args) {
        int a[] = {6,1,8,9,2,3,5,4,7};
        System.out.println("排序前：" + Arrays.toString(a));
        selectSort(a);
        System.out.println("排序后: " + Arrays.toStirng(a));
    }

    public static void selectSort(int[] a){
        for(int j = 0 ; j < a.length - 1; j++){
            int minIndex = j;
            int minValue = a[j];
            for(int i = minIndex + 1; i < a.length ; i ++){
                if(a[i] < minValue){
                    minIndex = i;
                    minValue = a[i];
                }
            }
            // 把原来要替换的数据更新到对应的最小索引位
            a[minIndex] = a[j];
            // 把最小数放到最前面
            a[j] = minValue;
        }
    }
}

7.查找

想要从数组中快速找到我们需要的元素，如果我要查找某个位置上的元素，那么我可以通过下标快速的找到，但是如果我们不知道数组中有哪些元素，而我们又需要找到这个元素，那么此时我们应该怎么办呢？

7.1顺序查找

从数组的第一个元素开始遍历，找了就结束遍历，否则直到遍历完成

package com.zzz.array;

public class ArrayDemo02 {

    public static void main(String[] args) {
        int[] d = {1,2,3,4,5,6,7,8,9,10};
        System.out.println(basicSelect(d, 11));

    }

    public static boolean basicSelect(int[] a,int num){
        for(int i = 0 ; i < a.length ; i++){
            if(a[i] == num){
                return true;
            }
        }

         return false;
    }
}

7.2折半查找(二分查找)

前提条件：只能针对排好序的数据进行查找

查找思路：每次都查找数据的中间元素，将需要找的数据和中间那个元素进行比较，这样查找可以减少至少一半的效率

8.增强版for循环

增强版for循环也称为foreach循环。相对于之前的普通for循环要简洁一些

语法格式：

for(元素类型 元素变量 ： 遍历对象 ){
        //  循环体 使用元素变量
}

package com.zzz.array;

public class ArrayDemo04 {

    
    /**
     * for(元素类型 元素变量 : 遍历对象){
            // 循环体 使用元素变量
        }
     * @param args
    */
    public static void main(String[] args){
        int[] a = {11,22,33,44,55,66};
        for(int i : a){
            System.out.println(i);
        }

        for(int i = 0 ; i < a.length ; i ++){
            System.out.println(a[i]);
        }
    }
}

foreach循环和for循环对比：

foreach循环更适合遍历数据
foreach循环没有下标，普通for循环适合做添加，删除操作
本质是foreach循环就是普通for循环

9.可变的参数列表

可变参数列表的语法规则

参数类型 ... 变量名称

package com.zzz.array

public class ArrayDemo05 {

    /**
    * 方法的形参中出现了 类型相同，个数不同的情况，这时我们可以使用 可变参数列表来实现
    * @param args
    */
    public static void main(String[] args){
        // TODO Auto-generated method stub
        System.out.println(add(1,2));
        System.out.println(add(1,2,3));
        System.out.println(add(1,2,3,4));
        add();
    }

/*  public static int add(int a,int b){
        return a + b;
    }

     public static int add(int a,int b,int c){
        return a + b + c;
    }*/

    public static int add(int ... a){
        System.out.println(a);
        int sum = 0;
        for( int i : a){
            sum += i;
        }
        return sum;
    }
}

可变参数的特点：

...的位置放在参数类型和变量名之间即可
可变参数列表必须出现在参数列表的最后面，而且一个方法的形参中最多只能有一个可变参数列表
可变参数列表本质上就是数组，既然是数组那么就可以按照数组的思路来处理

10.Arrays工具

在Java中提供了一个针对于数组操作的工具类，Arrays

package com.zzz.array;

import java.util.Arrays;

public Class ArrayDemo06 {

    /**
    *  Arrays工具类介绍
    *
    * @param args
    */
    public static void main(String[] args) {
        int[] a = {11,7,22,33,99,225,44,66,55,66,87,7};
        int[] b = {11,7,22,33,99,225,44,66,55,66,87,7};
        // 将数组转换为一个字符串
        System.out.println(Arrays.toString(a));
        // 排序
        // Arrays.sort(a);
        // 指定某个范围内的数据排序
        //Array.sort(a,3,8);
        System.out.println(Arrays.toString(a));
        // 二分查找
        int index = Arrays.binarySearch(a,661);

        System.out.println(index);
        //  判断两个数组是否相等
        System.out.println(Arrays.equals(a,b));
        //  给数组中的元素填充内容
        //  Arrays.fill(a, 1);
        //  局部填充
        Arrays.fill(a,2,5,1);
        System.out.println(Arrays.toString(a));
        //  复制数组
        int[] c = Arrays.copyOf(a, a.length-2);
        System.out.println(Arrays.toString(c));
        //  指定范围复制
        int d[] = Arrays.copyOfRange(a, 3, 7);
        System.out.println(Arrays.toString(d));

    

    }
}