【持续更新】Java入门教程

浏览数: 47

好了现在我们就要开始学习第三门的语言了，同时也是比较难的一门语言——Java。但是前面有我们的C语言和Python语言的一个基础学习的话，到Java这块的话自然而然的也不会太难。一样的本文章也是我的一个学习笔记，教程的来源是黑马程序员

一、Java的基础

1、基本输出

学编程还是得来一个Hello World的输出才算编程语言学习的开始：

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

然后的话特别强调一下，我们创建的这个文件名字为：HelloWorld.java 问题来了为什么我们要强调这个东西，是因为文件的名字和代码中的类名称是存在关系的。如果你的类名称和文件名称不一样，代码将无法运行。（建议类名称首字母为小写，若由多个字母组合的，首字母均为大写）

诶那话说又回来了，什么是类啊？就是我们第一行代码：public class 这个作为一个公共类型的类为下面的代码内容起到了关键作用，那其他第二行这么多单词，到底是干什么用的？

而第二行的代码作用主要是整个程序的主办法入口。

然后Java同时也是对大小写比较敏感的，剩下的基础语法应该不需要给大家解释了，都基本差不多了。

2、代码注释

代码注释的话其实不用多讲，在IDEA中我们都直接用 Ctrl+/ 的组合直接快捷注释了。不过还是稍微看一下。

public class HelloWorld {
   /* 这是第一个Java程序
    * 它将输出 Hello World
    * 这是一个多行注释的示例
    */
    public static void main(String[] args){
       // 这是单行注释的示例
       /* 这个也是单行注释的示例 */
       System.out.println("Hello World"); 
    }
}

上面是菜鸟教程给的例子。

3、自变量分类

①自变量

自变量分类的话，之前学过编程的都接触过什么整型啊，浮点型之类的东西。然后这边给大家送上黑马程序员整理的关于Java的自变量分类。

那如何直接输出这些内容呢？请看示例代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World"); // 字符串
        System.out.println(114514); // 整数
        System.out.println(1.14514); // 小数
        System.out.println(-11); // 负数
        System.out.println(true); // 布尔类型
        System.out.println(null); // 空 输出不了null 可以转换成字符串输出
    }
}

②特殊字符

Ⅰ制表符

制表符的表达方式是什么？是”\t” 他究竟有什么作用？

在打印的时候，把前面字符串的长度补齐到8，或者8的整数倍。最少补1个空格，最多补8个空格

那如何使用呢？看示例代码：

public class Main {
    public static void main(String[] args) {
        System.out.println("name" + '\t' + "ZherKing");
        System.out.println("school" + '\t' + "XXX University");
    }
}

其输出的结果是：

然后给大家上总结：

然后通过 菜鸟教程给大家补充：

符号	字符含义
\n	换行 (0x0a)
\r	回车 (0x0d)
\f	换页符(0x0c)
\b	退格 (0x08)
\0	空字符 (0x0)
\s	空格 (0x20)
\t	制表符
\”	双引号
\’	单引号
\\	反斜杠
\ddd	八进制字符 (ddd)
\uxxxx	16进制Unicode字符 (xxxx)

4、变量

①如何实现

变量的话按照之前的编程语言的学习相比大家都了解了，不过不理解的话我还是随便拿了个图给你们（

接下来看示例代码：

public class Main {
    public static void main(String[] args) {
        int a = 5;
        System.out.println(a);
    }
}

a是一个变量名，作为整形存在，然后的话输出是可以直接调用a直接进行输出的，最终的输出结果是 5

②使用方式

Ⅰ基本计算

看示例代码：

public class Main {
    public static void main(String[] args) {
        int a = 5;
        int b = 5;
        System.out.println(a+b);
    }
}

还有更多的运算符这边作个补充（菜鸟教程）

操作符	描述	例子
+	加法 – 相加运算符两侧的值	A + B 等于 30
–	减法 – 左操作数减去右操作数	A – B 等于 -10
*	乘法 – 相乘操作符两侧的值	A * B等于200
/	除法 – 左操作数除以右操作数	B / A等于2
％	取余 – 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21（区别详见下文）
—	自减: 操作数的值减少1	B– 或 –B 等于 19（区别详见下文）

将运算符代入到实际代码中测试：

public class Test {
 
  public static void main(String[] args) {
     int a = 10;
     int b = 20;
     int c = 25;
     int d = 25;
     System.out.println("a + b = " + (a + b) );
     System.out.println("a - b = " + (a - b) );
     System.out.println("a * b = " + (a * b) );
     System.out.println("b / a = " + (b / a) );
     System.out.println("b % a = " + (b % a) );
     System.out.println("c % a = " + (c % a) );
     System.out.println("a++   = " +  (a++) );
     System.out.println("a--   = " +  (a--) );
     // 查看  d++ 与 ++d 的不同
     System.out.println("d++   = " +  (d++) );
     System.out.println("++d   = " +  (++d) );
  }
}

输出结果：

a + b = 30
a - b = -10
a * b = 200
b / a = 2
b % a = 0
c % a = 5
a++   = 10
a--   = 11
d++   = 25
++d   = 27

Ⅱ修改数据

查看示例代码：

public class Main {
    public static void main(String[] args) {
        int b = 5;
        System.out.println(b);
        b = 10;
        System.out.println(b);
    }
}

示例代码中 b 的数值从5改成了10。然后总结！

然后再来一些注意事项：

5、基本数据类型

①介绍

那如何进行使用这些数据类型呢？

public class Main {
    public static void main(String[] args) {
        byte a = 1;
        System.out.println(a);
        short b = 1;
        System.out.println(b);
        int c = 1;
        System.out.println(c);
        long d = 1;
        System.out.println(d);
        float e = 1;
        System.out.println(e);
        double f = 1;
        System.out.println(f);
        boolean g = true;
        System.out.println(g);
        char h = 'A';
        System.out.println(h);
    }
}

输出的结果：

1
1
1
1
1.0
1.0
true
A

上总结：

②练习题

示例代码：

public class Main {
    public static void main(String[] args) {
        String name = "真境";
        int age = 18;
        char gender = 'M';
        double height = 180.1;
        boolean flag = true;
        System.out.println(name);
        System.out.println(age);
        System.out.println(gender);
        System.out.println(height);
        System.out.println(flag);
    }
}

6、标识符

什么叫做标识符？标识符就是给类，方法，变量等取名字。

这些就是标识符的规范要求。

7、键盘录入（Scanner类的使用）

①基本的键盘录入

键盘录入的话根据我们之前学的编程的话，大家都知道比如说C语言的 scanf 和 Python 的 input 的语法。其作用就是代码程序通过用户输入的内容对某个变量进行复制。

然后的话给大家来一个示例代码：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int i = sc.nextInt();
        System.out.println(i);
    }
}

同时的话创建对象的同时是可以进行输入多个变量的：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数");
        int i = sc.nextInt();
        int j = sc.nextInt();
        System.out.println(i+j);
    }
}

②NextLine和Next的区别

首先的话这两个都是属于 Scanner 类里面的内容的。

Ⅰnext():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next() 方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
next() 不能得到带有空格的字符串。

ⅡnextLine()：

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

主要的区别都在上面，其实最根本的用途就是通过哪一种方式来获取用户的输入。那具体的使用方法就是：

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
    // next 和 nextLine 的基本用法
        Scanner sc1 = new Scanner(System.in);
        String a = sc1.next();
        String b = sc1.nextLine();
        System.out.println(a+b);
    }
}

不过的话使用 next 和 nextLine 这两个语法的话可能需要使用字符串才可以（IDE给的建议）

③hasNext语句

hasNext语法的话我个人认为可以说判断是否有输入东西，或者是说输入的东西是否是恰当的数据类型，比如说看以下语句：

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
        Scanner sc2 = new Scanner(System.in);
        if (sc2.hasNext()){
            String c = sc2.next();
            System.out.println(c);
        }else{
            System.out.println("你好像什么都没输入啊？");
        }
        sc2.close();
        Scanner sc3 = new Scanner(System.in);
        if (sc3.hasNextLine()){
            String c = sc3.nextLine();
            System.out.println(c);
        }else{
            System.out.println("你好像什么都没输入啊？");
        }
        sc3.close();
    }
}

代码为了展示将 next 和 nextLine 整合在了一块，实际上这两个会冲突（你运行试试看？）然后的话判断的方式差别也是和前面的内容是一样的。那如何通过 hasNext 语句来判断是否是整形或者其他数据类型的输入呢？

通过 IDE 的联想的话可以看见 hasNext 语句的分支是非常多的，那随便拿个来作为例子：

import java.util.Scanner;

public class scanner {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        if (scanner.hasNextInt()){
            int n = scanner.nextInt();
            System.out.println(n);
        }else{
            System.out.println("你输入的好像不是整型啊？");
        }
    }
}

8、隐式转换和强制转换

①隐式转换

什么叫做隐式转换，其实说不用说是背这么一个专业词，看示例代码：

public class ImplicitConversion {
    public static void main(String[] args) {
        int a = 5;
        double b = 3.14;
        System.out.println(a + b);
    }
}

a是整型，b是双浮点型。那这两个加起来的结果是什么型？答案是双浮点型。因为他这样进行了一给隐式转换。

然后来几个练习题：

②强制转换

强制转换这个东西的话其实也很好理解，就是本来指定好的数据类型，直接强制转换成了指定的数据类型。

这个先不着急了解，后面的教程会继续说明。

9、算数运算符（补充）

①+运算符

②练习-数值拆分

题目：

示例代码：

import java.util.Scanner;
public class NumberBreaker {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入三位数字");
        int num = sc.nextInt();
        int ge = num % 10;
        int shi = num / 10 % 10;
        int bai = num / 100 % 10;
        System.out.println("个位数是" + ge);
        System.out.println("十位数是" + shi);
        System.out.println("百位数是" + bai);
    }
}

然后给大家来一个小结：

③运算符的补充（简便版）

当然的话这样子也可以更便捷的进行运算：

④运算符

⑤逻辑运算符+短路逻辑运算符

⑥三元运算符

三元运算符这个东西其实很好理解，看示例代码：

public class ThreeYuan {
    public static void main(String[] args) {
        int a = 5;
        int b = 10;
        int c = a > b ? a:b;
        System.out.println(c);
    }
}

其中代码部分：int c = a > b ? a:b; 就是我们所说的三元运算符。当a > b 符合这个条件的时候，c就会被复制给：前面的数值，也就是 a。如果不符合 a > b 这个条件的话，就给c赋值上：后面的数值，也就是b。

这么说的话三元运算符其实也很好理解的了。

⑦运算符优先级

二、Java进阶

从这个教程开始的话就是Java的一个进阶了，不过其实不会太难。不要紧张。

1、if语句

if 语句作为一个条件语句，也可以算是一种分支结构

①if语句

首先的话 if 语句是一种条件语句，当条件判断合适的时候就会执行命令。如以下代码：

import java.util.Scanner;
public class ifline {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        sc.close();
        if (a>5){
            System.out.println("这个数字大于5");
        }
    }
}

前面的话就是通过用户输入的数字，后面的if语句就是进行判断这个数字是否大于5。如果大于5的话就是true，就会输出 “这个数字大于5” 这个提示。没错 if 语句同时也可以判断布尔的数据类型，当结果为 true的时候就会直接执行内容：

import java.util.Scanner;
public class ifline {
    public static void main(String[] args) {
        boolean isLight = true;
        if (isLight) System.out.println("灯亮了");
    }
}

顺带一提，如果当代码只有一行的时候 {} 是可以省略的。但是的话我建议都要带个 {}。以免后期写代码混淆。

②if-else语句

既然前面有大于5数值进行判断，那肯定有不符合条件判断的。示例代码：

import java.util.Scanner;
public class IfAndelse {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        if (n > 5) System.out.println("所输入的数值大于5");
        else System.out.println("所输入的数值并不大于5");
    }
}

那就是一个 if else 的一个语句，大家记得个语法就可以了。

③else if 语句

那如果有多重条件呢？那就看示例代码：

import java.util.Scanner;
public class ElseIf {
    public static void main(String[] args) {
        System.out.println("请输入你的成绩：");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        sc.close();
        if (n >= 90) System.out.println("你的成绩为优秀！");
        else if (n >= 80 && n < 90) System.out.println("你的成绩为一般！");
        else if (n < 80 && n >= 60) System.out.println("你的成绩有点落后了，请加油");
        else if (n < 60) System.out.println("你的成绩为不合格！");
        else System.out.println("你输入的数值无法判断");
    }
}

这是一个成绩判断的一个小代码，代码可以通过你输入的成绩来判定评分等级，大概看一看！也是比较好理解的一个语句。

2、switch语句

switch 语句也是 分支语句 的一种语法。和 if 语句有点相似，请看他的流程图（菜鸟教程）：

switch case 语句有如下规则：

1、switch 语句中的变量类型可以是： byte、short、int 或者 char。从 Java SE 7 开始，switch 支持字符串 String 类型了，同时 case 标签必须为字符串常量或字面量。

2、switch 语句可以拥有多个 case 语句。每个 case 后面跟一个要比较的值和冒号。

3、case 语句中的值的数据类型必须与变量的数据类型相同，而且只能是常量或者字面常量。

4、当变量的值与 case 语句的值相等时，那么 case 语句之后的语句开始执行，直到 break 语句出现才会跳出 switch 语句。

5、当遇到 break 语句时，switch 语句终止。程序跳转到 switch 语句后面的语句执行。case 语句不必须要包含 break 语句。如果没有 break 语句出现，程序会继续执行下一条 case 语句，直到出现 break 语句。

6、switch 语句可以包含一个 default 分支，该分支一般是 switch 语句的最后一个分支（可以在任何位置，但建议在最后一个）。default 在没有 case 语句的值和变量值相等的时候执行。default 分支不需要 break 语句。

switch case 执行时，一定会先进行匹配，匹配成功返回当前 case 的值，再根据是否有 break，判断是否继续输出，或是跳出判断。

那我们先看示例代码：

import java.util.Scanner;
public class SwitchWithCase {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        char n = sc.next().charAt(0);
        switch (n) {
            case 'a':
                System.out.println("A");
                break;
            case 'b':
                System.out.println("B");
                break;
            case 'c':
                System.out.println("C");
                break;
            default:
                System.out.println("无法识别");
                break;
        }
    }
}

条件语句中还是在判断用户输入的字符，如果是 a 则输出 A 后直接 break; 跳出 switch 语句，如果没有 break 的话就会继续执行下面的代码块输入 B C 等内容 直到出现 break 或者语句结束为止。

default 的作用就是用作于不符合 case 的内容的一个默认输入内容，当你输入的内容非 a b c 的话就是输出default的内容。

3、循环语句

①while循环

while循环是一种最基本一个循环，其结构为：

while( 布尔表达式 ) {
  //循环内容
}

如果布尔表达式的值为 true 循环内容就会一直循环下去，直到布尔值为 false 才会终止。看示例代码：

public class WhileAndDoWhile {
    public static void main(String[] args) {
        int n = 10;
        while (n > 5){
            System.out.println("循环剩下" + (n - 5) + "次");
            n--;
        }
    }
}

如果你需要无限循环的话就是：

while (true) {}

这个代码就举了个例子就是循环的次数，当 n > 5 的时候布尔值就是true嘛然后就会开始执行 {} 里面的代码块，在输出内容的同时 n 也自减了 1 。最后不符合 n > 5 的条件，就结束的运行。

②do…while 循环

do while 循环和 while 循环不一样的地方就是，do while 循环就是先执行内容，在根据条件判断继续循环。总的来说就是先做在判断，while就是先判断再做。然后看示例代码：

public class WhileAndDoWhile {
    public static void main(String[] args) {
        int n = 10;
        do {
            System.out.println("循环剩下" + (n - 5) + "次");
            n--;
        } while (n > 5);
    }
}

就是先指定 do 的代码块的内容，然后再看 while 这边符合条件才继续 do。语法就是：

do {
       //代码语句
}while(布尔表达式);

③for循环

for循环这些东西其实和C语言非常相似，代码语法就是：

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

示例代码：

public class ForAndBreakContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("已经进行循环了" + i + "次");
        }
    }
}

输出的结果为：

已经进行循环了0次
已经进行循环了1次
已经进行循环了2次
已经进行循环了3次
已经进行循环了4次
已经进行循环了5次
已经进行循环了6次
已经进行循环了7次
已经进行循环了8次
已经进行循环了9次

示例代码中呢 for 循环第一个语句就是 设定为 i 为 0，第二个语句就是一个布尔表达式，如果 i 小于 10 的话 布尔值就是true，那他就会继续执行语句块，当每执行完一个代码块的话，就会进行 i++（自增）。因此他的顺序是：

当然这是基于符合条件，如果不符合呢？：

是的就是直接跳过了代码块。那其实这个也是很好理解的是吧！

④break和continue

Ⅰbreak语句

break 主要用在循环语句或者 switch 语句中，用来跳出整个语句块。break 跳出最里层的循环，并且继续执行该循环下面的语句。其语法就是：

break;

那如果代入示例代码呢：

public class ForAndBreakContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("已经进行循环了" + i + "次");
            break;
        }
    }
}

输出的结果为：

已经进行循环了0次

是的当他第一次执行完这个代码块完后读取到了 break 这个循环直接结束了，就开始执行后面的内容了。所以你可以直接理解成 终止循环。

Ⅱcontinue

continue 这个东西其实也很好理解，continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。在 for 循环中，continue 语句使程序立即跳转到更新语句。在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。

那就直接看示例代码：

public class ForAndBreakContinue {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if ( i == 5 ) continue;
            System.out.println("已经进行循环了" + i + "次");

        }
    }
}

输出内容：

已经进行循环了0次
已经进行循环了1次
已经进行循环了2次
已经进行循环了3次
已经进行循环了4次
已经进行循环了6次
已经进行循环了7次
已经进行循环了8次
已经进行循环了9次

没错如果当 i 等于 5的时候，直接执行 continue。那么这个第六次（循环从0开始因此这是第六次循环）的循环就直接跳过了，所以你会发现输出内容中少了个 ”已经进行循环了5次“ 这个内容。这就是continue的用法。

⑤小练习题

直接放答案：

public class FengServerPass {
    public static void main(String[] args) {
        for (int i = 1; i <= 100 ; i++) {
            if (i% 10 == 7 || i % 7 == 0 || i / 10 % 10 == 7) {
                System.out.println("过！");
                continue;
            }
            System.out.println(i);
        }
    }
}

4、数组

什么是数组？他是一种数据结构之一

①数组的定义

其实的话你会法西安数组定义的方式2 和C语言对数组定义的语法是一模一样的。然后的话初始化其实有两种方式，一个简写一个比较复杂，这个就是完整的格式：

简化格式：

示例代码如下：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        int[] arr2 = {1,2,3,4,5};
    }
}

相较于第一个完整版，简化版看着更容易记下来，同时的话数组也可以同时存储多个数据类型：

public class ArrayDefine {
    public static void main(String[] args) {
        String[] name = {"LiMing","ZhangSan"};
        double[] height = {1.78,1.80};
    }
}

②数组的输出

我们数组存储了大量的数据，那我们现在如何把数组内的数组输出出来呢？如果说是直接输出数组名呢？

那如何正确的输出我需要的数组的内容呢？请看示例代码：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5};
        int number = arr2[0];
        System.out.println(number);
    }
}

最终的输出结果为：

其中呢我们调用了 arr2[0] 这是数组的第一个值（数组的顺序都是从0开始的）然后赋值在 number 然后输出，那这样的话就可以正确的输出我们想要输出的内容了。

其格式就是：

数组名[索引]

③数组的遍历

诶数组的遍历是什么？

那如果我们想要一口气输出数组内的每个数据呢？请看示例代码：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5};
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

我们用的是for 循环，通过循环将数组的每一个数据，按照顺序输出。也就是索引从0到尾巴的一个过程，其中呢 arr2.length 就是代表数组的长度，和隔壁C语言的 sizeof 是一个意思。

④练习

Ⅰ遍历数组求和

参考答案：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5};
        int sum = 0;
        for (int i = 0; i < arr2.length; i++) {
            sum+=arr2[i];
        }
        System.out.println(sum);
    }
}

Ⅱ统计个数

参考答案：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5,6,7,8,9,10};
        int sum = 0;
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] % 3 == 0) {
                sum++;
            }
        }
        System.out.println(sum);
    }
}

Ⅲ变化数据

参考答案：

public class ArrayDefine {
    public static void main(String[] args) {
        int[] arr2 = {1,2,3,4,5,6,7,8,9,10};
        int sum = 0;
        for (int i = 0; i < arr2.length; i++) {
            if (arr2[i] % 2 == 0) arr2[i] /= 2;
            else arr2[i] *= 2;
        }
        for (int i = 0; i < arr2.length; i++) System.out.print(arr2[i] + "\n");
    }
}

⑤数组动态初始化

那这个数组有什么作用呢？我们可以指定这个数组的长度。看示例代码：

public class ArrayDefine {
    public static void main(String[] args) {
        String[] arr3 = new String[50];
        arr3[0] = "ZhangSan";
        System.out.println(arr3[0]);
    }
}

这样的话我们就定义了 arr3 这个数组能存储 50 个数据，同时我们也可以调用数据来进行输出，那如果我现在没有定义 arr3[1] 的内容，会输出什么呢？答案是：null，他会输出他的默认初始值。

那静态和动态有什么区别呢？

补充个注意事项：

⑥练习 – 动态化

Ⅰ求最值

参考答案：

public class FIndTheMax {
    public static void main(String[] args) {
        int[] arr = {33,5,22,44,55};
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] > max) {
                max = arr[i];
            }
        }
        System.out.println(max);
    }
}

Ⅱ遍历数组求和

参考答案：

import java.util.Random;

public class RadomNumber {
    public static void main(String[] args) {
        int[] arr = new int[10];
        Random r = new Random();
        for (int i = 0; i < arr.length; i++) arr[i] = r.nextInt(100) + 1;
        int sum = 0;
        for (int i = 0; i < arr.length; i++) sum += arr[i];
        int average = sum / arr.length;
        int geshu = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] < average) geshu++;
        }
        System.out.println("总和为：" + sum);
        System.out.println("平均数为：" + average);
        System.out.println("小于平均数的个数有：" + geshu + "个");
    }
}

Ⅲ交换数组中的数据

参考答案：

public class ExchangeArrData {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        for (int i = 0,j = arr.length - 1; i < j; i++,j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        for (int i = 0; i < arr.length; i++) System.out.print(arr[i] + " ");
    }
}

Ⅳ打乱数据

参考答案：

import java.util.Random;

public class DisturbArrData {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5};
        Random rand = new Random();
        for (int i = 0; i < arr.length; i++) {
            int index = rand.nextInt(arr.length);
            int temp = arr[i];
            arr[i] = arr[index];
            arr[index] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

5、Java的内存分配

6、方法

①介绍

什么叫做方法？

方法有什么作用呢？

比如说，我现在想打一把游戏，如果按照输出语句来游玩，就是图片上的过程，那如果我要打两把呢？难道我需要把所有内容再多打一遍吗？那这样的话是不是有点麻烦了？因此的话我们可以将这些代码直接打包下来，如图：

直接通过调用的方法调用两把游戏，是不是很熟悉，C语言的函数？Python的 def 方法？那有什么好处呢？

②定义和调用

那么了解方法之后，我们将了解如何进行定义和调用咯，那我们要如何定义他呢？首先的话我们要知道方法定义是：将所有的代码打包成一块，这个过程叫做方法。

那方法调用呢？方法调用就是：方法定义后并井不是直接运行的，需要手动调用才能执行，该过程称为方法调用。

好那么我们就向大家展示如何定义的：

然后的话我们将分成三个方法给大家讲解如何进行定义这个方法的：

Ⅰ最简单的

那就直接看这个代码：

public class ClassDefine {
    public static void Test(){
        System.out.println("Hello World");
    }
    public static void main(String[] args) {
        Test();
    }
}

然后我们将进一步的进行讲解这个代码内容，如下代码就是这个方法定义的框架：

public static void 方法名(){
        // 代码块
    }

那如何将这个方法调用呢？：

方法名();

然后给大家来一个注意事项：

这是一个看代码说结果的测试，其实很简单，只要从上往下读代码就可以了，不需要考虑太多的，输出的顺序我也画在图片上了，大家可以看看了解一下。

Ⅱ带参数的

为什么需要一个带参数的方法呢？你想想如果我自己写了一个计算的方法，但是他的值只能在方法中定义并不能收到主方法的定义，因此的话我们需要一个带参数的方法来接受主方法传入来的参数。

那么给大家来一个例子吧：

public class ClassDefine {
    public static void Test(int number){
        number++;
        System.out.println(number);
    }
    public static void main(String[] args) {
        Test(1);
    }
}

那么我给大家介绍一下这些代码：

public static void Test(参数类型 参数变量){
// 代码块
    }

那引用呢？

Test(参数值);

那你如果想要有多个值呢？用逗号分开：

public static void Test(int a, int b){
// 代码块
    }
Test(1, 2);

带参数和不带参数的区别：

Ⅲ带返回值的

带返回值啥意思啊？你想想哈我都对值进行传入参数了，那你还考虑什么，那肯定方法要吐出来一个数值是吧？那直接举个例子：

public class ClassDefine {
    public static int Test(int number){
        number++;
        return number;
    }
    public static void main(String[] args) {
        int a = Test(1);
        System.out.println(a);
    }
}

那么很明显的我们方法返回数值的时候用的是 return xxx; 在主方法中可以看出我们将返回值赋值给了 a 这个变量。这是一个流程：

上总结：

Ⅳ小总结

③方法的重载

Ⅰ介绍

什么是重载，为什么会有重载：

你可以想象，你在给方法进行命名的时候，会有一种情况，就是词穷了，我不知道要取什么名字，拼音大法又有点难堪，那么重载的作用就来了。他可以将所有的方法同一个命名。

那到底怎么实践呢？请看下列例子：

当我进行调用的时候，比如说 sum(1,2); 那我到底会用第一个方法还是第二个方法呢？其实很简单，答案是：第一个 为什么呢？因为第一个只需要两个参数，Java虚拟机会判断出来的。

这些是判断是否构成重载，要是参数个数一样的话可以判断数据类型的

Ⅱ练习

. 数组遍历

参考答案：

public class PrintArr {
    public static void main(String[] args) {
        int[] arr = {11,22,33,44,55};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.print(arr[i]);
            }else System.out.print(arr[i] + ", ");
        }
        System.out.print("]");
    }
}

.. 数组最大值

参考答案：

public class AccordingClassToPrintTheArrMaxNumber {
    public static int PrintMax(int[] arr){
        int max = arr[0];
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > max) max = arr[i];
        }
        return max;
    }
    public static void main(String[] args) {
        int[] arr = {1,4,2,3,6,1,4,8,0,10};
        int max = PrintMax(arr);
        System.out.println(max);
    }
}

… 判断是否存在

参考答案：

import java.util.Scanner;

public class FindItRealHave {
    public static boolean Find(int[] arr,int number){
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == number){
                return true;
            }
        }
        return false;
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9};
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        System.out.println(Find(arr,number));
    }
}

…. 复制数组

参考答案：

import java.util.Scanner;
public class CopyTheRangeOfTheArr {
    public static int[] CopyOfRange(int[] arr,int from,int to){
        int[] copyArr = new int[to - from];
        int index = 0;
        for(int i=from;i<to;i++){
            copyArr[index] = arr[i];
            index++;
        }
        return copyArr;
    }
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        Scanner sc = new Scanner(System.in);
        int from = sc.nextInt();
        int to = sc.nextInt();
        int[] newarr = CopyOfRange(arr,from,to);
        for(int i=0;i < newarr.length ;i++) System.out.println(newarr[i]);
    }
}

④方法的内存

不是很想说什么= = 直接略过。

⑤方法值的传递

看上面的代码的话，其实 number 的数值是无法修改的，因为方法内修改的数值只有方法内有效，所以，传递基本数据类型时，传递的是真实的数据，形参的改变，不影响实际参数的值。

要修改的话还是得通过 return 来进行修改：

7、综合练习题

黑马程序员的题目，随缘做（不一定全部做完答案不是百分百是黑马程序员的，我自己写的（

①买飞机票

参考答案：

import java.util.Scanner;

public class BuyThePlaneTicket {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.print("请输入飞机原价：");
        double Price = sc.nextInt();
        System.out.print("请输入购票月份：");
        int Month = sc.nextInt();
        System.out.println("请选择座位类型：");
        System.out.println("1. 头等舱");
        System.out.println("2. 经济舱");
        System.out.print("请输入对应数字(1、2)：");
        int Choice = sc.nextInt();
        if (Month >= 5 && Month <= 10) {
            switch (Choice) {
                case 1:
                    Price*=0.9;
                    break;
                case 2:
                    Price*=0.85;
                    break;
            }
        }else{
            switch (Choice) {
                case 1:
                    Price*=0.7;
                    break;
                case 2:
                    Price*=0.65;
                    break;
            }
        }
        System.out.println("飞机的价格为："+Price);
    }
}

②找质数

参考答案：

public class FindTheSuShu {
    public static void main(String[] args) {
        int sum = 0;
        for (int i = 101; i <= 200; i++) {
            boolean flag = true;
            for (int j = 2 ; j < i ; j++){
                if (i % j == 0){
                    flag = false;
                    break;
                }
            }
            if (flag){
                System.out.println(i + "是素数");
                sum++;
            }
        }
        System.out.println("素数一共有："+sum);
    }
}

③开发验证码

参考答案：

import java.util.Random;

public class TheRandomVerisity {
    public static void main(String[] args) {
        char[] chs = new char[52];
        for (int i = 0; i < chs.length; i++) {
            if (i <= 25) chs[i] = (char)(97 + i);
            else chs[i] = (char)(65 + i);
        }
        String result = "";
        Random rand = new Random();
        for (int i = 0 ; i < 4 ; i++){
            int randomIndex = rand.nextInt(chs.length);
            System.out.print(chs[randomIndex]);
        }
        int number = rand.nextInt(10);
        result += number;
        System.out.println(result);
    }

}

④数组元素的复制

参考答案：

public class CopyTheArr {
    public static void main(String[] args) {
        int[] arr = {1,2,3,4,5,6,7,8,9,10};
        int[] arr2 = new int[10];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[i];
        }
        for (int i = 0; i < arr2.length; i++) System.out.println(arr2[i]);
    }
}

⑤抢红包

参考答案：

import java.util.Random;
public class StoleTheRedPackage {
    public static void main(String[] args) {
        int[] arr = {288,388,588,1088};
        int[] newArr = new int[arr.length];
        Random r = new Random();
        for (int i = 0; i < 4; ) {
            int RandomIndex = r.nextInt(arr.length);
            int prize = arr[RandomIndex];
            boolean flag = contains(newArr, prize);
            if (!flag){
                newArr[i] = prize;
                i++;
            }
        }
        for (int i = 0; i < newArr.length; i++) System.out.println(newArr[i]);
    }
    public static boolean contains(int[] arr, int value) {
        for (int num : arr) {
            if (num == value) {
                return true;
            }
        }
        return false;
    }
}

⑥二维数组

二维数据这种东西其实很简单，你可以想象成一个表格，比如说一维数组是这样的：

二维数组就是这样的：

很好理解的，我就懒得写了，直接来一个黑马程序员的代码吧！

7、面向对象

①介绍

那怎么理解上面的面向对象呢？比如说

我现在要进行一个输出，我要找什么？能干活的东西，那就是System.out.print 嘛他能干活，这样就是面向对象，诶很好理解是吧，这有什么好处勒？

符合人类思维习惯，编程更简单，更好理解。