Java基础知识梳理---从配置环境变量到完成学生管理系统

个人介绍

大家好我是：一颗松
认真分享技术，记录学习点滴
如果分享对你有用请支持我哦🍺

点赞：👍 留言：✍收藏：⭐️

个人格言： 想法落实的最佳时机就是现在！🏄

文章目录

• ​​1 java基础知识梳理​​
• 
  
• ​​2 开发环境搭建​​

• ​​2.1 安装JDK​​
• ​​2.2 配置环境变量​​

• ​​3 java基础语法​​

• ​​案例1 --- HelloWord案例​​
• ​​3.1 标识符和关键字​​
• ​​3.2 常量和变量​​
• ​​3.3 运算符​​

• ​​4 数组​​

• ​​4.1 一维数组​​
• ​​案例2---数组案例集​​
• ​​4.2 数组初始化内存分配图解​​
• ​​4.3 二维数组​​

• ​​5 流程控制​​

• ​​5.1 顺序结构​​
• ​​5.2 分支结构​​
• ​​案例3---成绩奖励（if案例）​​
• 
  
• ​​案例4 --- 成绩录入输出评价（switch案例）​​
• ​​知识拓展【三目运算符：】​​
• ​​案例5---三目运算符操作案例：​​
• ​​5.3 循环结构​​
• ​​案例6 --- 求100以内偶数和(for循环案例)​​
• ​​案例7 --- 打印所有水仙花数（for循环）​​

• ​​6 java中的方法​​

• ​​6.1方法的概念与功能​​
• ​​6.2 方法定义格式：​​
• ​​案例8--- 方法定义​​
• ​​6.3 自定义方法的位置：​​
• ​​6.4 方法的调用与执行：​​
• ​​6.5 方法调用内存图解​​
• ​​6.6 java方法的值传递与址传递​​
• ​​案例9--- 定义方法做输出​​

• ​​7 初识面向对象​​

• ​​7.1 类与对象​​
• ​​案例9 ----定义学生类​​
• ​​案例10---根据案例9创建学生对象张三​​
• ​​7.2 构造方法​​
• ​​7.3 java面向对象的特征​​
• ​​案例11---学生类的封装案例​​

• ​​8 初识javaAPI​​

• ​​8.1JavaAPI帮助文档的使用方法​​
• ​​8.2 String类的介绍​​
• ​​案例12----字符串常量池面试题​​
• ​​案例13---自定义方法统计指定字符在本字符串中出现的次数​​
• ​​8.3 Random类​​
• ​​案例14---java小游戏【猜数字】​​

• ​​9 初识集合​​

• ​​9.1 ArryList集合​​
• ​​案例15 ----ArrayList初使用​​

• ​​学生管理系统实现​​

初学须知
:::info
💡 1. 常用百度
💡 2. 一定要动手敲，并长时间坚持（第一遍可能会很难）
💡 3. 多思考并自行实现功能代码
:::

1 java基础知识梳理

用思维导图，结构化展现java基础大概内容。

2 开发环境搭建

学习编程，必须有自己的开发环境

2.1 安装JDK

1. 拓展知识：

• java语言是跨平台语言，一套java代码可以去多个系统软件上运行（Windows、macOS、Linux…）,但前提是需要在系统软件上安装有java运行环境(JRE)；

1. JRE：（java Runtime Environment）java运行环境，它**包含java虚拟机(JVM)**和一些标准类库；
2. JVM：(Java Virtual Machine)，java字节码文件(.class)在虚拟机上运行。java程序离不开java虚拟机。
3. JDK：Java Development Kit，java语言开发工具包，包含java运行环境JRE和java工具

• JDK、JRE、JVM三者之间是包含与被包含关系

2. 安装JDK

1. 打开浏览器输入甲骨文公司官网(​​https://www.oracle.com​​),在导航栏点击产品（Products）进入页面底部，选择java

2. 进入java页面，翻到页面底部选择Orele JDK

4. 进入下载页面根据需求下载



5. 安装过程一路next就可以（如果想修改安装目录，最好安装在纯英文目录下）

2.2 配置环境变量

1. 为什么要配置环境变量？

答：因为在不配置环境变量的情况下，java的编译运行操作只能在java安装目录下进行，使得工作很难展开。（高版本JDK会自动配置环境变量，存在功能不全问题；建议手动配置）

2. 配置工作

1. 找到此电脑，右击选择属性

2. 进入属性界面后选择高级系统设置

3. 进入系统设置后选择高级，再选择环境变量设置

4. 进入环境变量配置页面后在系统环境变量下，选择新建

5. 新建JAVA_HOME并配置安装目录到jdk版本目录

6. 在path环境变量下，添加新配置;配置内容：“%JAVA_HOME%\bin”

到这里配置就算完成了。

3. 怎么检查是否配置成功？

3 java基础语法

清楚基础语法知识对于后期学习是十分必要的，一点一点的必须搞懂；
注意：【java语言中对字母的大小写是严格区分的，大写和小写代表两个东西。】
我们先看一个完整java程序案例：

案例1 — HelloWord案例

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

3.1 标识符和关键字

1. 什么是标识符？

标识符：java开发中用到的名字，就是各种名字：变量名、类名、包名等等；
案例1中：HelloWord是类名、main是方法名，args是变量名；这些都是标识符

名字呢不能乱起，那么该如何命名？【标识符的命名规则】

• 只能由：数字、字母、下划线(_)和“$”组成！不能出现其他任何字符。
• 不能以数字开头

江湖规则1： 小驼峰命名法，一个单词时全小写，多个单词时从第二个单词开始首字母大写，常见在（变量、方法名）
江湖规则2： 大驼峰命名法，每个单词首字母大写常见在（类名）话说不遵守江湖规则是行不通滴；

注意：【标识符要做到见名知意】

2. 关键字是什么？

关键字：java中有特殊含义的单词，在高级记事本或者集成开发环境中都会用不同的颜色显示；不需要特意背知道常见，慢慢积累；

java常用关键字：

3.2 常量和变量

常量和变量都描述的是数据，数据有不同的类型我们首先了解一下java中的数据类型

1. 常量：就是值不会发生改变的数据，比如：2，‘a’,"java"等等

此处需要注意的是：

• 浮点型常量：浮点型就是小数类型常量，小数默认是double类型，如果是float类型数值后必须加F或f
• 字符型常量：用单引号括起来的的单个字符如：‘a’、‘6’、'A’等等；
• 字符串常量：用双引号括起来的内容如：“helloword”、“15121”、" "等等；

注意：空字符串""，字符串的值为空；空字符’'会报错

2. 变量：变量定义格式

1. 数据类型 变量名；
2. 数据类型 变量名 = 变量值；

3.3 运算符

1. 算术运算符：

算术运算符注意事项【面试题】：

• 以下语句会不会报错？为什么？

    short num1 = 10,num2;
        byte num3 = 20;
        num2 = num1+num3;      //第一句
        //---------------------------------------------------
        num2 = 200+30;      //第二句
        //-------------------------------------------------
        num3 = 120+10;        //第三句
        //-------------------------------------------------
        //解析
        /*
      第一句：会报错，这边存在一个隐式转换；【任何整型变量在计算时都会默认转为int类型】再做计算；此处num1与num3会先转int计算完再赋值，然而num2是short类型，大类型值赋值给小类型会报错；
      第二句：不会报错，此处存在常量优化机制，因为200与30都是常量，在编译过程中会将结果计算出来，再给num2赋值；num2是short类型230在它的范围内；所以不会出错；
      第三句：会报错，虽然java有常量优化机制，但是，此处优化后的结果是130，超出了byte的范围；【byte范围：-128----+127】
    */
         

2. 赋值运算符：

赋值运算案例：

    int  num2  = 20;    //把 常量20赋给num2
    //-----------------------------------------------
    byte num3 = 20;
        num3 += 20; //此处实质是：num3 = (num3类型)（num3+20）

注意： 【类似+=、-=、%=这样的赋值运算存在默认强制转换机制】

3. 判断运算符：

4. 逻辑运算符：

|        // 逻辑或
^        // 逻辑异或
||     // 短路或

两个变量值互换要求：不用第三方变量【面试题】：

• 方案1 数学思维解决

    int num1 = 20;
        int num2 = 30;
        num1 = num1+num2;
        num2 = num1-num2;
        num1 = num1-num2;

• 方案2 用异或解决【一个数被另一个数连续异或两次，这个数值不变】

      int num1 = 20;
        int num2 = 30;
        num1 = num1^num2;
        num2 = num1^num2;
        num1 = num2^num1;

4 数组

4.1 一维数组

1. 数组概念：
数组是一个可以存储多个相同数据类型的数据的容器；

2. 数组的定义与初始化

数据类型 [ ] 数组名；
数据类型 数组名 [ ]；

3. 静态初始化，两种格式：

完整格式1
数据类型 [ ] 数组名 = new 数据类型[ ] { 数据1,数据2,数据3… };
简化格式2
数据类型 [ ] 数组名 = { 数据1,数据2,数据3… };

静态初始化 案例-1

//数组定义初始化完整格式
        int [] arr1 = new int[]{1,2,3};
        //数组定义初始化简化格式
        int [] arr2 = {1,2,3};

4. 动态初始化格式

数据类型 [ ] 数组名;
数组名 = new 数据类型 [ 所需的存储空间];

动态初始化 案例-2

int [] arr3;//定义数组
  arr3 = new int[10];//动态初始化
  arr3[0] = 15;
  arr3[1] = 20;
  .
  .
  .
  arr[9] = 9

5. 数组元素访问

• 索引
  索引的概念：容器中空间的编号就是索引，索引值从0开始（容器中空间编号从0开始）
• 元素：数组中存储的数据被称为

访问格式

格式：数组名 [索引值]；
eg: int [] arr2 = {1,2,3};
arr2[0];
arr2[1];
注意：数组元素以索引值访问时只能，一个一个单独访问，不能同时出现多个索引值;
–
错误示例： arr2[0,1,2];

访问案例

int [] arr2 = {1,2,3};
 System.out.println("arr2数组中第一元素为："+arr2[0]);

6. 数组遍历
数组遍历：就是把数组中的每个元素，依次都访问一遍；

数组遍历，输出所有元素格式：

for (int i = 0; i < 数组长度; i++) {
System.out.println(“数组值：”+数组名[i]);
}

友情提示:【IDEA快捷键—生成遍历框架【 数组名 .fori +Enter 】

案例2—数组案例集

数组遍历输出 案例-3

int [] arr2 = {1,2,3};//定义，静态初始化数组
for (int i = 0; i < arr2.length; i++) {
    System.out.println("数组值："+arr2[i]); //遍历输出arr2数组中的每个元素
}

求数组元素偶数和 案例-4

int [] arr4 = {1,2,3,4};     //静态初始化数组
        int sum =0;
        for (int i = 0; i < arr4.length; i++) {
            if (arr4[i]%2==0){  //通过取模筛选出所有偶数
                sum += arr4[i];  //累加计算偶数和
            }
        }
        System.out.println("数组元素中所有偶数和为："+sum);  //输出偶数和

求数组元素中最大值 案例-5

public static void main(String[] args) {
        int [] arr5 = {1,15,20,9,88,8}; //静态初始化数组
        for (int i = 1; i < arr5.length; i++) {
            if (arr5[0]<arr5[i]){ //筛选出大于arr5[0]的数
                arr5[0] = arr5[i];//将筛选出的数，赋值给arr5[0]
            }
        }
        int max = arr5[0];            //将arr5[0]赋值给max变量
        System.out.println("次数组最大值为："+max);
    }

4.2 数组初始化内存分配图解

 public static void main(String[] args) {
        int [] arr = new int [7]; //动态初始化一个长度为10的数组
    }

方法区： java中字节码文件会存在方法区；【注意：字节码文件不调用不加载】

栈内存： java把内存分为两部分，栈内存和堆内存，基本类型变量存于栈内存，栈内存存储特点，先进栈的内容后出栈；

堆内存： 所有new出来的东西存放在堆内存中。

当arr的值为null时，再访问arr数组元素时，就会出现空指针异常，报错如下：

Exception in thread "main" java.lang.NullPointerException
  at HelloWord.main(HelloWord.java:8)

4.3 二维数组

二维数组就是，一维数组的元素时一维数组；也就是数组存数组，这边不详细展开

5 流程控制

流程控制在各编程语言中通用，所以这是必须要掌握的第4点内容

5.1 顺序结构

程序默认是按照从上往下的顺序，执行流程；

5.2 分支结构

5.2.1 if语句（判断条件最终必须为：布尔类型值）

1. 简单if语句格式：

语句格式：
if (判断条件){
语句体; //判断条件成立执行语句体；
}

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体");  //判断条件为false，此语句不执行；
}

2. if…else语句格式

语句格式：
if (判断条件){
语句体1; //判断条件成立执行语句体1；
}else{
语句体2; //判断条件不成立执行语句体2；
}

int nub1 = 1;
int nub2 = 2;
if(nub1>nub2){
       System.out.println("执行了语句体1");  //判断条件为false，此语句不执行体；
}else{
       System.out.println("执行了语句体2");  //判断条件为false，执行此语句体；
}

3. if…else if…else…语句格式

语句格式：
if (判断条件1){
语句体1; //判断条件成立执行语句体1；
}else if(判断条件2){
语句体2; //判断条件1不成立,判断条件2成立，执行语句体2；
}else{
语句体3; //判断条件1和2都不成立执行语句体3；
}

案例3—成绩奖励（if案例）

/*
考试奖励：
    分数>=90:奖励自行车一辆
    90>分数>=80:奖励游乐园一日游
    80>分数:一顿狂揍
*/
public class IfTest {
    public static void main(String[] args) {
        int chengji;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩：");
           chengji = sc.nextInt();
           if (chengji <=100 && chengji>=0){
               if (chengji>=90){
                   System.out.println("恭喜！奖励自行车一辆！");
               }else if (chengji>=80 && chengji<90){
                   System.out.println("恭喜！奖励游乐园一日游！");
               }else{
                   System.out.println("来吧一顿接受狂揍！");
               }
           }else{
               System.out.println("成绩输入有误！");
           }
    }
}

5.2.2 switch语句
switch语句格式：如下伪代码所示

switch(variable){
           case 1:
               语句体1;
               break;
           case 2:
              语句体2;
               break;
           case 3:
               语句体3;
               break;
               .
               .
               .
           default:
               默认语句;
               break;
       }

1. variable的取值范围

• 基本类型：byte、short、int、long
• 引用类型：jdk5开始，允许枚举类型；jdk7开始，允许String
• jdk14开始允许，一个case 后跟多个值：case 1,2,3:
• if与switch选用：范围性的判断用if更合理；switch更适合固定值判断；

2. case穿透（可以优化代码）

case穿透示例：如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1:
    case 2:
    case 3:
        //重复语句体；
        break;
    default:
        break;
}

3. jdk14以后新特性（可以优化代码）

case穿透示例：如果有多个重复的语句体可以使用case穿透

switch(variable){
    case 1,2,3:
        //重复语句体；
        break;
    default:
        break;
}

案例4 — 成绩录入输出评价（switch案例）

System.out.println("请输入成绩：可选项【A、B、C、D】");
        switch ('B') {
            case 'A':
                System.out.println("成绩良好");
                break;
            case 'B':
                System.out.println("成绩中等");
                break;
            case 'C':
                System.out.println("及格");
                break;
            default:
                System.out.println("成绩不合格！");
                break;
        }

switch语句执行流程：
第一步：拿variable值与case值对比，如果对比结果相等，则进入语句体，直到遇到break；或者执行结束才会退出switch语句；
第二步：如果在case中没有匹配到值，就会进入default语句，直到遇到break;或者执行结束才会退出switch语句。在switch语句中 执行顺序与case 、default的位置无关；

知识拓展【三目运算符：】

三目运算符格式：
判断条件 ？ 值1 : 值2；

执行流程：
1 判断条件是否为真？
2 如果判断条件为真，则 值1 赋给这这条语句的结果；
3 如果判断条件为假，则 值2 赋给这这条语句的结果；

案例5—三目运算符操作案例：

public void  operator(){
    int a,b,c;
    a = 10;
    b = 20;
    //第一种情况判断条件(b>a)为真
    c = b>a ? a:b;//c的值为10；
    //第二种情况判断条件(b<a)为假
    c = b<a ? a:b;//c的值为20；
}

5.3 循环结构

使用循环的条件：

某个操作需要重复执行多次

5.3.1 for循环

1. for循环的使用

//for循环格式：

    for(初始化语句;条件判断语句;条件控制语句){
       //循环体语句;
    }
//在for循环中，初始化语句只执行1次；
//for循环案例：
 public static void main(String[] args) {
        for(int i =0;i<3;i++){
            System.out.println("执行第"+i+"次循环！");
        }
    }

2. for循环执行流程（重中之重）

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

注意：【在for循环中初始化语句只执行一次】

案例6 — 求100以内偶数和(for循环案例)

//for循环案例3（1-100之间的偶数和）
//实现方案1
        int sum =0;
        for (int i = 1;i<=100;i++){
            if (i%2==0){
                sum += i;
            }
        }
        System.out.println("1-100之间偶数和为："+sum);
//实现方案2
        int sum =0;
        for (int i = 2;i<=100;i+=2){
                sum += i;
        }
        System.out.println("1-100之间偶数和为："+sum);

案例7 — 打印所有水仙花数（for循环）

需求分析：什么是水仙花数？
答：水仙花数是一个三位数，它的每个位上的数字的 3次幂之和等于它本身。
步骤分析：

1 通过for循环筛选出三位数
2 通过if按照水仙花数概念，晒出水仙花数

//for循环找出水仙花数
        for (int i=100;i<=999;i++){
            int ge,shi,bai; //定义各位、十位、百位变量准备后续操作
            ge = i%10;
            shi = i/10%10;
            bai = i/100;
            //用if对水仙花数条件进行筛选
            if (i==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
                System.out.println("水仙花数："+i);
            }
        }

6 java中的方法

6.1方法的概念与功能

方法概念：具有独立功能的代码块【在其他语言中也叫函数】
方法作用：
a. 按功能将代码分类，提高代码可读性
b. 方便后期代码维护
c. 提高代码复用性

IDEA涨知识：Ctrl + F12，打开类的大纲

6.2 方法定义格式：

6.2.1 方法定义格式：
无参方法定义格式：

修饰符 返回值类型 方法名(){
return 返回值；
}

带参方法定义格式：

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2){
return 返回值；
}

6.2.3 形参（形式参数）与实参（实际参数）

形参：定义方法时声明的参数
实参：调用时传入的实际参数

//形参
public static void prints(int num) { //此处的 num就是形参
     //方法体语句
 }
//main方法调用prints()方法时需要传实参
 public static void main(String[] args) {
          prints(5);        //此处5就是实际参数
 }

案例8— 方法定义

//1无参方法
    public static void prints() {
        System.out.println("*******************");
    }

//2带参方法
    //案例1 主方法：
        public static void main(String[] args) {
                //方法体语句
        }
    //案例2 自定义方法：
         public static int sum(int num1,int num2){
                int sum = num1+num2;
                return sum;//返回值
         }

6.3 自定义方法的位置：

方法与方法之间保持平级关系，方法不允许嵌套定义；

6.4 方法的调用与执行：

方法不调用不执行：
方法的执行顺序与编写顺序无关，只与调用顺序相关；

方法的调用方式1： 用类名直接调用，被static修饰的方法，属于类所有，可以直接用:类名.方法名(); 直接调

方法的调用方式2： 通通对象调用，对象名.方法名();

6.5 方法调用内存图解

6.6 java方法的值传递与址传递

问题：在java中方法传参到底是值传递还是址传递？
答：java参数传递问题需要分情况讨论：

• 传递的参数为基本类型，则是值传递；
• 传参为引用类型参数，就是址传递；

1. 基本数据类型

案例1：【问：num1的值会不会变？ 答：不会】

public static void main(String[] args) {
        int num1 = 100; //定义变量num1
        test1(num1);    //把num1，作为参数传给test1方法
        System.out.println(num1);
    }
    public static int test1(int num1){
        return num1 = 200; //在test1方法中，给num1重新赋值
    }

基本数据类型作为参数的内存图解：

2. 引用类型数据

案例1：【问：num1的值会不会变？ 答：会】

public static void main(String[] args) {
        int [] num1 = {10,11}; //定义数组num1
        test1(num1);    //把num1地址，作为参数传给test1方法
        System.out.println(num1[0]);
    }
    public static int test1(int [] num1){
        return num1[0] = 200; //在test1方法中，给num1[0]重新赋值
    }

引用类型数据作为参数的内存图解：

案例9— 定义方法做输出

public static void prints(int freq) {
        if(freq<0 ){
            System.out.println("输入次数有误，请重新输入：");
        }else {
            for (int i = 0; i < freq; i++) {
                System.out.println("学好编程！");
            }
        }
    }

7 初识面向对象

面向对象是java语言的一大特征，也是java学习分水岭，理解掌握好这块基础对后期学习而言非常必要

7.1 类与对象

7.1.1. 类是什么？
答：类是把一类事物的属性，行为抽象成一个java文件，用文件来表现这类事物，那么这个文件就是一个类；
7.1.2. 对象是什么？
答：对象是类的一个具象，比如：通过一个描述所有人特征的类，可以具象出某一个具体的人如张三；通过人类产生的这个张三，就是人类的一个对象；
7.1.3. 类的特征
a. 类包含成员变量和成员方法
定义在类中的变量：叫成员变量
定义在方法中的变量：叫局部变量

7.1.4. 类的定义
定义格式：

修饰符 class 类名{
成员变量；
成员方法；
}

案例9 ----定义学生类

public class Students {
   int age;         //学生类成员变量age
   String name;     //学生类成员变量name
   void speak(){    //学生类成员方法speak
       System.out.println("大家好！我是"+name+"今年"+age+"岁");
   }
}

【注意：】类定义时，class前的public有什么用?
答：public修饰的类有最大权限，大家都可以访问，程序的主类必须用public修饰；被public修饰的类，类名与文件名必须保持一致，否则报错；

7.1.5. 对象的创建和使用
对象的创建格式：

类名 对象名 = new 类名();

案例10—根据案例9创建学生对象张三

public static void main(String[] args) {
        Students zhangsan = new Students();     //创建学生对象张三
        zhangsan.age = 18;                                  //用对象为成员方法赋值
        zhangsan.name = "张三";                           
        zhangsan.speak();                                       //用对象调用成员方法
    }

7.2 构造方法

构造方法又叫构造器

是在构建、创造对象的时候调用的方法，（没有构造方法不能创建对象）
注意：【一个类中如果没有手动写构造方法，系统会默认提供一个无参构造方法】

7.2.1. 构造方法格式

• 构造方法名 与类名相同
• 没有返回值类型，连void也没有
• 没有具体返回值，不能使用return带回结果

注意：【在构造方法中“return;”是可以存在的，this代表当前类对象的地址，谁调用代表谁】

案例1-构造方法格式

class Students{      //创建Students类
    String name;  //成员变量name
    int age;      //成员变量age
    //无参构造方法
    Students(){}
    //带参构造方法
    Students(int age,String name){ 
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.2. 构造方法的作用

2.1 本质作用是用于创建对象
2.2 可以在创建对象的时候，直接给成员变量赋值

案例2–通过构造方法为成员变量赋值

public class ThisDemo {
    public static void main(String[] args) {
        Students stu1 = new Students(18,"小明"); //创建对象stu1,并传参
    }
}
class Students{
    String name;  //成员变量
    int age;      //成员变量
    Students(int age,String name){ //构造方法
        this.age = age;   //通过局部变量为成员变量age赋值
        this.name = name; //通过局部变量为成员变量name赋值
    }
}

7.2.3. 构造方法内存解析（案例2解析）

注意：【字节码文件不调用不加载】

7.3 java面向对象的特征

话说java万物皆对象，怎么理解呢？
答：生活中的所有事务我们都可以进行归类，归类后就能找出共性，共同属性，共同行为等等那么就可以将事物抽象成类；一个类可以创建无数对象，这样就便于开，发节省开发成本。也就是万物皆对象。
7.3.1 java的封装
什么是封装？

答：大概可以这么理解，就好比公开且无人管的器材室，所有人都可以随意出入，里面篮球🏀、足球⚽、羽毛球🏸等等器材大家都可以自由使用想怎么用就怎么用。封装就是现在来了一个管理员器材室不能随意出入了，你要东西可以，但是不能让你自己随意拿了，得经过管理员之手。(这段纯属我自己理解的，有问题欢迎在评论区指正)

a. 此处公开就对应权限修饰：public，被public修饰的属性用最大权限，可以被任意class调用；
b. 不公开就对应：private，被private修饰的属性只能在本类内部使用，外部无法直接访问，但是可以通过类提供的public修饰的方法间接访问。

为什么要封装？封装有什么好处？

1. 外部不能直接访问、提高代码的安全性，可控性更方便管理；
2. 降低程序复杂度。

案例11—学生类的封装案例

public class Studens {
    private int age;        //定义成员变量 age并私有
    private String naem;    //定义成员变量 name并私有

    public Studens() {      //无参构造
    }

    public Studens(int age, String naem) {  //带参构造
        this.age = age;
        this.naem = naem;
    }

    public void speak(){
        System.out.println("讲中国话");     // 成员方法
    }

    public int getAge() {                  //为外部提供变量访问的方法getXxx方法
        return age;
    }

    public void setAge(int age) {           //为外部提供变量访问的方法setXxx方法
        this.age = age;
    }

    public String getNaem() {               //为外部提供变量访问的方法getXxx方法
        return naem;
    }

    public void setNaem(String naem) {      //为外部提供变量访问的方法setXxx方法
        this.naem = naem;
    }
}

继承、多态java进阶补充；
7.3.2 java的继承

7.3.3 java的多态

8 初识javaAPI

javaAPI（Application Programming Interface）应用程序编程接口

8.1JavaAPI帮助文档的使用方法

什么是API？
答：API本质就是java为开发者提供的工具类，这些类功能强大，为开发工作提供得力助手。
如何学习API?
答：需要阅读官方提供的API开发文档；
阅读步骤：

1. 打开开发文档，在导航栏选择索引选项，输入自己想要查询的类名：

2. 查看类是不是在java.lang包下，如果是则使用是不需要导包，不是则要导包；

3. 接着看类的介绍，可以做什么；
4. 看构造方法，因为构造方法是我们创建对象时候必须用的，根据构造方法创建对象；
5. 看成员方法；

8.2 String类的介绍

• 在java中所有被“”包裹的内容都是String类的对象；
• 字符串一旦被创建，则值就不会发生改变；
• 字符串常量池：
  JDK8之前常量池在方法区
  JDK8以后被迁移到堆内存

案例12----字符串常量池面试题

回答问题并说明原因：

public static void main(String[] args) {
        boolean flag;
        //第一题
        String str1 = "hello";
        String str2 = new String("hello");

        flag = str1 == str2 ;
        System.out.println("第一题，输出为true还是false？："+flag);

        //第二题
        String str3 = "hello";
        flag = str1 == str3;
        System.out.println("第二题，输出为true还是false？："+flag);
    }

解析：①此处涉及到字符串常量池知识，在用“”直接创建字符串对象时，首先会到字符串常量池中查找是否有该字符串，如果有直接从常量池中把地址拿给字符串常量，如果没有则往常量池中添加新元素。

②用new方法创建字符串对象时，在栈内存开辟变量空间后，再到堆内存new出一块新空间，此时拿参数字符串对象去常量池中复制一份赋值给new出来的空间，再将空间地址赋给字符串变量；

• String类的常见方法

案例13—自定义方法统计指定字符在本字符串中出现的次数

public static int countChar(String String, char cha) {
        int count = 0;                          
        char []arr = String.toCharArray();      //使用String类的toCharArray方法将字符串转为字符数组
        for (int i = 0; i < arr.length; i++) {  //for循环遍历数组
            if (cha == arr[i]){                 //if语句对比字符，用count统计
                count ++;
            }
        }
        return count;                           //返回统计数
    }

8.3 Random类

规则简单记：【包左不包右】

案例14—java小游戏【猜数字】

public static void numGame() {
        int count = 3;                                    //控制循环次数
        Random r = new Random();
        int num = r.nextInt(100)+91;               //生成0---100的随机数
                Scanner sc = new Scanner(System.in);
        while (count > 0){                               //循环控制输入次数
            System.out.println("请输入1--100的随机数值：");
            int numb = sc.nextInt();
            if (num==numb) {
                System.out.println("恭喜您猜对啦！");
                break;
            }else if (numb<num){
                System.out.println("您猜的数偏小，您还有"+(count-1)+"次机会！");
                count --;
            }else {
                System.out.println("您猜的数偏大，您还有"+(count-1)+"次机会！");
                count --;
            }
        }
    }

9 初识集合

9.1 ArryList集合

• ArrayList构造方1

• public ArrayList();

• 泛型：<>

• 在类名之后加<>,可以使集合存储的数据类型，进行类型限制；
• 尖括号中只能使用引用数据类型，不能是基本数据类型

解决方案：【基本类型都有对应包装类】

1 ArrayList的常用成员方法

• 增

• public boolean add(E e);向集合尾部添加数据，返回添加成功的状态
• public void add(int index,E element);插队添加

 ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素

• 删

• public E remove(int index);根据索引删除集合中的元素
• public boolean remove(元素);根据元素删除集合中的内容，重复元素只删除第一个；返回添加成功的状态

 ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                    //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.remove("张三");                //根据元素删除
        list1.remove(2);                    //根据索引值删除元素

• 改

• public E set(int index,E element);修改指定索引位置，返回被覆盖的元素

ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                   //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");  
        list1.set(2,"年薪百万");             //修改集合数据

• 查

• public E get(int index);根据索引，获取集合中的元素

      ArrayList<String> list1 = new ArrayList<>();//创建集合
        list1.add("张三");                        //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        list1.get(2);                           //查找集合元素

案例15 ----ArrayList初使用

创建一个存储字符串集合，存储5个字符串元素，找出4个字的人名，并打印

public static void main(String[] args) {
        ArrayList<String> list1 = new ArrayList<>();//创建list集合
        list1.add("张三");                           //添加元素
        list1.add("王五");
        list1.add("上官铁蛋");
        list1.add("张三");
        list1.add("诸葛订单");
        for (int i = 0; i < list1.size(); i++) {    //遍历集合
            String name = list1.get(i);             //获取集合元素
            if (list1.get(i).length()==4){          //判断字符串长度是否为4
                System.out.println(name);           //打印4个字的名字
            }
        }
    }

学生管理系统实现