一. 注释

• 注释是对代码的一种解释,在程序 的指定位置, 添加的一些说明性信息被注释掉的内容, 不会参与程序的编译和运行.

分类:
        单行:  // 注释信息
        多行:  /* 注释信息 */
        文档:  /** 注释信息 */

二. 关键字

• Java语言中有特殊含义的单词，就是关键字。在后面的课程中会陆续的学到这些关键字的含义。

  关键字的特点： 1.全都是小写字母组成的 2.关键字被高级的代码编辑工具(idea)有特殊的颜色标记。

例如: 上图在idea中橙色标记的, public class static void int ... 等.

三. 自变量(常量)

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

//1.字符串常量： 用双引号括起来的内容
System.out.println("hello"); 
//2.字符常量：用单引号括起来的内容
System.out.println('a');
//3.整数常量：所有整数
System.out.println(666);
//4.小数常量：所有的小数
System.out.println(3.14);
//5.布尔常量：只有true(真)和false(假)
System.out.println(true);
//6.空常量:   null,空常量不能直接输出

四. 变量

• 变量是内存中的一小片空间，空间中存储的数据可以在某个范围内发生改变。

变量的定义格式:

数据类型 变量名 = 初始值;

//定义int类型的变量，赋值为10
int a=10;
System.out.println(a);

//定义short类型变量，赋值为5
short b=5;
System.out.println(b);

//定义double类型变量，赋值为3.14
double c=3.14;
System.out.println(c);

//定义boolean类型变量，赋值为true
boolean d=true;
System.out.println(d); 

//定义char类型变量，赋值为'a'
char s='a';
System.out.println(s);

//定义long类型的变量，需要加后缀L   <===
long m=8888888888L; //long类型后建议加大写字母L
System.out.println(m);

//定义float类型的变量，需要加后缀F  <===
float f=3.14F; //float类型后建议加大写字母F
System.out.println(f);

注意事项:

1.定义long类型的变量，必须加后缀L
2.定义float类的变量，必须加后缀F
3.可以在一行定义多个同类型的变量
    int x=3,y=4;
    System.out.println(x);
    System.out.println(y);
4.变量没有初始值，不能直接使用。
5.变量的名称不同相同

五. 标志符

• 自己给变量, 类起的名字都是标识符（重点）

规则 (必须要遵守):
1. 26个英文字母(大小写都可以)
2. 数字0~9
3. _ $
​
要求:
1. 不能以数字开头   2. 不能是关键字  3. 严格区分大小写
    
规范(江湖规矩)
​
1. 小驼峰命名法 (变量)
    
        如果是一个单词, 所有字母小写 age
        如果是多个单词, 从第二个单词开始, 首字母大写 maxAge
    
2. 大驼峰命名法 (类)
        
        如果是一个单词, 首字母大写  Student
        如果是多个单词, 每个单词首字母大写, GoodStudent

六. 基本数据类型

四类八种:（必须记住）

整数:
        byte        1个字节        
        short       2个字节
        int         4个字节
        long        8个字节
小数:
        float       4个字节
        double      8个字节
字符:
        char        2个字节
布尔:
        boolean     1个字节

七. 引用数据类型

Scanner(键盘录入)

• Java中的引用数据类型,作用于键盘录入. (通俗解释: 就是在程序运行时, 在控制台利用电脑键盘输入,所需要的对象)

// 1. 导包
import java.util.Scanner; 
// 2. 创建键盘录入对象
Scanner sc = new Scanner(System.in);
// 3. 接收键盘录入的数据(键盘输入的是什么类型, 就创建什么类型进行接收录入数据)
int age = sc.nextInt();

例如:

import java.util.Scanner;
​
public class Demo {
    public static void main(String[] args) {
        // 2. 创建一个键盘录入对象
        Scanner sc = new Scanner(System.in);
        // 友好提示:
        System.out.println("请输入一个整数: ");
        // 3. 键盘录入一个int类型的数据,并用int类型的变量 num 接收数据.
        int num = sc.nextInt();
        // 4. 打印输出数据
        System.out.println("你输入的值是: "+num);
    }
}

Random(随机数)

• 随机生成一定范围的随机数.

格式:

Random r=new Random();
int num = r.nextInt(n)+m; 
​
n: 生成随机数的个数(就是在这个随机数范围中, 满足条件的数有几个); 
m: 生成随机数时,起始值; 
​
例如: 生成 [58~75]之间的随机数
n : 18 (58到75之间有几个数); // 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 (18个)
m : 58(随机数从58开始);
即: 
Random r=new Random();
int num = r.nextInt(18)+58; 

例如:

// 1. 导包
import java.util.Random;
​
public class Demo {
    public static void main(String[] args) {
        // 2.创建Random对象
        Random r=new Random();
        // 3.生成指定范围的随机数 生成[70,100]范围内的随机数 包含70包含100
        int num = r.nextInt(31)+70;//可以自己简单推到一下。
        System.out.println(num);
    }
}

八. 运算符

算数运算符

+ - * : 没啥需要注意的, 跟小学学的是一样的
​
/ : 整数相除, 结果只能得到整数, 想要得到带有小数的结果, 必须有小数参与运算
% : 取模 ---> 获取的时候除法之后剩余的余数.
​
注意: % 一般情况是 判断一个数是否是偶数, 或者是一个数是否能被另一个数整除. 
 
    num % 2 == 0;   // 这个num就是一个偶数 
    num % n == 0;   // num能被n整除
​
例如: 
    int a = 5;
    int b = 2;
​
    System.out.println(5/2);    // 2 
    System.out.println(5%2);    // 1 

自增自减运算符

++ : 让变量自身的值 + 1操作
-- : 让变量自身的值 - 1操作
​
使用方式:
​
    1. 单独使用(推荐)
            ++, -- 在前在后没有区别
            
            int a = 10;
            a++;
            ++a;
​
    2. 参与运算使用(面试题)
             ++在前: 先自增, 再操作
             ++在后: 先操作, 再自增
                            - 先将该变量, 原本记录的值, 提取出来做操作, 然后再进行自增
                            
             int a = 10;
             int b = a++; // ++在a后面, 先将10赋值给b, b=10; 然后在a再去自增,a=11;
             System.out.println(a);  // 11
             System.out.println(b);  // 10
​
             int a = 10;
             int b = ++a; // ++在a前面, 先a去自增,a=11;然后再将11赋值给b, b=11;
             System.out.println(a);  // 11
             System.out.println(b);  // 11
​
使用场景: 
    需要做计数的时候, 例如求个数, 求几次. 做变量++操作. 

赋值运算符

基本赋值运算符:
​
        = : 将符号右边的数据, 赋值给左侧的变量
        
        int a = 10;
​
扩展赋值运算符:
​
        int a = 2; 
        int b = 5;
        
        b+=a; // b = b + a ;   //结果 : 7
        b-=a; // b = b - a ;   //结果 : 3
        b*=a; // b = b * a ;   //结果 : 10
        b/=a; // b = b / a ;   //结果 : 2
        b%=a; // b = b % a ;   //结果 : 1
        
​
        += : 将符号左右两边的数据做加法运算, 将结果赋值给左边
        -= : 将符号左右两边的数据做减法运算, 将结果赋值给左边
        *= : 将符号左右两边的数据做乘法运算, 将结果赋值给左边
        /+ : 将符号左右两边的数据做除法运算, 将结果赋值给左边
        %= : 将符号左右两边的数据做取余运算, 将结果赋值给左边
        

关系运算符

表达式:  
> >= < <= == !=
​
结论: 关系运算符无论简单还是复杂, 结果都只能是boolean类型的true, false
    
注意: =号是赋值运算符, ==是比较运算符
​
​
例如: 
    int a = 10;
    int b = 20;
​
    System.out.println(a > b);      // 结果: false
    System.out.println(a >= b);     // 结果: false
    System.out.println(a < b);      // 结果: true
    System.out.println(a <= b);     // 结果: true
    System.out.println(a == b);     // 结果: false
    System.out.println(a != b);     // 结果: true

逻辑运算符

&(与) : 并且, 符号两边结果必须同时是true,结果才能为true. 遇false结果就是false;
|(或) : 或者, 符号两边有一个结果是true,结果就为true. 遇true结果就是true;
!(非) : 取反, 取结果的对立面. 
​
​
例如: 
    int a = 10;
    int b = 20;
    int c = 30;
​
    System.out.println(a > b & b < c);      // 结果: false
    System.out.println(a < b & b < c);      // 结果:true
    System.out.println(a > b | b < c);      // 结果:true
    System.out.println(a > b | b > c);      // 结果:false
    System.out.println( !(a > b) & b < c );     // 结果:true
    System.out.println(a > b & !(b < c) );      // 结果:false

短路:

短路逻辑运算符:
​
    &  : 没有短路效果, 无论符号左边是true还是false, 右边都要继续执行
    && : 具有短路效果, 符号左边为false的时候, 右边就不执行了
            如果符号左边为true, 右边要继续执行
            
    |  : 没有短路效果, 无论符号左边是true还是false, 右边都要继续执行
    || : 具有短路效果, 符号左边为true的时候, 右边就不执行了
            如果符号左边为false, 右边要继续执行

三元运算符

介绍: 可以根据一个判断条件, 达成二者选其一.
​
格式: 表达式 ?  值1 : 值2;
执行流程:
        1. 执行判断条件, 看其返回结果是true, false
        2. true : 值1就是运算结果
        3. false : 值2就是运算结果
​
例如: 
利用三元运算符求三个整数的最大值
​
    int a = 10;
    int b = 20;
    int c = 30;
    // 谁是最大的? 
int max = a>b?a:b; 
int max1 = max>c ? max : c ;
System.out.println(max1);

九. 流程控制语句

if语句

if语句的格式1 :
​
    if(判断条件){
        语句体;
    }
​
执行流程:
    1. 执行判断条件, 看其返回结果是true, 还是false
    2. true : 执行 {} 中语句体
    3. false : 不执行 {} 中语句体

if语句格式2:
​
    if(判断条件) {
        语句体1;
    } else {
        语句体2;
    }
​
执行流程:
​
    1. 执行判断条件, 看其返回结果是true, 还是false
    2. true : 执行语句体1
    3. false : 执行语句体2

if语句的格式3:
​
    if(判断条件1){
        语句体1;
    }else if(判断条件2){
        语句体2;
    }else if(判断条件3){
        语句体3;
    }
    ...
    else {
        语句体n+1;
    }
​

switch语句

    if语句的格式1 :
    
        if(判断条件){
            语句体;
        }
    
    执行流程:
        1. 执行判断条件, 看其返回结果是true, 还是false
        2. true : 执行 {} 中语句体
        3. false : 不执行 {} 中语句体
    
​
    if语句格式2:
    
        if(判断条件) {
            语句体1;
        } else {
            语句体2;
        }
    
    执行流程:
    
        1. 执行判断条件, 看其返回结果是true, 还是false
        2. true : 执行语句体1
        3. false : 执行语句体2
​
    if语句的格式3:
    
        if(判断条件1){
            语句体1;
        }else if(判断条件2){
            语句体2;
        }else if(判断条件3){
            语句体3;
        }
​
        ...
        else {
            语句体n+1;
        }

for循环

格式:

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

初始化语句: 定义变量
判断条件: 控制循环是否需要继续的条件
循环体语句: 循环要执行的代码
条件控制语句 : 改变控制循环的那个变量

for(int i = 1; i <= 10; i++){  // 循环几次 
	System.out.println("HelloWorld");
}
   
使用场景: 明确循环次数的时候,使用for循环. 

无限循环
   
for(;;){}
​

while循环

格式:
​
初始化语句;
while(判断条件){
    循环体语句;
    条件控制语句;
}
​
int i = 1;
while(i <= 5){
    System.out.println("HelloWorld");
    i++;
}
​
使用场景: 不明确循环的次数, 使用while死循环.
while(true){
    循环体语句;
    条件控制语句;
}

do...while循环(了解)

格式:
​
初始化语句;
do {
    循环体语句;
    条件控制语句;
}while(判断条件);
​
特点: 无论判断条件是否满足, 都至少执行一次循环体

break&continue跳转控制语句

break: 结束\终止
                switch语句和循环语句,终止当前循环语句;
                
                注意: break只能在switch和循环中进行使用;
​
continue: 跳过
                跳过某一次循环体的执行, 继续下一次;
                
                注意: continue只能在循环中使用;
                
------------------------------------------------------------
​
共同的注意事项:
​
    break, continue, 下面不允许写代码, 因为执行不到;
​
使用细节:
​
如果在一个循环嵌套的代码中, break和continue, 只能操作自己所在的那一层
​
想要操作指定层, 可以使用标号(给循环起名字)

十. 数组

两种初始化:

动态初始化: 手动指定长度, 系统分配默认初始化值.       
    int[] arr = new int[长度];
​
静态初始化: 手动指定元素, 系统会计算出该数组的长度.    
    int[] arr = new int[]{100,100,100,90};
    int[] arr = {100,100,100,90};
​
arr[索引] <== 索引代表数组元素的下角标,索引都是从0开始,每个数组的最大索引值等于arr.length-1; 
​
注意: 
只要是对数组中的元素进行操作(获取元素,修改赋值元素), 第一个想法是循环遍历数组,这样才能得到数组的每一个元素.
for(int i = 0; i < arr.length; i++){
    // arr[i] 代表数组的每一个元素
    System.out.println(arr[i]); 
}   

两种初始化的使用选择:

1. 静态初始化:  如果要操作的数据都已经明确给出了, 推荐使用静态初始化
                需求: 计算出班级学生的总成绩  (100,100,100,90)
                int[] arr = {100,100,100,99};
​
2. 动态初始化:  只知道要存储几个元素, 但是不明确具体数值的情况
                
                int[] arr = new int[5];
                
                for(int i = 0; i < arr.length; i++){
                    arr[i] = sc.nextInt();
                }

十一. 方法

• 方法\函数: 一段具有独立功能的代码块, 不调用就不执行.

方法的定义:

定义格式:
​
public static 返回值类型 方法名(参数列表){
    方法体;
    return 返回值;
}
​
public static : 修饰符, 目前来说暂时记住
返回值类型: 跟return返回的结果有关
方法名: 自己给方法起的名字, 小驼峰命名法
参数列表: 方法运行之前所需要的材料
方法体: 方法中所维护的逻辑代码
return :
         1. 用于结束方法
         2. 用于将返回值返还给调用者

方法调用格式:

方法的调用格式:
​
1. 带返回值的方法:
​
        A: 单独调用-不推荐,因为没有拿到结果数据.   
            方法名(实参);
            
        B: 赋值调用-推荐, 因为灵活    
            返回值类型 变量名 = 方法名(实参)
                        
        C: 输出调用-偶尔用
            System.out.println(方法名(实参));
​
​
2. 不带返回值的方法(void) :
​
        void : 并不是一个数据类型, 只是标识此方法没有返回值的
​
        A: 单独调用
            方法名(实参);

示例:

public static void main(String[] args){
    // 1. getMax 为方法的调用, ()中的20,30 为方法的实参; 
    // 2. 用int类型参数接收方法返回的参数;
    int max = getMax(20,30);
    System.out.println(max);
}
​
​
// 1. 方法的定义. int: 方法返回值类型; getMax: 方法名; (int a, int b): 定义方法时使用的形参;
public static int getMax(int a, int b){
    // 2. 返回int类型参数;
    return a > b ? a : b;
}

方法注意事项:

1. 方法不调用就不执行
    
2. 方法与方法之间是平级关系, 不允许嵌套定义
    
3. 方法的编写顺序和执行顺序无关, 要想梳理执行顺序, 就看调用顺序
    
4. 如果一个方法的返回值类型为void, 表示此方法是没有返回值, return 语句可以省略不写的
        但如果非要写return的话, 只能写成 return;  后面不能带有具体的值.
        正确: return;
        错误: return 10;
​
5. return 语句下面不能写代码, 因为执行不到
    
6. 如果一个方法有明确的返回值类型, 一定要通过 return 语句带回一个结果, 无论什么情况下.

方法的重载:

介绍: 方法重载(Overload) : 方法与方法之间的一种关系
            
            - 在同一个类中, 方法名相同, 参数不同, 与返回值无关
                    (个数不同, 类型不同, 顺序不同)

十二. 面向对象

类和对象的关系: 
​
    类 : 是一组相关属性和行为的集合, 将类理解为是对象的设计图
            既然类是对象的设计图, 那就是说, 需要根据类, 才能创建出对象
        
    关系 : 依赖关系
                需要根据类去创建对象
           数量关系
                一对多的关系, 根据一个类, 可以创建出多个对象.
​
标准 JavaBean:（必须掌握）
​
    1. 所有成员变量私有化
    
    2. 提供出[空参][带参]构造方法
    
    3. 针对于私有的成员变量, 提供出setXxx\getXxx方法
​

例如:

// 1. 定义一个Student类
public class Student {
​
    // 2. 成员变量私有化
    private String name;
    // 2. 成员变量私有化
    private int age;
    // 2. 成员变量私有化
    private String teacherName;
​
    // 3. 提供空参构造方法
    public Student() {
    }
    // 4. 提供带参构造方法
    public Student(String name, int age, String teacherName) {
        this.name = name;
        this.age = age;
        this.teacherName = teacherName;
    }
    
    // 5. 针对于私有的成员变量, 提供出getXxx方法
    public String getName() {
        return name;
    }
    // 5. 针对于私有的成员变量, 提供出SetXxx方法
    public void setName(String name) {
        this.name = name;
    }
​
    public int getAge() {
        return age;
    }
​
    public void setAge(int age) {
        this.age = age;
    }
​
    public String getTeacherName() {
        return teacherName;
    }
​
    public void setTeacherName(String teacherName) {
        this.teacherName = teacherName;
    }

十三. String与StringBuilder

String介绍

特点:
1. Java 中所有的双引号字符串, 都是String这个类的对象
​
2. String 一旦被创建就不可改变 - 内容不可改变
    
            - String是一个不可改变的字符序列
            
            String s = "abc";
            s = "def";      // 这一步是让s变量, 记录了新的对象, 原来的 "abc" 内容是根本没有改变的
        
3. 字符串虽然不可改变, 但是其内容可以被共享
​
            - 字符串常量池 :
                    
                    在使用双引号创建字符串对象时, 会检查该数据在常量池中是否存在
                            不存在 : 创建
                            存在 : 复用

创建方式:

1. public String() : 创建一个空白的字符串对象
    String s = new String();
    
2. public String(String s) : 根据传入的字符串, 创建字符串对象
    String s = new String("abc");
​
3. public String(char[] chs) : 根据传入的字符数组, 创建字符串对象
    char[] chs = {'a','b','c'};
    String s = new String(chs);
​
​
1. String s = "abc";
​
​
​
两种创建字符串对象的区别 :
​
    1. 双引号直接创建: 数据会在字符串常量池中进行维护
    2. 通过构造方法 new 出来的对象: 会在堆内存中有自己独立的内存空间

String常见方法

String类中用于比较的方法:
​
public boolean equals(Object anObject) : 
    两个字符串之间做比较, 比较内容, 返回true, false的结果
​
public boolean equalsIgnoreCase(String anotherString)  : 
    两个字符串之间做比较, 比较内容, 返回true, false的结果, 忽略大小写
​

String类中用于遍历的方法:
​
public char[] toCharArray() : 将字符串转换为字符数组
​
public char charAt(int index) : 根据传入的索引获取字符
​
public int length() : 返回字符串中字符的个数

String类中用于截取的方法: 
​
public String substring(int beginIndex) : 
    根据传入的索引截取当前字符串, 截取到末尾, 并返回新的字符串
public String substring(int beginIndex, int endIndex) : 
    根据传入的开始和结束索引, 截取字符串, 并返回新的字符串
    - 包含头, 不包含尾，什么是包头不包尾？如下：

 只截取索引尾1到4之间的字符串，故称之为包头不包尾。

String类中用于替换的方法:
​
public String replace(CharSequence target, CharSequence replacement) :
    参数1 target :  旧值
    参数2 replacement : 新值

String类中用于切割的方法 :
​
public String[] split(String regex) : 
​
根据传入的字符串参数, 作为规则, 切割当前字符串.
​
正则表达式 : 本质就是一个字符串 ---> 可以去指定一些规则.
​
结论: 今后在做切割的时候, 希望都能以 \\ 为开头

StringBuilder介绍

- 字符串的缓冲区(容器), 容器可以存储任意数据类型, 但是数据进入到该容器, 都会变成字符串
    - 可变的字符序列
    
- String 和 StringBuilder 区别
    - String不可改变的字符序列
    - StringBuilder可以改变的字符序列
​
思考: 
如何将一个基本数据类型变成字符串类型? 

StringBuilder常用方法

public StringBuilder append(任意类型);
​
    往StringBuilder容器添加任意类型的数据，返回StringBuilder本身。
​
public StringBuilder reverse();
​
    对StringBuilder进行反转
​
public int length();
​
    获取StringBuiler容器中字符的个数
​
public String toString();
​
    把StringBuilder容器转换为字符串
​

StringBuilder和String之间的相互转换

String ---> StringBuilder 的转换
​
            1. 通过StringBuilder的构造方法进行转换
​
                        String s = "abc";
                        StringBuilder sb = new StringBuilder(s);
​
            2. 先创建StringBuilder对象, 再通过append方法进行转换.
                        String s = "abc";
                        StringBuilder sb = new StringBuilder();
                        sb.append(s);
​
StringBuilder ---> String 的转换
​
            1. 直接通过toString方法即可
                        StringBuilder sb = new StringBuilder("abc");
                        String s = sb.toString();

 好的最后我们看一下基础班遇到的单词，也在温习一下。

Day01(Java环境搭建与入门)
单词		音标		释义
Windows		[ˈwɪndoʊz]		窗口
Linux		[ˈlɪnəks; ˈlaɪnəks]		Linux操作系统
public		[ˈpʌblɪk]		公共的
class		[klɑːs]		类
static		[ˈstætɪk]		静态
void		[vɔɪd]		空的
main		[meɪn]		主要的
String		[strɪŋ]		字符串
args		['ɑ:ɡs]		自变量
System		[ˈsɪstəm]		系统
out		[aʊt]		输出
print		[prɪnt]		打印
Debug		[ˌdiːˈbʌɡ]		调试
path		[pɑːθ]		路径
version		[ˈvɜːʃn]		版本
Project		[ˈprɒdʒekt]		项目
Module		[ˈmɒdjuːl]		模块
package		[ˈpækɪdʒ]		包
basic		[ˈbeɪsɪk]		基础
code		[kəʊd]		代码
run		[rʌn]		运行
font		[fɒnt]		字体
completion		[kəmˈpliːʃn]		完成
remove		[rɪˈmuːv]		移除
import		[ˈɪmpɔːt]		导入
apply		[əˈplaɪ]		应用
Day02(Java基础语法,运算符,分支语句)
单词		音标		释义
boolean		[ˈbu:liən]		布尔型、布尔类型
true		[tru:]		真正地、正确的
false		[fɔ:ls]		错的、错误的
byte		[baɪt]		字节
short		[ʃɔ:t]		短整型
int		[ɪnt]		整型
long		[lɒŋ]		长整型
float		[fləʊt]		浮动、单精度浮点数据类型
double		[ˈdʌbl]		双精度浮点数、双精度浮点数据类型
char		[tʃɑ:(r)]		字符型、字符类型
height		[haɪt]		身高
gender		[ˈdʒendə(r)]		性别
flag		[flæɡ]		标记
name		[neɪm]		姓名
import		[ˈɪmpɔːt]		导入
util		[ju'til]		工具
Scanner		[ˈskænə(r)]		扫描仪
new		[njuː]		新的
nextInt				下一个整数
next		[nekst]		然后
max		[mæks]		最大
if		[ɪf]		如果
else		[els]		否则
Unicode		['junɪˌkod]		字符编码标准
Day03(循环语句)
单词		音标		释义
switch		[swɪtʃ]		开关、切换、交换机
case		[keɪs]		情况、状况
break		[breɪk]		打断、中断
default		[dɪˈfɔ:lt]		默认、预设、缺省
for		[fə(r)]		循环、因为、 为了
while		[waɪl]		循环、当…的时候
do...while		['du:w'aɪl]		循环语句、重复步骤
continue		[kənˈtɪnju:]		继续、持续
Random		[ˈrændəm]		随机数
import		[ˈɪmpɔːt]		导入
score		[skɔ:(r)]		分数、成绩
loop		[lu:p]		循环
year		[jɪə(r); jɜː(r)]		年
money		[ˈmʌni]		钱
sum		[sʌm]		总和
Day04(数组)
单词		音标		释义
result		[rɪˈzʌlt]		结果,成绩
length		[leŋkθ]		长度
native		[ˈneɪtɪv]		本地,天生
month		[mʌnθ]		月
min		[mɪn]		最小值
array		[əˈreɪ]		数组、队列
stack		[stæk]		栈
heap		[hi:p]		堆
index		[ˈɪndeks]		索引
out of		[aut ɔv]		超出
bound		[baʊnd]		界限
Exception		[ɪkˈsepʃn]		异常
null		[nʌl]		空
pointer		[ˈpɔɪntə(r)]		指针
ArrayIndexOutOfBoundsException				索引越界异常
NullPointerException				空指针异常
Day05(方法)
单词		音标		释义
getMax				获取最大值
max		[mæks]		最大值
double		[ˈdʌbl]		双倍,双精度浮点数
method		['mɛθəd]		方法,类函数
return		[ri tə:n]		返回
result		[rɪ'zʌlt]		结果
compare		[kəm'pɛr]		比较
number		['nʌmbɚ]		数字
change		[tʃendʒ]		改变
reverse		[rɪ'vɝs]		反转
start		[stɑrt]		开始
end		[ɛnd]		结束
define		[dɪˈfaɪn]		定义
param		[pəˈræm]		参数
same		[seɪm]		相同、 同样
count		[kaʊnt]		计数、计算、统计
overload		[ˌəʊvəˈləʊd]		重载
open		[ˈəʊpən]		打开、开启
judge		[dʒʌdʒ]		判断、 裁判
Day07(面向对象基础-封装)
单词		音标		释义
study		[ˈstʌdi]		学习
protected		[prə'tektɪd]		受保护的
salary		[ˈsæləri]		薪水
Manager		[ˈmænɪdʒə(r)]		经理
student		[ˈstju:dnt]		学生、 学员
name		[neɪm]		姓名
age		[eɪdʒ]		年龄
eat		[i:t]		吃
sleep		[sli:p]		睡觉、睡眠
import		[ˈɪmpɔ:t]		导入
phone		[fəʊn]		手机、电话
brand		[brænd]		品牌、商标
price		[praɪs]		价格
color		['kʌlə(r)]		颜色
call		[kɔ:l]		打电话
send		[send]		发送
message		[ˈmesɪdʒ]		信息、消息
variable		[ˈveəriəbl]		变量
difference		[ˈdɪfrəns]		区别、差异
private		[ˈpraɪvət]		私有、私人的
show		[ʃəʊ]		显示、展示
person		[ˈpɜ:sn]		人
this		[ðɪs]		这个、这
construct		[kənˈstrʌkt]		构造
dog		[dɒg]		狗
get		[ɡet]		获取
set		[set]		赋值
cat		[kæt]		猫
Day08(String和StringBuilder)
单词		音标		释义
content		[ˈkɒntent; kənˈtent]		内容，目录；满足；容量
toCharArray				转换为字符数组
equals		['i:kwəlz]		相等
equalsIgnoreCase				判断两字符串忽略大小写是否相等
charAt				截取一个字符
length		[leŋkθ]		长度
subString		[ˈsʌbstrɪŋ]		子串；子链
replace		[rɪˈpleɪs		替换,更换
split		[splɪt]		切割
StringBuilder
append		[əˈpend]		附加,追加
reverse		[rɪˈvɜːs]		反转
toString				将数值转换成字符串
LowerCase		['ləʊəˌkeɪs]		小写字母
UpperCase		['ʌpəˌkeɪs]		大写字母
Day09(集合)
单词		音标		释义
list		[lɪst]		列表，清单，目录
ArrayList				动态数组
size		[saɪz]		大小,尺寸
add		[æd]		添加
remove		[rɪ'muv]		删除
element		['ɛləmənt]		元素
Manager		['mænɪdʒɚ]		管理
update		[,ʌp'det]		修改
list		[lɪst]		清单
manager		[ˈmænɪdʒə(r)]		管理者