java从零开始系统性学习完整超全资源+笔记(还在更新中）

前言

资源来自：王汉远java基础，
B站视频： https://www.bilibili.com/video/BV1b4411g7bj/?spm_id_from=333.1007.top_right_bar_window_custom_collection.content.click&vd_source=33eb2731cb742522d03acd26e5b17ba3
网盘链接（含源代码和笔记资料PPT）：1,java基础学习：
链接：https://pan.baidu.com/s/1lxrpAW6yAxzSouYQz-GaKg
提取码：anr4
课件：
链接：https://pan.baidu.com/s/1zV-4jtSKHzkmS4c6wp7Qag
提取码：cgw6
下半部分
链接：https://pan.baidu.com/s/15xOnqGo-CQelWyk4naVsJQ
提取码：sk57
之前学的java忘记差不多了，最近得好好再学一遍，计划三周学完，特写此笔记便于后期做毕设项目和工作使用。
学习开始日期：2022.11.2
学习截止日期：进行中
**注意：**视频是基于eclipse进行编写的，最好还是用IDEA，eclipse老旧了，但是基本知识点还是不变的，等下学完这些视频，和IEDA里面有不同的地方再进行对比补充笔记。
IDEA版本：链接：https://pan.baidu.com/s/1znJc2zSpj84cvB6DGQ5NAw
提取码：pj3r

文章目录

java从零开始系统性学习完整超全资源+笔记(还在更新中）
- 前言
- 一、变量与数据类型
- - Java语言概述
  - 常用DOS命令
  - HelloWorld案例
  - 注释
  - 关键字
  - 常量
  - 变量
  - 数据类型
  - 标示符
  - 命名规则
- 二、Eclipse/IDEA基本使用与配置
- - **1:基本使用**
  - **2:基本配置**
  - 3:删除和导入项目
  - 4.快捷键汇总
  - 5.Debug
- 三、运算符和表达式
- - 运算符
  - 键盘录入
- 四、条件判断与循环语句
- - 选择结构
  - 循环结构
  - 随机数
- 五、数组
- - 一维数组&内存图解
  - 二维数组
- 六、方法
- - 方法定义及格式
  - 形参和实参
  - 方法重载
- 上半部分基础语法系统练习
- - 1. 键盘录入月份，输出对应的季节(键盘录入+循环）
  - 2.打印5位数中所有的回文数 (for+if训练）
  - 3. 不死神兔问题
  - 4. 求数组中满足要求的元素和
  - 5. 裁判评分
  - 6. 数组反转
  - 7. 数组基本查找
  - 8. 数据加密
- 七、面向对象基础
- - 1.面向对象思想概述及举例
  - 2.类与对象及其使用
  - 3.对象内存存储机制
  - 4.成员变量和局部变量的区别
  - - - private关键字
  - 5.封装(private)
  - 6.this关键字
  - 7.构造方法
  - 8.标准类的代码写法和测试
  - 9.类名作为形式参数和返回值
- 八、java常用API
- - API概述
  - String
  - StringBuilder
- 九、java集合
- - 1.对象数组的案例
  - 2. ArrayList类的构造方法和成员方法
  - 3. ArrayList类案例
  - 4.学生管理系统

一、变量与数据类型

Java语言概述

1. java语言的跨平台原理

平台:指的是操作系统(Windows，Linux， Mac)
跨平台: Java程序可以在任意操作系统上运行，一次编写到处运行
原理:实现跨平台需要依赖Java的虚拟机JVM ( Java Virtual Machine）

2.JRE和JDK
JRE：java的运行环境
JDK：java的开发工具包

联系：使用JDK开发完成java程序，交给JRE去运行。

常用DOS命令

1. 打开控制台
win+ R，然后cmd回车；或者开始-搜索-输入cmd-回车。
常见DOS命令

d:回车盘符切换
dir(directory):列出当前目录下的文件以及文件夹
cd (change directory)改变指定目录(进入指定目录)
进入cd目录; cd 目录名称，或者目录路径
同上图
回退cd…; cd
cls: (clear screen)清屏- exit:退出dos命令行

HelloWorld案例

1.Notepad++的使用
下载安装之后新建文件，点击上方的设置按钮——选择首选项——新建——格式：windows——语言：java——编码：ANSI。

2.HelloWorld案例编写

首先定义一个类
public class 类名
在类定义后加上一对大括号{}
在大括号中间添加一个主(main)方法/函数
public static void main(String [] args){ }
在主方法的大括号中间添加一行输出语句
System.out.println(“HelloWorld”);
完整代码：

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

单词拼写注意问题：

注释

●注释概述
-用于解释说明程序的文字
●Java中注释分类
-单行注释
●格式: //注释文字
-多行注释
●格式:/注释文字/
-文档注释
●格式: /*注释文字/
●注释的作用
-解释说明程序，提高程序的阅读性

关键字

关键字概述
被Java语言赋予特定含义的单词
关键字特点
-组成关键字的字母全部小写
-常用的代码编辑器，针对关键字有特殊的颜色标记，非常直观，所以我们不需要去死记硬背，在今后的学习中重要的关键字也会不断的出来。

常量

常量概述:
在程序执行的过程中，其值不可以发生改变的量
常量分类
-字符串常量
用双引号括起来的内容(“HelloWorld”)
-整数常量
所有整数(12,-23)
-小数常量
所有小数(12.34)
-字符常量.
用单引号括起来的内容(a,‘A’,‘0’)
-布尔常量.
较为特有，只有true和false
空常量
null(数组部分讲解)

public class HelloWorld{public final static String CONSTANT = "HelloWorld";public final static float PI = 3.14f;/*主方法*/public static void main(String[] args){System.out.println(CONSTANT);}

变量

变量概述
- 在程序执行的过程中，在某个范围内其值可以发生改变的量
- 从本质上讲，变量其实是内存中的一小块区域
变量定义格式
- 数据类型变量名=初始化值;
- 注意:格式是固定的，记住格式，以不变应万变
计算机存储单元
变量是内存中的小容器，用来存储数据。那么计算机内存是怎么存储数据的呢？无论是内存还是硬盘，计算机存储设备的最小信息单元叫“位（bit）”，我们又称之为“比特位”，通常用小写的字母b表示。而计算机最小的存储单元叫“字节（byte）”，通常用大写字母B表示，字节是由连续的8个位组成。
除了字节外还有一些常用的存储单位，大家可能比较熟悉，我们一起来看看：
1B（字节） = 8bit
1KB = 1024B
1MB = 1024KB
1GB = 1024MB
1TB = 1024GB

数据类型

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的内存空间，所以它们表示的数据大小也是不一样的。

基本数据类型（4类8种）

标示符

作用
给包,类,方法,变量等起名字
组成规则
由字符，下划线_，美元符$组成
这里的字符采用的是unicode字符集，所以包括英文大小写字母，中文字符，数字字符等。
注意事项
- 不能以数字开头
- 不能是Java中的关键字

命名规则

基本要求
见名知意
常见命名的规则
包 (其实就是文件夹,用于对类进行管理)
全部小写，多级包用点隔开。
com,cn,com.demo
命名必须全部使用英文小写字母，禁止使用“下划线”等字符。(除常量外，Java命名习惯中均不推荐使用下划线等字符)
项目包命名规则: …相关项目可使用…的命名法则。
类
- 一个单词首字母大写 Student,Car
- 多个单词，每个单词首字母大写 HelloWorld
- 如果 Java 程序源代码里定义了一个 public 类，则该源文件的主文件名必须与该 public 类（也就是该类定义使用了 public 关键字修饰）的类名相同。
- 如果 Java 程序源代码里没有定义任何 public 类，那么 Java 程序源程序的主文件名可以是任意的。
- 一个 Java 源文件只定义一个类，不同的类使用不同的源文件定义。
- Class/Qbiect. terface
  类和接口使用大驼峰命名法抽象类使用“ Abstract"做为类命名的开头Exception类命名使用“Exception” 做为类命名的结尾
  Test类使用"Test" 做为类命名的结尾。
变量或者方法
- 一个单词首字母小写。 age,show()
- 多个单词，从第二个单词开始每个单词首字母大写 maxAge,getAge()

变量的定义和使用

变量定义的注意事项

变量未赋值,不能直接使用
引出变量的第二种使用格式
变量只在它所属的范围内有效。
变量在哪对大括号内，变量就属于哪对大括号
一行上可以定义多个变量，但是不建议

类型转换

+是一个运算符, 我们应该能够看懂，做数据的加法。
boolean类型不能转换为其他的数据类型
默认转换
byte,short,char—int—long—float—double
byte,short,char相互之间不转换，他们参与运算首先转换为int类型
强制转换
目标类型变量名=(目标类型)(被转换的数据);

二、Eclipse/IDEA基本使用与配置

1:基本使用

A:创建Java项目：点击File或者在最左侧空白处，选择Java项目，在界面中写一个项目名称，然后Finish即可。
B:创建包：展开项目，在源包src下建立一个包com.itheima
C:创建类：在com.ithiema包下建立一个类HelloWorld在界面中写一个类名：HelloWorld，然后finish即可。
D:编写代码在HelloWorld类写main方法，在main方法中写一条输出语句：我是程序员，我骄傲，我自豪。
E:编译自动编译，在保存的那一刻帮你做好了
F:运行选择要运行的文件或者在要运行的文件内容中右键 -- Run as - Java Application即可

2:基本配置

A:行号的显示和隐藏显示：在代码区域的最左边的空白区域，右键 -- Show Line Numbers即可。隐藏：把上面的动作再做一次。B:字体大小及颜色a:Java代码区域的字体大小和颜色：window -- Preferences -- General -- Appearance -- Colors And Fonts -- Java -- Java Edit Text Fontb:控制台window -- Preferences -- General -- Appearance -- Colors And Fonts -- Debug -- Console fontc:其他文件window -- Preferences -- General -- Appearance -- Colors And Fonts -- Basic -- Text FontC:窗体给弄乱了，怎么办?window -- Perspective -- Reset PerspectiveD:控制台找不到了，怎么办?Window--Show View—Console

3:删除和导入项目

A:删除项目选中项目 – 右键 – 删除从项目区域中删除从硬盘上删除
B:导入项目在项目区域右键找到import找到General，展开，并找到Existing Projects into Workspace点击next,然后选择你要导入的项目注意：这里选择的是项目名称

创建eclipse程序如图

4.快捷键汇总

自己常用的
注释：Ctrl+/ | Ctrl+Shift+/ 前者将当前行注释掉（行首加上//），后者将当前选中的内容注释掉（两端打上/* … */）
内容辅助：Alt + / 自动写代码，类似代码提示。
方法定位：按住Ctr1+鼠标左键，可以快速定位到对应的变量、方法或者其他的类等。
格式化：ctrl+shift+F
或者设置保存（ctrl+S）的时候格式化
导包： CTRL + SHIFT + O
查找替换：CTRL+F
get set方法：Alt+Insert （有的电脑没有insert,按键盘上的【fn】+【f12】,那么此时即可在笔记本输入insert。）
格式化
生成get,set方法

idea：右击点击Generate or 也可以用快捷键Alt+Insert

注释多行代码：ctrl+shift+/
有用的快键键整理
来自：Eclipse快捷键大全

编辑
Ctrl+1 快速修复（最经典的快捷键,就不用多说了，可以解决很多问题，比如import类、try catch包围等）
Ctrl+Shift+F 格式化当前代码
Ctrl+Shift+M 添加类的import导入
Ctrl+Shift+O 组织类的import导入（既有Ctrl+Shift+M的作用，又可以帮你去除没用的导入，很有用）
Ctrl+Y 重做（与撤销Ctrl+Z相反）
==Alt+/ 内容辅助（帮你省了多少次键盘敲打，太常用了） ==
Ctrl+D 删除当前行或者多行
==Alt+↓ 当前行和下面一行交互位置（特别实用,可以省去先剪切,再粘贴了） ==
Alt+↑ 当前行和上面一行交互位置（同上）
Ctrl+Alt+↓ 复制当前行到下一行（复制增加）
Ctrl+Alt+↑ 复制当前行到上一行（复制增加）
Shift+Enter 在当前行的下一行插入空行（这时鼠标可以在当前行的任一位置,不一定是最后）
Ctrl+/ 注释当前行,再按则取消注释
选择
Alt+Shift+↑ 选择封装元素
Alt+Shift+← 选择上一个元素
Alt+Shift+→ 选择下一个元素
Shift+← 从光标处开始往左选择字符
Shift+→ 从光标处开始往右选择字符
Ctrl+Shift+← 选中光标左边的单词
Ctrl+Shift+→ 选中光标又边的单词
移动
Ctrl+← 光标移到左边单词的开头，相当于vim的b
Ctrl+→ 光标移到右边单词的末尾，相当于vim的e
搜索
Ctrl+K 参照选中的Word快速定位到下一个（如果没有选中word，则搜索上一次使用搜索的word）
Ctrl+Shift+K 参照选中的Word快速定位到上一个
Ctrl+J 正向增量查找（按下Ctrl+J后,你所输入的每个字母编辑器都提供快速匹配定位到某个单词,如果没有,则在状态栏中显示没有找到了,查一个单词时,特别实用,要退出这个模式，按escape建）
Ctrl+Shift+J 反向增量查找（和上条相同,只不过是从后往前查）
Ctrl+Shift+U 列出所有包含字符串的行
Ctrl+H 打开搜索对话框
Ctrl+G 工作区中的声明
Ctrl+Shift+G 工作区中的引用
导航
Ctrl+Shift+T 搜索类（包括工程和关联的第三jar包）
Ctrl+Shift+R 搜索工程中的文件
Ctrl+E 快速显示当前Editer的下拉列表（如果当前页面没有显示的用黑体表示）
F4 打开类型层次结构
F3 跳转到声明处
Alt+← 前一个编辑的页面
Alt+→ 下一个编辑的页面（当然是针对上面那条来说了）
Ctrl+PageUp/PageDown 在编辑器中，切换已经打开的文件
调试
F5 单步跳入
F6 单步跳过
F7 单步返回
F8 继续
Ctrl+Shift+D 显示变量的值
Ctrl+Shift+B 在当前行设置或者去掉断点
Ctrl+R 运行至行(超好用，可以节省好多的断点)
重构
（一般重构的快捷键都是Alt+Shift开头的了）
Alt+Shift+R 重命名方法名、属性或者变量名（是我自己最爱用的一个了,尤其是变量和类的Rename,比手工方法能节省很多劳动力）
Alt+Shift+M 把一段函数内的代码抽取成方法（这是重构里面最常用的方法之一了,尤其是对一大堆泥团代码有用）
Alt+Shift+C 修改函数结构（比较实用,有N个函数调用了这个方法,修改一次搞定）
Alt+Shift+L 抽取本地变量（可以直接把一些魔法数字和字符串抽取成一个变量,尤其是多处调用的时候）
Alt+Shift+F 把Class中的local变量变为field变量（比较实用的功能）
Alt+Shift+I 合并变量（可能这样说有点不妥Inline）
Alt+Shift+V 移动函数和变量（不怎么常用）
Alt+Shift+Z 重构的后悔药（Undo）
其他
Alt+Enter 显示当前选择资源的属性，windows下的查看文件的属性就是这个快捷键，通常用来查看文件在windows中的实际路径
Ctrl+↑ 文本编辑器上滚行
Ctrl+↓ 文本编辑器下滚行
Ctrl+M 最大化当前的Edit或View （再按则反之）
Ctrl+O 快速显示 OutLine（不开Outline窗口的同学，这个快捷键是必不可少的）
Ctrl+T 快速显示当前类的继承结构
Ctrl+W 关闭当前Editer（windows下关闭打开的对话框也是这个，还有qq、旺旺、浏览器等都是）
Ctrl+L 文本编辑器转至行
F2 显示工具提示描述
idea与eclipse快捷键对比
参考文章：IDEA和Eclipse的比较

IDEA快捷键汇总：
1.idea下设置main快捷键自动输出 public static void main(String args[]){}方法
参考：idea下设置main快捷键自动输出 public static void main(String args[]){}方法

5.Debug

1.双击侧边栏，打断点；
2.点击运行debug as；
取消断点：
参考：eclipse如何取消断点

方法一：
1.适合于在debug界面，更快速。也可以是在编辑界面切换到debug界面。2、成功进入debug界面之后，从右上角找到breakpoint选项（三个选项中的中间一个）。3、会看到一排图标，一个X号的表示取消选择的debug断点，两个X号的是取消所有断点。选择两个X号的，点击。4、弹出来的对话框，点击yes，就可以取消所有的断点了。
方法二：
在javaee等编辑界面，直接使用run–>removebreakpoint。就可以取消所有的断点。

三、运算符和表达式

运算符

代码

package com.yunSuanFu;public class YunSuanFu {/*** Alt + / 自动写代码，类似代码提示*/public static void main(String[] args) {// TODO Auto-generated method stub//加法int c = add(1,2);System.out.println(c);//减法float d = substract(3, 2);System.out.println(d);//乘法YunSuanFu yunsuanfu = new YunSuanFu();   //不能将静态的方法写在非静态的方法中
//      非静态的变量(动态的类）就要新建一个对象int e = yunsuanfu.multiply(5, 6);System.out.println(e);//除法float f = yunsuanfu.divide(33.3f, 3.0f);System.out.println(f);int h = yunsuanfu.divide(10, 5);System.out.println("整数的除法" + h);//取余long g = yunsuanfu.mod(10, 3);System.out.println(g);         }/** 文档注释  * 两个整数相加* @param a* @param b* return */public static int add(int a,int b) {int c = a + b;return c;}/** 减法*/public static float substract(float a,float b) {float c = a - b;return c;}/**  乘法*/public int multiply(int a,int b) {int c = a * b;return c;}/** 除法*/public float divide(float a,float b) {return a/b;}public int divide(int a,int b) {return a/b;}/** 取余*/public long mod(long a,long b) {return a % b;        }
}

运算符

对常量和变量进行操作的符号称为运算符
表达式
用运算符把常量或者变量连接起来符合java语法的式子就可以称为表达式。不同运算符连接的式子体现的是不同类型的表达式。
定义两个int类型的变量a,b，做加法(a+ b)
常用运算符
算术运算符
赋值运算符
关系运算符
逻辑运算符
三元运算符

算术运算符
• +,-,*,/的基本使用
%的使用
– %和/的区别
• ++,–
自增自减

字符和字符串参与+运算

int i = 10;int j = 5;System.out.println(++i);    //++放在前面的时候先加1再做其他运算System.out.println(j++);    //++放在后面的时候先调用它的值再加1System.out.println(j);

输出结果：

11
5
6

• 字符参与运算
– 其实是拿该字符对应的数值来操作
– ‘a’ 97
– ‘A’ 65
– ‘0’ 48

• 字符串参与运算
– 这里其实做的不是加法运算，而是字符串拼接。
– 字符串和其他类型的数据做拼接，结果是字符串类型的。

赋值运算符
• 基本的赋值运算符： =
• 扩展的赋值运算符：+=,-=,*=,/=,…
关系运算符
• ==,!=,>,>=,<,<=
• 关系运算符的结果都是boolean型，也就是要么是true，要么是false。
• 注意事项
– 关系运算符“ ==”不能误写成“=” 。

-逻辑运算符
• 逻辑运算符用于连接布尔型表达式，在Java中不
可以写成3<x<6，应该写成x>3 && x<6 。
• &,|,^,!
• &&,||
– “&”和“&&”的区别：
• 单&时，左边无论真假，右边都进行运算；
• 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
• “|”和“||”的区别同理，双或时，左边为真，右边不参与运算。第一个左边为假判断右边第二个。

三元运算符
• 格式
– (关系表达式)?表达式1：表达式2；
– 如果条件为true，运算后的结果是表达式1；
– 如果条件为false，运算后的结果是表达式2；
• 示例：
– 获取两个数中大数。
– int x=3,y=4,z;
– z = (x>y)?x:y;//z变量存储的就是两个数的大数。

键盘录入

键盘录入数据概述
我们目前在写程序的时候，数据值都是固定的，但是实际开发中，数据值肯定是变化的，所以，把数据改进为键盘录入，提高程序的灵活性。
如何实现键盘录入数据呢?(目前先记住使用)

导包(位置放到class定义的上面)
import java.util.Scanner;
创建对象
Scanner sc = new Scanner(System.in);
接收数据
int x = sc.nextInt();

核心步骤：

//0.导入包
import java.util.Scanner;
// 1.创建键盘录入的对象Scanner sc = new Scanner(System.in);// 2.接收数据System.out.println("请输入第一个数据:");int a = sc.nextInt();System.out.println("请输入第二个数据:");int b = sc.nextInt();

练习：
键盘录入两个数据，并对这两个数据求和，输出其结果
键盘录入两个数据，获取这两个数据中的最大值
键盘录入两个数据，比较这两个数据是否相等
键盘录入三个数据，获取这三个数据中的最大值

代码：

package com.demo;import java.util.Scanner;/*** 引入包 CTRL + SHIFT + O*/public class ScannerDemo {public static void main(String[] args) {// 1.创建键盘录入的对象Scanner sc = new Scanner(System.in);// 2.接收数据System.out.println("请输入第一个数据:");int a = sc.nextInt();System.out.println("请输入第二个数据:");int b = sc.nextInt();// 对数据进行求和int sum = a + b;System.out.println("sum = " + sum);// 三元组运算符判断两个数是否相等boolean flag = ((a == b) ? true : false);System.out.println("flag:" + flag);System.out.println("请输入第三个数据:");int c = sc.nextInt();int temp = ((a > b) ? a : b);int max = ((temp > c) ? temp : c);System.out.println("max: " + max);}
}

四、条件判断与循环语句

选择结构

if
if语句有三种格式
if语句第一种格式：

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

执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体

if语句第二种格式：

if(关系表达式) {语句体1;}else {语句体2;}

执行流程
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体1
如果是false就执行语句体2

if语句第三种格式：

if(关系表达式1) {语句体1;}else  if (关系表达式2) {语句体2;}…else {语句体n+1;}

switch
switch语句格式：

switch(表达式) {case 值1：语句体1;break;case 值2：语句体2;break;…default：    语句体n+1;break;}

格式解释
switch表示这是switch语句
表达式的取值：byte,short,int,char
JDK5以后可以是枚举
JDK7以后可以是String
case后面跟的是要和表达式进行比较的值
语句体部分可以是一条或多条语句
break表示中断，结束的意思，可以结束switch语句
default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似。

循环结构

for
for循环语句格式：

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

执行流程
A:执行初始化语句
B:执行判断条件语句，看其结果是true还是false
如果是false，循环结束。
如果是true，继续执行。
C:执行循环体语句
D:执行控制条件语句
E:回到B继续

while
while循环语句格式：

基本格式while(判断条件语句) {循环体语句;}
改版格式初始化语句;while(判断条件语句) {循环体语句;控制条件语句;}

do … while
do…while循环语句格式：
基本格式

 do {循环体语句;}while((判断条件语句);
改版格式初始化语句;do {循环体语句;控制条件语句;} while((判断条件语句);

for while do…while对比
虽然可以完成同样的功能，但是还是有小区别：
do…while循环至少会执行一次循环体。
for循环和while循环只有在条件成立的时候才会去执行循环体
for循环语句和while循环语句的小区别：
使用区别：控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消失，能够提高内存的使用效率。
continue 与 break
- continue的使用场景：
  在循环语句中
  离开使用场景的存在是没有意义的
  continue的作用：
  单层循环对比break，然后总结两个的区别
  break 退出当前循环
  continue 退出本次循环
- break的使用场景：
  在选择结构switch语句中
  在循环语句中
  离开使用场景的存在是没有意义的
  break的作用：
  跳出单层循环

随机数

作用：
用于产生一个随机数
使用步骤(和Scanner类似)

导包
import java.util.Random;
创建对象
Random r = new Random();
获取随机数
int number = r.nextInt(10);
//10表示随机数的范围0-10

产生的数据在0到10之间，包括0，不包括10。

Random r = new Random();
int number = r.nextInt(10);

如何获取一个1-100之间的随机数呢?

Random r = new Random();
int number = r.nextInt(10) + 1;   //在结果出加1，随机数是默认范围从0开始。

综合练习
猜数字小游戏案例
系统产生一个1-100之间的随机数，请猜出这个数据是多少。
分析：
A:系统产生一个1-100之间的随机数
Random r = new Random();
int number = r.nextInt(100) + 1;
B:键盘录入我们要猜的数据
C:比较这两个数据,用if语句实现
大了：提示大了
小了：提示小了
猜中了：提示恭喜你,猜中了
D:多次猜数据,而我们不知道猜多少次,怎么办呢?
==while(true) {循环体语句;}==表示一直运行。

public class RandomTest {public static void main(String[] args) {//系统产生一个1-100之间的随机数Random r = new Random();//获取随机数int number = r.nextInt(100) + 1;//多次猜数据while(true) {   //while(true)表示一直运行//键盘录入我们要猜的数据Scanner sc = new Scanner(System.in);//接收数据System.out.println("请输入你要猜的数据(1-100)：");int guessNumber = sc.nextInt();//比较这两个数据,用if语句实现if(guessNumber > number) {System.out.println("你猜的数据"+guessNumber+"大了");}else if(guessNumber < number) {System.out.println("你猜的数据"+guessNumber+"小了");}else {System.out.println("恭喜你,猜中了");break;    //跳出循环}}}
}

五、数组

一维数组&内存图解

数组的概念
- 定义格式

格式1：数据类型[] 数组名;
格式2：数据类型 数组名[];
注意：这两种定义做完了，数组中是没有元素值的。

数组初始化概述：
Java中的数组必须先初始化,然后才能使用。
所谓初始化：就是为数组中的数组元素分配内存空间，并为每个数组元素赋值。
数组的初始化方式：
动态初始化：初始化时只指定数组长度，由系统为数组分配初始值。

格式：数据类型[] 数组名 = new 数据类型[数组长度];
数组长度其实就是数组中元素的个数。
举例：
int[] arr = new int[3];
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。

静态初始化：初始化时指定每个数组元素的初始值，由系统决定数组长度。
格式：
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
举例：
int[] arr = new int[]{1,2,3};
解释：定义了一个int类型的数组，这个数组中可以存放3个int类型的值，并且值分别是1,2,3。
其实这种写法还有一个简化的写法
int[] arr = {1,2,3};

java中的内存分配：
Java 程序在运行时，需要在内存中分配空间。为了提高运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。
栈存储局部变量
堆存储new出来的东西
方法区 (面向对象进阶讲)
本地方法区 (和系统相关)
寄存器 (给CPU使用)

数组操作的两个常见小问题
1.数组索引越界
ArrayIndexOutOfBoundsException
访问到了数组中的不存在的索引时发生。
2.空指针异常
NullPointerException
数组引用没有指向对象，却在操作对象中的元素时。
内存图解1：
定义一个数组，输出数组名及元素。然后给数组中的元素赋值，再次输出数组名及元素。
内存图解2：
定义两个数组，分别输出数组名及元素。然后分别给数组中的元素赋值，分别再次输出数组名及元素。
内存图解3：
定义两个数组，先定义一个数组，赋值，输出。然后定义第二个数组的时候把第一个数组的地址赋值给第二个数组。然后给第二个数组赋值，再次输出两个数组的名及元素。
练习
一维数组遍历：

public class array {public static void main(String[] args) {//      int[] arr = new int[6];int[] arr = { 2, 4, 5, 6 };
//      int array[3] = {2,4,5,6};for (int i = 0; i <= 3; i++) {System.out.println(arr[i]);}}
}

获取数值长度：数值名.length
数组获取最值(获取数组中的最大值最小值)
先画图，然后讲解

二维数组

定义格式
数据类型[][] 数组名;
数据类型数组名[][]; 不推荐
数据类型[] 数组名[]; 不推荐
初始化方式
数据类型[][] 变量名 = new 数据类型[m][n];
数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}};
简化版格式：数据类型[][] 变量名 = {{元素…},{元素…},{元素…}};
二维数组遍历
int[][] arr = {{1,2,3},{4,5,6},{7,8,9}};

六、方法

方法定义及格式

简单的说：方法就是完成特定功能的代码块
在很多语言里面都有函数的定义
函数在Java中被称为方法
格式：
修饰符返回值类型方法名(参数类型参数名1，参数类型参数名2…) {
函数体;
return 返回值;
}
方法格式解释
修饰符目前记住 public static
返回值类型用于限定返回值的数据类型
方法名一个名字，为了方便我们调用方法
参数类型用于限定调用方法时传入的数据的类型
参数名用于接收调用方法时传入的数据的变量
方法体完成功能的代码
return 结束方法，把返回值带给调用者
方法案例
写一个方法首先有两点需要明确
返回值类型明确功能结果的数据类型
参数列表明确有几个参数，以及参数的类型
按照格式和两个明确来完成如下功能
求两个数据之和的案例

形参和实参

参考：java形参和实参
1.形参：形参定义在方法（函数）中，只有调用所对应的函数时才会分配给形参内存单元，调用结束后释放所分配的内存单元，因此形参只可以在定义的函数内部使用。

2.实参：实参可以是变量，常量，表达式等等。从刚开始定义便有内存单元，所分配的内存单元与是否调用无关。

例如

package com.demo03;
/** 方法重载：在同一个类中，出现了方法名相同的情况。* 方法重载的特点：*        方法名相同，参数列表不同。与返回值无关。*        参数列表不同：*             参数的个数不同*            参数对应的数据类型不同* * 注意：*      在调用方法的时候，java虚拟机会通过参数列表的不同来区分同名的方法。*/
public class MethodDemo {public static void main(String[] args) {float c = sum(1.2f,2.3f); //1.2f,2.3f实参System.out.println(c);}//不能出现方法名相同，并且参数列表也相同的情况
//  public static int sum(int x,int y) {    //x,y形参
//      return x + y;
//  }public static float sum(float a,float b) {return a + b;}//求三个数据的和/*public static int sum2(int a,int b,int c) {return a + b + c;}*/public static int sum(int a,int b,int c) {return a + b + c;}//求两个数据的和方法public static int sum(int a,int b) {//int c = a + b;//return c;return a + b;}
}

package com.demo04;/** 方法的参数如果是基本数据类型：形式参数的改变不影响实际参数。* * 形式参数：用于接收实际参数的变量* 实际参数：实际参与运算的变量*/
public class ArgsDemo {public static void main(String[] args) {int a = 10;int b = 20;System.out.println("a:"+a+",b:"+b);//a:10,b:20change(a,b);System.out.println("a:"+a+",b:"+b);//??? a:10,b:20}public static void change(int a,int b) {//a=10,b=20System.out.println("a:"+a+",b:"+b);//a:10,b:20a = b;//a=20b = a + b;//b=40System.out.println("a:"+a+",b:"+b);//a:20,b:40}}

package com.demo04;/** 如果参数是引用数据类型：*      形式参数的改变直接影响实际参数*/
public class ArgsDemo2 {public static void main(String[] args) {int[] arr = { 1, 2, 3, 4, 5 };for (int x = 0; x < arr.length; x++) {System.out. println(arr[x]);}System.out.println("-------------------------");change(arr);for (int x = 0; x < arr.length; x++) {System.out.println(arr[x]);}}public static void change(int[] arr) {for (int x = 0; x < arr.length; x++) {if (arr[x] % 2 == 0) {arr[x] *= 2;}}}}

有明确返回值的方法调用
单独调用，没有意义
输出调用，有意义，但是不够好，因为我不一定非要把结果输出
赋值调用，推荐方式
有明确返回值的方法练习
键盘录入两个数据，返回两个数中的较大值
键盘录入两个数据，比较两个数是否相等
键盘录入三个数据，返回三个数中的最大值
没有明确返回值的方法定义和调用
写一个方法，在控制台输出10次HelloWorld案例。
没有明确返回值的函数调用：
其实就是void类型方法的调用
只能单独调用
没有明确返回值的方法练习
写一个方法，传递一个整数(大于1)，在控制台打印1到该数据的值。
写一个方法，把所有的水仙花数打印在控制台

方法重载

方法重载概述
在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
方法重载特点
与返回值类型无关，只看方法名和参数列表
在调用时，虚拟机通过参数列表的不同来区分同名方法

方法重载练习
比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试

package com.demo03;
/** 比较两个数据是否相等。参数类型分别为两个byte类型，两个short类型，两个int类型，两个long类型，并在main方法中进行测试*/
public class MethodTest {public static void main(String[] args) {//System.out.println(compare(10, 20));//System.out.println(compare((byte)10, (byte)20));//System.out.println(compare((short)10, (short)20));System.out.println(compare(10L, 20L));}//bytepublic static boolean compare(byte a,byte b) {System.out.println("byte");return a == b;}//shortpublic static boolean compare(short a,short b) {System.out.println("short");return a == b;}//intpublic static boolean compare(int a,int b) {System.out.println("int");return a == b;}//longpublic static boolean compare(long a,long b) {System.out.println("long");return a == b;}
}

方法参数传递问题
看程序写结果，并总结基本类型和引用类型参数的传递问题(代码在备注部分)
方法练习
1.把遍历数组改进为方法实现，并调用方法

package fangFa;public class printArray {public static void main(String[] args) {//      int[] arr = new int[4];int arr2[] = { 1, 2, 3 };printArray2(arr2);}public static void printArray2(int[] arr) {System.out.print("[");for (int x = 0; x < arr.length; x++) {if (x == arr.length - 1) {System.out.print(arr[x] + "]");} else {System.out.print(arr[x] + ",");}}}
}

2.把获取数组最值改进为方法实现，并调用方法

public class MethodTest2 {public static void main(String[] args) {//定义数组int[] arr = {24,36,90,75,81};/*//定义参照物int max = arr[0];//遍历数组,获取元素,依次比较for(int x=1; x<arr.length; x++) {if(arr[x] > max) {max = arr[x];}}*///写方法实现获取数组中的最大值int min = getMin(arr);//输出结果System.out.println("min:"+min);}/** 两个明确：*         返回值类型：int*       参数列表：int[] arr*/public static int getMin(int[] arr) {//定义参照物int min = arr[0];//遍历数组,获取元素,依次比较for(int x=1; x<arr.length; x++) {if(arr[x] < min) {min = arr[x];}}return min;}
}

写一个方法，用于对数组进行求和，并调用方法。

package com.demo05;
/** 写一个方法，用于对数组进行求和，并调用方法。*/
public class MethodTest3 {public static void main(String[] args) {//定义数组int[] arr = {1,2,3,4,5};/*//定义求和变量int sum = 0;//获取数组中的每一个元素for(int x=0; x<arr.length; x++) {//累加sum += arr[x];}*///写方法实现int sum = sum(arr);//输出结果System.out.println("sum:"+sum);}/** 两个明确：*        返回值类型：int*       参数列表：int[] arr*/public static int sum(int[] arr) {//定义求和变量int sum = 0;//获取数组中的每一个元素for(int x=0; x<arr.length; x++) {//累加sum += arr[x];}return sum;}
}

上半部分基础语法系统练习

题目

键盘录入月份，输出对应的季节
2. 打印5位数中所有的回文数
3. 不死神兔问题
4. 求数组中满足要求的元素和
5. 裁判评分
6. 数组反转
7. 数组基本查找
8. 数据加密

1. 键盘录入月份，输出对应的季节(键盘录入+循环）

package com.demo1;/** 需求：键盘录入一个月份，输出该月份对应的季节。* 一年有四季*      3,4,5   春季*         6,7,8   夏季*         9,10,11 秋季*         12,1,2  冬季* * * */
import java.util.Scanner;public class jiJie {public static void main(String[] args) {//      键盘录入Scanner sc = new Scanner(System.in);
//      接收数据System.out.println("键盘输入月份:");int month = sc.nextInt();while ((month >= 1) && (month <= 12)) {if ((month == 3) || (month == 4) || (month == 5)) {System.out.println("春季");break;}if ((month == 6) || (month == 7) || (month == 8)) {System.out.println("夏季");break;}if ((month == 9) || (month == 10) || (month == 11)) {System.out.println("秋季");break;}if ((month == 12) || (month == 1) || (month == 2)) {System.out.println("冬季");break;}}}
}

2.打印5位数中所有的回文数 (for+if训练）

package com.demo;
/** 需求：打印5位数中的所有回文数。*        什么是回文数呢?举例：12321是回文数，个位与万位相同，十位与千位相同。* * 分析：*       A:5位数告诉了我们数据的范围,用for循环实现*       B:拿到每一个5位数后,获取其个位,十位,千位,万位的数据*          如何获取呢?假设x是一个5位数*            个位：x%10*             十位：x/10%10*          千位：x/10/10/10%10*            万位：x/10/10/10/10%10*         C:根据条件进行判断,把满足条件的数据输出即可*/
public class Test3 {public static void main(String[] args) {//5位数告诉了我们数据的范围,用for循环实现int i = 0;for(int x=10000; x<100000; x++) {//拿到每一个5位数后,获取其个位,十位,千位,万位的数据int ge = x%10;int shi = x/10%10;int qian = x/10/10/10%10;int wan = x/10/10/10/10%10;//根据条件进行判断,把满足条件的数据输出即可if((ge == wan) && (shi == qian)) {System.out.println(x);i++;}}System.out.println(i);}
}

3. 不死神兔问题

package com.demo;/** 需求：*         有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，*         假如兔子都不死，问第二十个月的兔子对数为多少？ * * 规律：*       第一个月：1*      第二个月：1*      第三个月：2*      第四个月：3*      第五个月：5*      ...* *      规律：从第三个月开始，每个月的兔子对数是前两个月的兔子对数之和*          第一个月和第二个月的兔子对数都是1* * 分析：*        A:由于数据比较多,所以我们就定义数组来实现了*            int[] arr = new int[20];*      B:给数组的元素赋值*             arr[0] = 1*            arr[1] = 2*        C:找规律*          arr[2] = arr[1] + arr[0];*            arr[3] = arr[2] + arr[1];*            arr[4] = arr[3] + arr[2];*            arr[5] = arr[4] + arr[3];*            ... */
public class Test4 {public static void main(String[] args) {//定义数组int[] arr = new int[20];//给数组的元素赋值arr[0] = 1;arr[1] = 1;//找规律赋值for(int x=2; x<arr.length; x++) {arr[x] = arr[x-1] + arr[x-2];}//输出结果System.out.println("第二十个月兔子的对数是："+arr[19]);}
}

4. 求数组中满足要求的元素和

package com.demo;/** 需求：* (1)定义一个int类型的一维数组，内容为{171,72,19,16,118,51,210,7,18}* (2)求出该数组中满足要求的元素和。*         要求：求和的元素的个位和十位不能包含7,并且只能为偶数。* * 分析：*      A:定义一个int类型的一维数组*       B:定义一个求和变量*         C:遍历数组,获取数组中的每一个元素*         D:判断该元素是否满足条件，如果满足条件就累加*             假设该数据是x*            个位不能是7：x%10 != 7*           十位不能是7：x/10%10 != 7*            必须是偶数：x%2 == 0*        E:输出求和结果*/
public class Test5 {public static void main(String[] args) {//定义一个int类型的一维数组int[] arr = {171,72,19,16,118,51,210,7,18};//定义一个求和变量int sum = 0;//遍历数组,获取数组中的每一个元素for(int x=0; x<arr.length; x++) {//判断该元素是否满足条件，如果满足条件就累加if((arr[x]%10 != 7) && (arr[x]/10%10 != 7) && (arr[x]%2 == 0)) {sum += arr[x];}}//输出求和结果System.out.println("sum:"+sum);}
}

5. 裁判评分

package com.demo;import java.util.Scanner;/** 需求：在编程竞赛中，有6个评委为参赛的选手打分，分数为0-100的整数分。* 选手的最后得分为：去掉一个最高分和一个最低分后 的4个评委平均值。* 请写代码实现。(不考虑小数部分)* * 分析：*      A:定义一个长度为6的数组*      B:键盘录入评委的分数*        C:写方法实现获取最高分,最低分*       D:写方法求评委的分数和*       E:平均分：(和-最高分-最低分)/(arr.length-2)*        F:输出平均分即可*/
public class Test6 {public static void main(String[] args) {//定义一个长度为6的数组int[] arr = new int[6];//创建键盘录入对象Scanner sc = new Scanner(System.in);//键盘录入评委的分数for(int x=0; x<arr.length; x++) {//接收数据System.out.println("请输入第"+(x+1)+"个评委给出的分数(0-100)：");int score = sc.nextInt();arr[x] = score;}//写方法实现获取最高分,最低分//调用方法int max = getMax(arr);int min = getMin(arr);//写方法求评委的分数和int sum = sum(arr);//平均分：(和-最高分-最低分)/(arr.length-2)int avg = (sum-max-min)/(arr.length-2);//输出平均分即可System.out.println("该选手的最终得分是："+avg);}/** 两个明确：*      返回值类型：int*       参数列表：int[] arr*/public static int sum(int[] arr) {//定义求和变量int sum = 0;for(int x=0; x<arr.length; x++) {sum += arr[x];}return sum;}/** 两个明确：*         返回值类型：int*       参数列表：int[] arr*/public static int getMin(int[] arr) {//定义参照物int min = arr[0];for(int x=1; x<arr.length; x++) {if(arr[x] < min) {min = arr[x];}}return min;}/** 两个明确：*      返回值类型：int*       参数列表：int[] arr*/public static int getMax(int[] arr) {//定义参照物int max = arr[0];for(int x=1; x<arr.length; x++) {if(arr[x] > max) {max = arr[x];}}return max;}
}

6. 数组反转

package com.demo;import java.util.Scanner;/** 需求：* (1)键盘录入5个int类型的数据存储数组arr中* (2)定义方法将arr数组中的内容反转* (3)定义方法对反转后的数组进行遍历* * 分析：*      A:定义一个长度为5的数组*      B:通过键盘录入数据给数组中的元素赋值*        C:定义方法将arr数组中的内容反转*             什么是反转?如何实现反转*       D:定义方法对反转后的数组进行遍历*/
public class Test7 {public static void main(String[] args) {//定义一个长度为5的数组int[] arr = new int[5];//通过键盘录入数据给数组中的元素赋值Scanner sc = new Scanner(System.in);for(int x=0; x<arr.length; x++) {System.out.println("请输入"+(x+1)+"个元素值：");int number = sc.nextInt();arr[x] = number;}//反转前printArray(arr);//定义方法将arr数组中的内容反转reverse(arr);//定义方法对反转后的数组进行遍历printArray(arr);}//遍历数组public static void printArray(int[] arr) {System.out.print("[");for(int x=0; x<arr.length; x++) {if(x==arr.length-1) {System.out.println(arr[x]+"]");}else {System.out.print(arr[x]+", ");}}}/** 两个明确：*       返回值类型：void*      参数列表：int[] arr*/public static void reverse(int[] arr) {for(int start=0,end=arr.length-1; start<=end; start++,end--) {int temp = arr[start];arr[start] = arr[end];arr[end] = temp;}}}

7. 数组基本查找

package com.demo;import java.util.Scanner;/** 需求：* (1)键盘录入5个int类型的数据存储数组arr中* (2)定义方法将arr数组中的内容反转* (3)定义方法对反转后的数组进行遍历* * 分析：*      A:定义一个长度为5的数组*      B:通过键盘录入数据给数组中的元素赋值*        C:定义方法将arr数组中的内容反转*             什么是反转?如何实现反转*       D:定义方法对反转后的数组进行遍历*/
public class Test7 {public static void main(String[] args) {//定义一个长度为5的数组int[] arr = new int[5];//通过键盘录入数据给数组中的元素赋值Scanner sc = new Scanner(System.in);for(int x=0; x<arr.length; x++) {System.out.println("请输入"+(x+1)+"个元素值：");int number = sc.nextInt();arr[x] = number;}//反转前printArray(arr);//定义方法将arr数组中的内容反转reverse(arr);//定义方法对反转后的数组进行遍历printArray(arr);}//遍历数组public static void printArray(int[] arr) {System.out.print("[");for(int x=0; x<arr.length; x++) {if(x==arr.length-1) {System.out.println(arr[x]+"]");}else {System.out.print(arr[x]+", ");}}}/** 两个明确：*       返回值类型：void*      参数列表：int[] arr*/public static void reverse(int[] arr) {for(int start=0,end=arr.length-1; start<=end; start++,end--) {int temp = arr[start];arr[start] = arr[end];arr[end] = temp;}}}

8. 数据加密

package com.demo;import java.util.Scanner;/** 需求：键盘录入数据,要求数据是四位的整数,现需要对数据进行加密,加密规则如下:* 每位数字都加上5,然后除以10的余数代替该数字,* 再将第一位和第四位交换,第二位和第三位交换,* 请把加密后的数据输出到控制台* * 分析：*        A:键盘录入一个4位数*            举例：4567*         B:定义一个长度为4的数组*          int[] arr = new int[4];*           arr = {4,5,6,7};*      C:对数组中的数据进行加密规则的操作*             每位数字都加上5,然后除以10的余数代替该数字*                arr[x] += 5;*                 结果：arr = {9,10,11,12};*                 arr[x] %= 10;*                 结果：arr = {9,0,1,2};*            再将第一位和第四位交换,第二位和第三位交换*              结果：arr = {2,1,0,9};*        D:请把加密后的数据输出到控制台*/
public class Test9 {public static void main(String[] args) {//键盘录入一个4位数Scanner sc = new Scanner(System.in);//接收数据System.out.println("请输入一个4位数：");int number = sc.nextInt();//定义一个长度为4的数组int[] arr = new int[4];arr[0] = number/10/10/10%10;arr[1] = number/10/10%10;arr[2] = number/10%10;arr[3] = number%10;//对数组中的数据进行加密规则的操作//每位数字都加上5,然后除以10的余数代替该数字for(int x=0; x<arr.length; x++) {arr[x] += 5;arr[x] %= 10;}//再将第一位和第四位交换,第二位和第三位交换int temp = arr[0];arr[0] = arr[3];arr[3] = temp;temp = arr[1];arr[1] = arr[2];arr[2] = temp;//请把加密后的数据输出到控制台for(int x=0; x<arr.length; x++) {System.out.print(arr[x]);}System.out.println();}
}

七、面向对象基础

1.面向对象思想概述及举例

我们回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后再分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言

面向对象思想特点
是一种更符合我们思考习惯的思想
可以将复杂的事情简单化
将我们从执行者变成了指挥者
角色发生了转换
面向对象思想举例(demo01)
买电脑
洗衣服

2.类与对象及其使用

类与对象的关系
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
我们如何表示一个现实世界事物呢：
属性就是该事物的描述信息
行为就是该事物能够做什么
举例：学生事物
我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
类：是一组相关的属性和行为的集合
对象：是该类事物的具体体现
举例：
类学生
对象班长就是一个对象
类的定义
现实世界的事物
属性事物的描述信息
行为事物能做什么
Java中用class描述事物也是如此
成员变量就是事物的属性
成员方法就是事物的行为
定义类其实就是定义类的成员(成员变量和成员方法)
学生类

package com.demo02;
/** 类的定义：*       类是用来描述现实世界的事物的* * 事物：*       属性  事物的描述信息*        行为  事物能够做什么* * 类是如何和事物进行对应的呢?*      类：*          成员变量*           成员方法* * 需求：写一个学生类* * 学生事物：*       属性：姓名，年龄...*      行为：学习，吃饭...* * 学生类：*       成员变量：姓名,年龄*      成员方法：学习,吃饭** 成员变量：和我们前面学习过的变量的定义是一样的。*        位置不同：类中，方法外*      初始化值：不需要给初始化值* 成员方法：和我们前面学习过的方法的定义是一样的。*      去掉static关键字*/
public class Student {//成员变量//姓名String name;//年龄int age;//成员方法//学习的方法public void study() {System.out.println("好好学习，天天向上");}//吃饭的方法public void eat() {System.out.println("学习饿了要吃饭");}
}

学生类测试


package com.demo02;
/** Student是一个学生事物描述类，main方法不适合放在它里面。* * 使用一个类，其实就是使用该类的成员。(成员变量和成员方法)* 而我们要想使用一个类的成员，就必须首先拥有该类的对象。* 我们如何拥有一个类的对象呢?*       创建对象就可以了?* 我们如何创建对象呢?*      格式：类名 对象名 = new 类名();* 对象如何访问成员呢?*      成员变量：对象名.变量名*        成员方法：对象名.方法名(...)*/
public class StudentDemo {public static void main(String[] args) {//格式：类名 对象名 = new 类名();Student s = new Student();//System.out.println("s:"+s); //com.demo02.Student@193c0cf/*//直接输出成员变量值System.out.println("姓名："+s.name); //nullSystem.out.println("年龄："+s.age); //0System.out.println("----------");//给成员变量赋值s.name = "林青霞";s.age = 28;//再次输出成员变量的值System.out.println("姓名："+s.name); //林青霞System.out.println("年龄："+s.age); //28System.out.println("----------");*///调用成员方法s.study();s.eat();}
}

如何定义
按照事物到类的过程一步步分析
如何使用
创建对象：
类名对象名 = new 类名();
对象名.成员变量
对象名.成员方法

3.对象内存存储机制

1个对象的内存
一个对象的基本初始化过程
2个对象的内存
方法的共用
2个对象的内存
两个引用指向同一个对象
对象指向一个地址

package com.demo03;
/** 手机类的测试类*/
public class PhoneDemo3 {public static void main(String[] args) {Phone p = new Phone();p.brand = "OPPO";p.price = 2999;p.color = "白色";System.out.println("p:"+p);System.out.println(p.brand+"---"+p.price+"---"+p.color);Phone p2 = p;          //把p的内存地址直接给了p2p2.brand = "魅族";p2.price = 1999;p2.color = "蓝色";System.out.println("再次输出p:"+p);System.out.println("p2:"+p2);System.out.println(p.brand+"---"+p.price+"---"+p.color);System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);}
}

输出结果：

4.成员变量和局部变量的区别

在类中的位置不同
成员变量类中方法外
局部变量方法内或者方法声明上，离开方法就不能用了。
在内存中的位置不同
成员变量堆内存
局部变量栈内存
生命周期不同
成员变量随着对象的存在而存在，随着对象的消失而消失
局部变量随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同
成员变量有默认的初始化值
局部变量没有默认的初始化值，必须先定义，赋值，才能使用。

一个标准的案例的使用

package com.demo04;
/** 成员变量和局部变量的区别：*       A:在类中的位置不同*             成员变量：类中，方法外*          局部变量：方法中或者方法声明上(形式参数)*       B:在内存中的位置不同*            成员变量：堆内存*            局部变量：栈内存*        C:生命周期不同*           成员变量：随着对象的创建而存在，随着对象的消失而消失*           局部变量：随着方法的调用而存在，随着方法的调用完毕而消失*         D:初始化值的问题*          成员变量：有默认值*           局部变量：没有默认值。必须先定义，赋值，最后使用*/
public class Variable {int x;  //成员变量  堆内存public void show(){int y = 1;  //局部变量  栈内存System.out.println(x);System.out.println(y);}public static void main(String[] args){Variable v = new Variable();v.show();}
}

输出：
0
1

- private关键字

是一个权限修饰符。
可以修饰成员(成员变量和成员方法)
被private修饰的成员只在本类中才能访问。

private最常见的应用：
把成员变量用private修饰
提供对应的getXxx()/setXxx()方法
- setXxx() 赋值
- getXxx() 获取值

Student:

package demo2;
/** 学生类(私有）** 通过对象直接访问成员变量，会存在数据安全问题* 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢?* 能。* 如何实现呢?*       private关键字** private:*      是一个修饰符*         可以修饰成员变量，也可以修饰成员方法*      ==被private修饰的成员只能在本类中被访问==** 针对private修饰的成员变量，我们会相应的提供getXxx()和setXxx()用于获取和设置成员变量的值,方法用public修饰*/
public class Student {String name;
//    int age;private int age;public void show(){System.out.println("姓名:" + name + "年龄是:" + age);}public void setAge(int a) {if(a<0 || a>200){System.out.println("给你的年纪有误");}else{age = a;}}public int getAge() {return age;}
}

StudentDemo:

package demo2;public class StudentDemo {public static void main(String[] args){Student s = new Student();s.show();s.name="小何";    //不是私有的所以可以直接访问s.setAge(-24);s.show();}
}

5.封装(private)

封装概述
是面向对象三大特征之一。(其它两个是继承和多态）
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法
好处：
通过方法来控制成员变量的操作，提高了代码的安全性。
把代码用方法进行封装，提高了代码的复用性。

Student:

package demo3;public class Student {private String name;private int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

StudentDemo

package demo3;public class StudentDemo {public static void main(String[] args){Student s = new Student();s.setName("小何");s.setAge(11);System.out.println(s.getName() + s.getAge());}}

6.this关键字

this:代表所在类的对象引用
记住：
方法被哪个对象调用，this就代表哪个对象
什么时候使用this呢?
局部变量隐藏成员变量

package com.demo07;
/** 学生类* * 起名字我们要求做到见名知意。* 而我们现在的代码中的n和a就没有做到见名知意，所以我要改进。* * 如果有局部变量名和成员变量名相同，在局部使用的时候，采用的是就近的原则。* * 我们有没有办法把局部变量的name赋值给成员变量的name呢?* 有。* * 什么办法呢?*        用this关键字就可以解决这个问题* * this:代表所在类的对象引用*       方法被哪个对象调用，this就代表那个对象* * 使用场景：*       局部变量隐藏成员变量*/
public class Student {private String name;private int age;public void setName(String name) { //"林青霞"//name = n;this.name = name;}public String getName() {return name;}public void setAge(int age) {//age = age;this.age = age;}public int getAge() {return age;}
}

7.构造方法

构造方法作用概述
给对象的数据进行初始化
构造方法格式
方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值
构造方法注意事项
如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的
标准类的代码写法和测试
类
- 成员变量
- 构造方法
  无参构造方法
  带参构造方法
- 成员方法
  getXxx()
  setXxx()
给成员变量赋值的方式
无参构造方法+setXxx()
带参构造方法

package com.demo08;
/** 构造方法：*       给对象的数据进行初始化* * 格式：*      方法名和类名相同*       没有返回值类型，连void都不能写*       没有具体的返回值* * 构造方法的注意事项：*      A:如果我们没有给出构造方法，系统将会提供一个默认的无参构造方法供我们使用。*      B:如果我们给出了构造方法，系统将不再提供默认的无参构造方法供我们使用。*        这个时候，如果我们想使用无参构造方法，就必须自己提供。*        推荐：自己给无参构造方法*      C:构造方法也是可以重载的* * 成员变量赋值：*        A:setXxx()方法*       B:带参构造方法    */
public class Student {private String name;private int age;/*public Student() {System.out.println("这是构造方法");}*/public Student() {}public Student(String name) {this.name = name;}public Student(int age) {this.age = age;}public Student(String name,int age) {this.name = name;this.age = age;}public void show() {System.out.println(name+"---"+age);}public String getName() {return name;}public void setName(String name) {this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}

package com.demo08;public class StudentDemo {public static void main(String[] args) {//如何调用构造方法呢?//通过new关键字调用//格式：类名 对象名 = new 构造方法(...);//Student s = new Student();//s.setName("张三");//s.setAge(18);//s.show();//public Student(String name)//Student s2 = new Student("林青霞");//s2.show();//public Student(int age)/*Student s3 = new Student(28);s3.show();*///public Student(String name,int age)Student s4 = new Student("林青霞",28);s4.show();}
}

8.标准类的代码写法和测试

类
成员变量
构造方法
- 无参构造方法
- 带参构造方法
  成员方法
  getXxx()
  setXxx()
  给成员变量赋值的方式
- 无参构造方法+setXxx()
- 带参构造方法
  类名作为形式参数案例
  要的其实是该类的对象
  类名作为返回值案例
  返回的其实是该类的对象
  student

package com.demo09;
/** 学生类*/
public class Student {/**姓名*/private String name;/**年龄*/private int age;/**构造方法*/public Student() {}/**构造方法*/public Student(String name,int age) {this.name = name;this.age = age;}/**给姓名赋值*/public void setName(String name) {this.name = name;}/*** 获取姓名*/public String getName() {return name;}/*** 给年龄赋值* @param age 年龄*/public void setAge(int age) {this.age = age;}/*** 获取年龄* @return 年龄*/public int getAge() {return age;}
}

package com.demo09;
/** 学生类的测试类*/
public class StudentDemo {public static void main(String[] args) {//无参+setXxx()Student s = new  Student();s.setName("林青霞");s.setAge(28);System.out.println(s.getName()+"---"+s.getAge());//带参构造Student s2 = new Student("林青霞",28);System.out.println(s2.getName()+"---"+s2.getAge());}
}

9.类名作为形式参数和返回值

类名作为形式参数案例
要的其实是该类的对象
类名作为返回值案例
返回的其实是该类的对象

package com.demo10;public class Student {/*** 学习*/public void study() {System.out.println("好好学习,天天向上");}
}

package com.demo10;public class Teacher {/*** 调用学生类的学习方法* @param s 学生对象*/public void test(Student s) {s.study();}
}

package com.demo10;//需求： 调用Teacher的test方法//类名作为形式参数：其实这里需要的是该类对象。
public class Test {public static void main(String[] args) {Teacher t = new Teacher();Student s = new Student();t.test(s);}
}

package com.demo11;public class Teacher {public Student getStudent() {Student s = new Student();return s;}
}

package com.demo11;//需求： 通过Teacher得到Student对象，然后调用Student类的方法
//如果方法的返回值是类名：其实返回的是该类的对象
public class Test {public static void main(String[] args) {Teacher t = new Teacher();Student s = t.getStudent();//Student s = new Student();s.study();}
}

八、java常用API

API概述

API(Application Programming Interface)
应用程序编程接口
编写一个机器人程序去控制机器人踢足球，程序就需要向机器人发出向前跑、向后跑、射门、抢球等各种命令，没有编过程序的人很难想象这样的程序如何编写。但是对于有经验的开发人员来说，知道机器人厂商一定会提供一些用于控制机器人的Java类，这些类中定义好了操作机器人各种动作的方法。其实，这些Java类就是机器人厂商提供给应用程序编程的接口，大家把这些类称为API。本章涉及的Java API指的就是JDK中提供的各种功能的Java类。

-如何使用API
（1）打开帮助文档
点击显示，找到索引，看到输入框
你要找谁?
在输入框里输入，然后回车

例如：Scanner，点击第一个

CTRL+F查找

String s = sc.nextLine();
int month = sc.nextInt();

（2）看包
java.lang下的类不需要导包，其他需要
（3）看类的解释和说明
（4）学习构造方法
（5）使用成员方法

String

String类的概述及构造方法
String类概述
字符串是由多个字符组成的一串数据
字符串可以看成是字符数组
构造方法
public String(String original)
public String(char[] value)
public String(char[] value,int offset,int count)
直接赋值也可以是一个对象
String的特点
通过构造方法创建字符串对象
String s = new String(“hello”);
直接赋值创建字符串对象
String s = “hello”;区别是什么?
String类的判断功能
boolean equals(Object obj) 判断字符串是否相等
boolean equalsIgnoreCase(String str) 不区分字符串大小写
boolean startsWith(String str) 判断以什么字符串为开始

boolean endsWith(String str) 以什么为结束，同endsEnd。
API中的equal:

Equal测试：

package com.demo03;
/** Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。* 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。* * String类的判断功能：* boolean equals(Object obj):比较字符串的内容是否相同* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写* boolean startsWith(String str):判断字符串对象是否以指定的str开头* boolean endsWith(String str):判断字符串对象是否以指定的str结尾*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s1 = "hello";String s2 = "hello";String s3 = "Hello";//boolean equals(Object obj):比较字符串的内容是否相同/*System.out.println(s1.equals(s2));System.out.println(s1.equals(s3));System.out.println("-----------");*///boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写/*System.out.println(s1.equalsIgnoreCase(s2));System.out.println(s1.equalsIgnoreCase(s3));System.out.println("-----------");*///boolean startsWith(String str):判断字符串对象是否以指定的str开头/*System.out.println(s1.startsWith("he"));System.out.println(s1.startsWith("ll"));*///boolean endsWith(String str):判断字符串对象是否以指定的str结束System.out.println(s1.endsWith("ll"));}
}

练习: 模拟用户登录

package demo5_api;import java.util.Scanner;/*** 模拟用户登录 equal的用法 给三次机会,并提示还有几次。* A 定义2个字符串对象，是正确的账号和密码* B 键盘录入账号和密码，并规定3次机会* C 判断输入的账号密码和正确的是否一样，一样：登陆成功，记得break跳出循环，不一样：失败还有2-x次机会；第三次：账号锁定，次数用完*/
public class UserLogin {public static void main(String[] args) {//  1.定义两个字符串对象，用于存储已经存在的用户名和密码String name = "admin";String password = "123456";
//  2.键盘录入 3次机会for (int x = 0; x < 3; x++) {Scanner scanner = new Scanner(System.in);System.out.println("输入账号:");String userName = scanner.nextLine();System.out.println("输入密码:");String userPsd = scanner.nextLine();if (userName.equals(name) && userPsd.equals(userPsd)) {System.out.println("登陆成功");break;} else if ((2 - x) == 0) {System.out.println("次数用完");} else {System.out.println("还剩余" + (2 - x) + "次机会");}}}
}

String类的获取功能
int length() 字符串的长度
char charAt(int index) 整型变量所在位置的字符
int indexOf(String str) 字符串在整个字符串中的位置
String substring(int start) 取子字符串，从start开始取字符串
String substring(int start,int end) 从start开始取字符串，到end结束，不包括第end个。
String类的转换功能
char[] toCharArray() 把字符串转换为字符数组
String toLowerCase() 把字符串转换为小写字符串
String toUpperCase() 把字符串转换为大写字符串

package demo5_api;public class StringDemo {public static void main(String[] args){String s = "helloWorld";
//        int length();获取字符串的长度，字符字数System.out.println(s.length());
//        charAt(int index) 获取指定索引处的字符System.out.println(s.charAt(1));
//        int indexOf(String str) 获取str在字符串对象中第一次出现的索引System.out.println(s.indexOf("l"));System.out.println(s.indexOf("he"));
//        String substring(int start):从start开始截取字符串System.out.println(s.substring(0));System.out.println(s.substring(4));
//       String substring(int start,int end):从start开始，到end结束截取字符串,不包括最后一位System.out.println(s.substring(3,6));
//       String toUpperCase() 把字符串转换为**大写**字符串System.out.println(s.toUpperCase());
//       String toLowerCase() 把字符串转换为**小写**字符串System.out.println(s.toLowerCase());}
}

String类的其他功能
String trim() 去除字符串两端空格

String s1 = "hekk";
System.out.println(s1.trim());

按照指定符号分割字符串
String[] split(String str)

String类的练习
（1）把数组中的数据按照指定格式拼接成一个字符串
举例：int[] arr = {1,2,3}; 输出结果：[1, 2, 3]

package com.demo07;
/** 把数组中的数据按照指定格式拼接成一个字符串* 举例：int[] arr = {1,2,3};  * 输出结果：[1, 2, 3]* * 分析：*      A:定义一个int类型的数组*         B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串*      C:调用方法*         D:输出结果*/
public class StringTest {public static void main(String[] args) {//定义一个int类型的数组int[] arr = {1,2,3};//写方法实现把数组中的元素按照指定的格式拼接成一个字符串//调用方法String s = arrayToString(arr);//输出结果System.out.println("s:"+s);}/** 两个明确：*        返回值类型：String*        参数列表：int[] arr*/public static String arrayToString(int[] arr) {String s = "";//[1, 2, 3]s += "[";for(int x=0; x<arr.length; x++) {if(x==arr.length-1) {s += arr[x];}else {s += arr[x];s += ", ";}}s += "]";return s;}
}

（2）2字符串反转
举例：键盘录入”abc” 输出结果：”cba”

package com.demo07;import java.util.Scanner;/** 字符串反转* 举例：键盘录入”abc”       * 输出结果：”cba”* * 分析：*      A:键盘录入一个字符串*        B:写方法实现字符串的反转*          a:把字符串倒着遍历，得到的每一个字符拼接成字符串。*          b:把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串*         C:调用方法*         D:输出结果*/
public class StringTest2 {public static void main(String[] args) {//键盘录入一个字符串Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();//写方法实现字符串的反转//调用方法String result = reverse(s);//输出结果System.out.println("result:"+result);}/*把字符串倒着遍历，得到的每一个字符拼接成字符串。两个明确：返回值类型：String参数列表：String s*//*public static String reverse(String s) {String ss = "";for(int x=s.length()-1; x>=0; x--) {ss += s.charAt(x);}return ss;}*///把字符串转换为字符数组，然后对字符数组进行反转，最后再把字符数组转换为字符串public static String reverse(String s) {//把字符串转换为字符数组char[] chs = s.toCharArray();//对字符数组进行反转for(int start=0,end=chs.length-1; start<=end; start++,end--) {char temp = chs[start];chs[start] = chs[end];chs[end] = temp;}//最后再把字符数组转换为字符串String ss = new String(chs);return ss;}
}

String拼接的过程图：缺点比较耗费内存。

StringBuilder

StringBuilder类概述及其构造方法
- StringBuilder类概述
  我们如果对字符串进行拼接操作，每次拼接，都会构建一个新的String对象，既耗时，又浪费空间。而StringBuilder就可以解决这个问题
StringBuilder和String的区别?

package com.demo01;
/** StringBuilder:是一个可变的字符串。字符串缓冲区类。* * String和StringBuilder的区别：*        String的内容是固定的。*         StringBuilder的内容是可变的。* * 构造方法：*      StringBuilder()* * 成员方法：*        public int capacity():返回当前容量*       public int length():返回长度（字符数）* *      容量：理论值*      长度：实际值*/
public class StringBuilderDemo {public static void main(String[] args) {//创建对象StringBuilder sb = new StringBuilder();System.out.println("sb:"+sb);System.out.println("sb.capacity():"+sb.capacity());System.out.println("sb.length():"+sb.length());sb.append("asdfasdfasdfasdfasdfasdfasdfdfgdragtert");System.out.println("sb.capacity():"+sb.capacity());System.out.println("sb.length():"+sb.length());}
}

构造方法
public StringBuilder()
StringBuilder类的常用方法
添加功能（字符串后面追加字符串）
public StringBuilder append(任意类型)

package com.demo02;
/** 添加功能*       public StringBuilder append(任意类型):添加数据，并返回自身对象* 反转功能*        public StringBuilder reverse()*/
public class StringBuilderDemo {public static void main(String[] args) {//创建对象StringBuilder sb = new StringBuilder();//public StringBuilder append(任意类型)StringBuilder sb2 = sb.append("hello");System.out.println("sb:"+sb);System.out.println("sb2:"+sb2);System.out.println(sb == sb2); //truesb.append("hello");sb.append("world");sb.append(true);sb.append(100);System.out.println("sb:"+sb);//链式编程sb.append("hello").append("world").append(true).append(100);System.out.println("sb:"+sb);//public StringBuilder reverse()sb.reverse();System.out.println("sb:"+sb);}
}

反转功能
public StringBuilder reverse()

StringBuilder的练习

在这里插入代码片

StringBuilder和String的相互转换

package com.demo03;
/** StringBuilder和String的相互转换* * StringBuilder -- String*       public String toString():通过toString()就可以实现把StringBuilder转成String* * String -- StringBuilder*        StringBuilder(String str):通过构造方法就可以实现把String转成StringBuilder*/
public class StringBuilderTest {public static void main(String[] args) {//StringBuilder -- String/*StringBuilder sb = new StringBuilder();sb.append("hello").append("world");String s = sb.toString();System.out.println(s);*///String -- StringBuilderString s = "helloworld";StringBuilder sb = new StringBuilder(s);System.out.println(sb);}
}

把数组拼接成一个字符串

package com.demo03;
/** 把数组拼接成一个字符串* 举例：*        int[] arr = {1,2,3};* 结果：*      [1, 2, 3]*/
public class StringBuilderTest2 {public static void main(String[] args) {//定义一个数组int[] arr = {1,2,3};//写方法实现拼接//调用方法String s = arrayToString(arr);//输出结果System.out.println("s:"+s);}/** 两个明确：*      返回值类型：String*        参数列表：int[] arr*/public static String arrayToString(int[] arr) {StringBuilder sb = new StringBuilder();//[1, 2, 3]sb.append("[");for(int x=0; x<arr.length; x++) {if(x==arr.length-1) {sb.append(arr[x]);}else {sb.append(arr[x]).append(", ");}}sb.append("]");String result = sb.toString();return result;}
}

把字符串反转
注意：如果，用reverse方法的时候报错，修改：
1.类名和StringBuilder冲突了，换一个类名。
2.定义加上java.lang.

java.lang.StringBuilder k = new java.lang.StringBuilder(s);

package demo5_api;import java.util.Scanner;/** 判断一个字符串是否是对称字符串* 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串** 分析：*       A:键盘录入一个字符串*        B:写方法实现判断一个字符串是否是对称字符串*             把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串*      C:调用方法*         D:输出结果*/
public class StringBuilder1 {public static void main(String[] args) {System.out.println("请输入一个字符串");Scanner scanner = new Scanner(System.in);String s = scanner.nextLine();java.lang.StringBuilder k = new java.lang.StringBuilder(s);System.out.println("字符串反转后的结果为" + k.reverse());}
}

结果：

 demo5_api.StringBuilder1
请输入一个字符串
heh
字符串反转后的结果为heh

判断一个字符串是否是对称字符串
例如"abc"不是对称字符串，“aba”、“abba”、“aaa”、"mnanm"是对称字符串
代码

package com.demo03;import java.util.Scanner;/** 判断一个字符串是否是对称字符串* 例如"abc"不是对称字符串，"aba"、"abba"、"aaa"、"mnanm"是对称字符串* * 分析：*         A:键盘录入一个字符串*        B:写方法实现判断一个字符串是否是对称字符串*             把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串*      C:调用方法*         D:输出结果*/
public class StringBuilderTest4 {public static void main(String[] args) {//键盘录入一个字符串Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();//写方法实现判断一个字符串是否是对称字符串//调用方法boolean b = isSymmetry(s);//输出结果System.out.println("b:"+b);}/** 两个明确：*       返回值类型：boolean*       参数列表：String s*/public static boolean isSymmetry(String s) {//把字符串反转，和反转前的字符串进行比较，如果内容相同，就说明是对称字符串StringBuilder sb = new StringBuilder(s);sb.reverse();String result = sb.toString();return result.equals(s);}
}

本章节全部代码汇总：

package com.demo01;import java.util.Scanner;/** Scanner:用于获取键盘录入的数据。(基本数据类型，字符串数据)*       public String nextLine():获取键盘录入的字符串数据*/
public class ScannerDemo {public static void main(String[] args) {//创建键盘录入对象Scanner sc = new Scanner(System.in);//接收数据System.out.println("请输入一个字符串数据：");String s = sc.nextLine();//输出结果System.out.println("s:"+s);}
}

demo02

package com.demo02;
/** String:字符串类*        由多个字符组成的一串数据*       字符串其本质是一个字符数组* * 构造方法：*      String(String original):把字符串数据封装成字符串对象*         String(char[] value):把字符数组的数据封装成字符串对象*      String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象* * 注意：字符串是一种比较特殊的引用数据类型，直接输出字符串对象输出的是该对象中的数据。*/
public class StringDemo {public static void main(String[] args) {//方式1//String(String original):把字符串数据封装成字符串对象String s1 = new String("hello");System.out.println("s1:"+s1);System.out.println("---------");//方式2//String(char[] value):把字符数组的数据封装成字符串对象char[] chs = {'h','e','l','l','o'};String s2 = new String(chs);System.out.println("s2:"+s2);System.out.println("---------");//方式3//String(char[] value, int index, int count):把字符数组中的一部分数据封装成字符串对象//String s3 = new String(chs,0,chs.length);//char[] chs = {'h','e','l','l','o'};String s3 = new String(chs,1,3);System.out.println("s3:"+s3);System.out.println("---------");//方式4String s4 = "hello";System.out.println("s4:"+s4);}
}

demo02

package com.demo02;
/** 通过构造方法创建的字符串对象和直接赋值方式创建的字符串对象有什么区别呢?*       通过构造方法创建字符串对象是在堆内存。*        直接赋值方式创建对象是在方法区的常量池。*       * ==:*        基本数据类型：比较的是基本数据类型的值是否相同*         引用数据类型：比较的是引用数据类型的地址值是否相同*/
public class StringDemo2 {public static void main(String[] args) {String s1 = new String("hello");String s2 = "hello";//System.out.println("s1:"+s1);//System.out.println("s2:"+s2);//System.out.println("s1==s2:"+(s1==s2)); //falseString s3 = "hello";/*System.out.println("s1==s3:"+(s1==s3)); //falseSystem.out.println("s2==s3:"+(s2==s3)); //true*/System.out.println(s1.equals(s2));}
}

demo03

package com.demo03;
/** Object:是类层次结构中的根类，所有的类都直接或者间接的继承自该类。* 如果一个方法的形式参数是Object，那么这里我们就可以传递它的任意的子类对象。* * String类的判断功能：* boolean equals(Object obj):比较字符串的内容是否相同* boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写* boolean startsWith(String str):判断字符串对象是否以指定的str开头* boolean endsWith(String str):判断字符串对象是否以指定的str结尾*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s1 = "hello";String s2 = "hello";String s3 = "Hello";//boolean equals(Object obj):比较字符串的内容是否相同/*System.out.println(s1.equals(s2));System.out.println(s1.equals(s3));System.out.println("-----------");*///boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写/*System.out.println(s1.equalsIgnoreCase(s2));System.out.println(s1.equalsIgnoreCase(s3));System.out.println("-----------");*///boolean startsWith(String str):判断字符串对象是否以指定的str开头/*System.out.println(s1.startsWith("he"));System.out.println(s1.startsWith("ll"));*///boolean endsWith(String str):判断字符串对象是否以指定的str结束System.out.println(s1.endsWith("ll"));}
}

demo03

package com.demo03;import java.util.Scanner;/** 模拟登录,给三次机会,并提示还有几次。* * 分析：*       A:定义两个字符串对象，用于存储已经存在的用户名和密码*         B:键盘录入用户名和密码*       C:拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较*             如果内容相同，提示登录成功*           如果内容不同，提示登录失败，并提示还有几次机会*/
public class StringTest {public static void main(String[] args) {//定义两个字符串对象，用于存储已经存在的用户名和密码String username = "admin";String password = "admin";//给三次机会，用for循环实现for(int x=0; x<3; x++) {//键盘录入用户名和密码Scanner sc = new Scanner(System.in);System.out.println("请输入用户名：");String name = sc.nextLine();System.out.println("请输入密码：");String pwd = sc.nextLine();//拿键盘录入的用户名和密码和已经存在的用户名和密码进行比较if(username.equals(name) && password.equals(pwd)) {System.out.println("登录成功");break;}else {if((2-x) ==0) {System.out.println("用户名和密码被锁定,请与管理员联系");}else {System.out.println("登录失败,你还有"+(2-x)+"次机会"); //2,1,0}}}}
}

demo04

package com.demo04;
/** String类的获取功能：* int length():获取字符串的长度，其实也就是字符个数* char charAt(int index):获取指定索引处的字符* int indexOf(String str):获取str在字符串对象中第一次出现的索引* String substring(int start):从start开始截取字符串* String substring(int start,int end):从start开始，到end结束截取字符串。包括start，不包括end*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s = "helloworld";//int length():获取字符串的长度，其实也就是字符个数System.out.println(s.length());/*  System.out.println("--------");//char charAt(int index):获取指定索引处的字符System.out.println(s.charAt(0));System.out.println(s.charAt(1));System.out.println("--------");*///int indexOf(String str):获取str在字符串对象中第一次出现的索引/*System.out.println(s.indexOf("l"));System.out.println(s.indexOf("owo"));System.out.println(s.indexOf("ak"));System.out.println("--------");*//*//String substring(int start):从start开始截取字符串System.out.println(s.substring(0));System.out.println(s.substring(5));System.out.println("--------");*///String substring(int start,int end):从start开始，到end结束截取字符串System.out.println(s.substring(0, s.length()));//System.out.println(s.substring(3,8));}
}

demo04

package com.demo04;
/** 遍历字符串(获取字符串中的每一个字符)*/
public class StringTest {public static void main(String[] args) {//创建一个字符串对象String s = "abcde";//原始做法System.out.println(s.charAt(0));System.out.println(s.charAt(1));System.out.println(s.charAt(2));System.out.println(s.charAt(3));System.out.println(s.charAt(4));System.out.println("---------");//用for循环改进for(int x=0; x<5; x++) {System.out.println(s.charAt(x));}System.out.println("---------");//用length()方法获取字符串的长度for(int x=0; x<s.length(); x++) {System.out.println(s.charAt(x));}}
}

demo04

package com.demo04;import java.util.Scanner;/** 统计一个字符串中大写字母字符，小写字母字符，数字字符出现的次数。(不考虑其他字符)* * 分析：*       A:键盘录入一个字符串数据*      B:定义三个统计变量，初始化值都是0*      C:遍历字符串，得到每一个字符*         D:拿字符进行判断*          假如ch是一个字符。*             大写：ch>='A' && ch<='Z'*           小写：ch>='a' && ch<='z'*           数字：ch>='0' && ch<='9'*       E:输出结果*/
public class StringTest2 {public static void main(String[] args) {//键盘录入一个字符串数据Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串数据：");String s = sc.nextLine();//定义三个统计变量，初始化值都是0int bigCount = 0;int smallCount = 0;int numberCount = 0;//遍历字符串，得到每一个字符for(int x=0; x<s.length(); x++) {char ch = s.charAt(x);//拿字符进行判断if(ch>='A' && ch<='Z') {bigCount++;}else if(ch>='a' && ch<='z') {smallCount++;}else if(ch>='0' && ch<='9') {numberCount++;}else {System.out.println("该字符"+ch+"非法");}}//输出结果System.out.println("大写字符："+bigCount+"个");System.out.println("小写字符："+smallCount+"个");System.out.println("数字字符："+numberCount+"个");}
}

demo05

package com.demo05;
/** String类的转换功能：* char[] toCharArray():把字符串转换为字符数组* String toLowerCase():把字符串转换为小写字符串* String toUpperCase():把字符串转换为大写字符串* * 字符串的遍历：*         A:length()加上charAt()*       B:把字符串转换为字符数组，然后遍历数组*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象String s = "abcde";//char[] toCharArray():把字符串转换为字符数组/*char[] chs = s.toCharArray();for(int x=0; x<chs.length; x++) {System.out.println(chs[x]);}System.out.println("-----------");*///String toLowerCase():把字符串转换为小写字符串System.out.println("HelloWorld".toLowerCase());//String toUpperCase():把字符串转换为大写字符串System.out.println("HelloWorld".toUpperCase());}
}

demo06

package com.demo06;
/** 去除字符串两端空格   *       String trim()* 按照指定符号分割字符串  *       String[] split(String str)*/
public class StringDemo {public static void main(String[] args) {//创建字符串对象/*String s1 = "helloworld";String s2 = "  helloworld  ";String s3 = "  hello  world  ";System.out.println("---"+s1+"---");System.out.println("---"+s1.trim()+"---");System.out.println("---"+s2+"---");System.out.println("---"+s2.trim()+"---");System.out.println("---"+s3+"---");System.out.println("---"+s3.trim()+"---");System.out.println("-------------------");*///String[] split(String str)//创建字符串对象String s4 = "aa,bb,cc";String[] strArray = s4.split(",");for(int x=0; x<strArray.length; x++) {System.out.println(strArray[x]);}}
}

demo07

package com.demo07;
/** 把数组中的数据按照指定格式拼接成一个字符串* 举例：int[] arr = {1,2,3};  * 输出结果：[1, 2, 3]* * 分析：*      A:定义一个int类型的数组*         B:写方法实现把数组中的元素按照指定的格式拼接成一个字符串*      C:调用方法*         D:输出结果*/
public class StringTest {public static void main(String[] args) {//定义一个int类型的数组int[] arr = {1,2,3};//写方法实现把数组中的元素按照指定的格式拼接成一个字符串//调用方法String s = arrayToString(arr);//输出结果System.out.println("s:"+s);}/** 两个明确：*        返回值类型：String*        参数列表：int[] arr*/public static String arrayToString(int[] arr) {String s = "";//[1, 2, 3]s += "[";for(int x=0; x<arr.length; x++) {if(x==arr.length-1) {s += arr[x];}else {s += arr[x];s += ", ";}}s += "]";return s;}
}

demo07

package com.demo07;import java.util.Scanner;/** 字符串反转* 举例：键盘录入”abc”       * 输出结果：”cba”* * 分析：*      A:键盘录入一个字符串*        B:写方法实现字符串的反转*          a:把字符串倒着遍历，得到的每一个字符拼接成字符串。*          b:把字符串转换为字符数组，然后对字符数组进行反转，最后在把字符数组转换为字符串*         C:调用方法*         D:输出结果*/
public class StringTest2 {public static void main(String[] args) {//键盘录入一个字符串Scanner sc = new Scanner(System.in);System.out.println("请输入一个字符串：");String s = sc.nextLine();//写方法实现字符串的反转//调用方法String result = reverse(s);//输出结果System.out.println("result:"+result);}/*把字符串倒着遍历，得到的每一个字符拼接成字符串。两个明确：返回值类型：String参数列表：String s*//*public static String reverse(String s) {String ss = "";for(int x=s.length()-1; x>=0; x--) {ss += s.charAt(x);}return ss;}*///把字符串转换为字符数组，然后对字符数组进行反转，最后再把字符数组转换为字符串public static String reverse(String s) {//把字符串转换为字符数组char[] chs = s.toCharArray();//对字符数组进行反转for(int start=0,end=chs.length-1; start<=end; start++,end--) {char temp = chs[start];chs[start] = chs[end];chs[end] = temp;}//最后再把字符数组转换为字符串String ss = new String(chs);return ss;}
}

九、java集合

1.对象数组的案例

首先须知道如何快速：IDEA自动生成构造、get、set方法
简要步骤：右击——Generate——get and set(选择就是带参数的，不选就不带）
Student:

package demo9_List;/** Eclipse自动生成构造方法：*      代码区域右键 -- Source -- Generate Constructors from Superclass...    无参构造方法*         代码区域右键 -- Source -- Generate Constructor using Fields...        带参构造方法* 自动生成getXxx()/setXxx():*         代码区域右键 -- Source -- Generate Getters and Setters...** 一个标准的类通常要拥有下面四个组成部分:1.所有的成员变量都要使用private关键字修饰2.为每一个成员变量编写一对儿Getter/Setter方法3.编写一个无参数的构造方法4.编写一个全参数的构造方法这样标准的类也叫做Java Bean。*/
public class Student {private String name;    //所有的成员变量都要使用private关键字修饰private int age;public Student(String name, int age) {super();this.name = name;this.age = age;}public Student() {super();}public String getName() {return name;}public void setName(String name) {  //为每一个成员变量编写一对儿Getter/Setter方法this.name = name;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}}

StudentDemo:

package demo9_List;/** 创建一个学生数组，存储三个学生对象并遍历* 分析：* A 定义学生类* B 创建学生数组* C 创建学生对象* D 把学生对象作为元素赋值给学生数组* E 遍历数组*/
public class StudentDemo {public static void main(String[] args) {//        1.创建学生数组Student[] students = new Student[3];
//        2.创建学生对象Student s1 = new Student("小何",25);Student s2 = new Student("小张",28);Student s3 = new Student("小林",27);
//        把学生对象作为元素赋值给数组students[0] = s1;students[1] = s2;students[2] = s3;
//        遍历学生数组for (int i = 0;i<students.length;i++){Student s= students[i];System.out.println(s.getName()+"--"+s.getAge());}}
}

为什么出现集合类？
我们学习的是面向对象语言，而面向对象语言对事物的描述是通过对象体现的，为了方便对多个对象进行操作，我们就必须把这多个对象进行存储。
而要想存储多个对象，就不能是一个基本的变量，而应该是一个容器类型的变量，在我们目前所学过的知识里面，有哪些是容器类型的呢?数组和StringBuilder。
但是呢? StringBuilder的结果是一个字符串，不一定满足我们的要求，所以我们只能选择数组，这就是对象数组。而对象数组又不能适应变化的需求，因为数组的长度是固定的，这个时候，为了适应变化的需求，Java就提供了集合类供我们使用。由此可见集合的长度是可变的数组。
集合类的特点：长度可变。
ArrayList:
大小可变数组的实现
:是一种特殊的数据类型，泛型。
怎么用呢?
在出现E的地方我们使用引用数据类型替换即可
举例：ArrayList,ArrayList

2. ArrayList类的构造方法和成员方法

构造方法
ArrayList()

package demo9_List;import java.util.ArrayList;/** 为什么会出现集合类：*         我们学习的是面向对象编程语言，而面向对象编程语言对事物的描述都是通过对象来体现的。*       为了方便对多个对象进行操作，我们就必须对这多个对象进行存储，而要想对多个对象进行存储，*       就不能是一个基本的变量，而应该是一个容器类型的变量。*      到目前为止，我们学习过了哪些容器类型的数据呢？StringBuilder,数组。*         StringBuilder的结果只能是一个字符串类型，不一定满足我们的需求。*      所以，我们目前只能选择数组了，也就是我们前面学习过的对象数组。*      但是，数组的长度是固定的，适应不了变化的需求，那么，我们该如何选择呢?*        这个时候，java就提供了集合类供我们使用。* 构造方法：*        ArrayList()** 添加元素：*         public boolean add(E e):添加元素*       public void add(int index,E element):在指定的索引处添加一个元素*/
public class arrayListDemo1 {public static void main(String[] args) {//        创建集合对象ArrayList<String> array = new ArrayList<String>();  //<String>表示泛型的意思，每一项都是String类型
//        添加元素 add(E e)array.add("world");array.add("hello");array.add("java");
//        在指定的索引处添加对象array.add(2, "android");System.out.println("array:" + array);}}

输出结果：

array:[world, hello, android, java]

成员方法
添加元素
array.add(E e);
获取元素
array.get(int index);
集合长度
array.size();
删除元素
array.remove(int index);
修改元素
array.set(int index,E element);

package demo9_List;import java.util.ArrayList;/** 获取元素*      public E get(int index):返回指定索引处的元素* 集合长度*       public int size():返回集合中的元素的个数* 删除元素*        public boolean remove(Object o):删除指定的元素，返回删除是否成功*        public E remove(int index):删除指定索引处的元素，返回被删除的元素* 修改元素*        public E set(int index,E element):修改指定索引处的元素，返回被修改的元素*/
public class arrayListDemo2 {public static void main(String[] args) {ArrayList<String> arrayList = new ArrayList<String>();
//        添加元素arrayList.add("1world");arrayList.add("2world");arrayList.add("3world");System.out.println(arrayList);
//        集合长度System.out.println(arrayList.size());
//        删除指定元素,返回被删除的元素System.out.println(arrayList.remove(1));System.out.println("删除后的集合：" + arrayList);
//        修改元素System.out.println(arrayList.set(0, "hello"));}
}

集合遍历：

package com.demo01;import java.util.ArrayList;/** ArrayList集合的遍历*        通过size()和get()配合实现的*/
public class ArrayListDemo3 {public static void main(String[] args) {//创建集合对象ArrayList<String> array = new ArrayList<String>();//添加元素array.add("hello");array.add("world");array.add("java");//获取元素//原始做法System.out.println(array.get(0));System.out.println(array.get(1));System.out.println(array.get(2));System.out.println("----------");for(int x=0; x<3; x++) {System.out.println(array.get(x));}System.out.println("----------");//如何知道集合中元素的个数呢?size()for(int x=0; x<array.size(); x++) {System.out.println(array.get(x));}System.out.println("----------");//最标准的用法for(int x=0; x<array.size(); x++) {String s = array.get(x);System.out.println(s);}}
}

3. ArrayList类案例

存储字符串并遍历
给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。
存储自定义对象并遍历
创建一个集合，存储学生对象，学生对象的数据来自于键盘录入，最后，遍历集合。

package com.demo02;import java.util.ArrayList;/** 给定一个字符串数组：{“张三丰”,“宋远桥”,“张无忌”,“殷梨亭”,“张翠山”,“莫声谷”}，将数组中的元素添加到集合中，并把所有姓张的人员打印到控制台上。* * 分析：*        A:定义字符串数组*      B:创建集合对象*       C:遍历字符串数组，获取到每一个字符串元素*       D:把获取到的字符串元素添加到集合*      E:遍历集合*             要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台*/
public class ArrayListTest2 {public static void main(String[] args) {//定义字符串数组String[] strArray = {"张三丰","宋远桥","张无忌","殷梨亭","张翠山","莫声谷"};//创建集合对象ArrayList<String> array = new ArrayList<String>();//遍历字符串数组，获取到每一个字符串元素for(int x=0; x<strArray.length; x++) {//把获取到的字符串元素添加到集合array.add(strArray[x]);}//遍历集合for(int x=0; x<array.size(); x++) {String s = array.get(x);//要判断每一个字符串元素是否以"张"开头，如果是，就输出在控制台if(s.startsWith("张")) {System.out.println(s);}}}
}

结果：

张三丰
张无忌
张翠山

4.学生管理系统

package com.demo;
/** 这是我的学生类*/
public class Student {//学号private String id;//姓名private String name;//年龄private String age;//居住地private String address;public Student() {}public Student(String id, String name, String age, String address) {this.id = id;this.name = name;this.age = age;this.address = address;}public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}}

package com.demo;import java.util.ArrayList;
import java.util.Scanner;/** 这是我的学生管理系统的主类* * 步骤如下：* A:定义学生类* B:学生管理系统的主界面的代码编写* C:学生管理系统的查看所有学生的代码编写* D:学生管理系统的添加学生的代码编写* E:学生管理系统的删除学生的代码编写* F:学生管理系统的修改学生的代码编写*/
public class StudentManagerTest {public static void main(String[] args) {//创建集合对象，用于存储学生数据ArrayList<Student> array = new ArrayList<Student>();//为了让程序能够回到这里来，我们使用循环while(true) {//这是学生管理系统的主界面System.out.println("--------欢迎来到学生管理系统--------");System.out.println("1 查看所有学生");System.out.println("2 添加学生");System.out.println("3 删除学生");System.out.println("4 修改学生");System.out.println("5 退出");System.out.println("请输入你的选择：");//创建键盘录入对象Scanner sc = new Scanner(System.in);String choiceString = sc.nextLine();//用switch语句实现选择switch(choiceString) {case "1"://查看所有学生findAllStudent(array);break;case "2"://添加学生addStudent(array);break;case "3"://删除学生deleteStudent(array);break;case "4"://修改学生updateStudent(array);break;case "5"://退出System.out.println("谢谢你的使用");System.exit(0);           //JVM退出break;default:break;}}}//修改学生public static void updateStudent(ArrayList<Student> array) {//修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生//创建键盘录入对象Scanner sc = new Scanner(System.in);System.out.println("请输入你要修改的学生的学号：");String id = sc.nextLine();//定义一个索引int index = -1;//遍历集合for(int x=0; x<array.size(); x++) {//获取每一个学生对象Student s = array.get(x);//拿学生对象的学号和键盘录入的学号进行比较if(s.getId().equals(id)) {index = x;break;}}if(index == -1) {System.out.println("不好意思,你要修改的学号对应的学生信息不存在,请回去重新你的选择");}else {System.out.println("请输入学生新姓名：");String name = sc.nextLine();System.out.println("请输入学生新年龄：");String age = sc.nextLine();System.out.println("请输入学生新居住地：");String address = sc.nextLine();//创建学生对象Student s = new Student();s.setId(id);s.setName(name);s.setAge(age);s.setAddress(address);//修改集合中的学生对象array.set(index, s);//给出提示System.out.println("修改学生成功");}}//删除学生public static void deleteStudent(ArrayList<Student> array) {//删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生//创建键盘录入对象Scanner sc = new Scanner(System.in);System.out.println("请输入你要删除的学生的学号：");String id = sc.nextLine();/*//遍历集合for(int x=0; x<array.size(); x++) {//获取到每一个学生对象Student s = array.get(x);//拿这个学生对象的学号和键盘录入的学号进行比较if(s.getId().equals(id)) {array.remove(x); //根据索引删除break;}}//给出提示System.out.println("删除学生成功");*///我们必须给出学号不存在的时候的提示//定义一个索引int index = -1;//遍历集合for(int x=0; x<array.size(); x++) {//获取到每一个学生对象Student s = array.get(x);//拿这个学生对象的学号和键盘录入的学号进行比较if(s.getId().equals(id)) {index = x;break;}}if(index == -1) {System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择");}else {array.remove(index);System.out.println("删除学生成功");}}//添加学生public static void addStudent(ArrayList<Student> array) {//创建键盘录入对象Scanner sc = new Scanner(System.in);//为了让id能够被访问到，我们就把id定义在了循环的外面String id;//为了让代码能够回到这里，用循环while(true) {System.out.println("请输入学生学号：");//String id = sc.nextLine();id = sc.nextLine();//判断学号有没有被人占用//定义标记boolean flag = false;//遍历集合，得到每一个学生for(int x=0; x<array.size(); x++) {Student s = array.get(x);//获取该学生的学号，和键盘录入的学号进行比较if(s.getId().equals(id)) {flag = true; //说明学号被占用了break;}}if(flag) {System.out.println("你输入的学号已经被占用,请重新输入");}else {break; //结束循环}}System.out.println("请输入学生姓名：");String name = sc.nextLine();System.out.println("请输入学生年龄：");String age = sc.nextLine();System.out.println("请输入学生居住地：");String address = sc.nextLine();//创建学生对象Student s = new Student();s.setId(id);s.setName(name);s.setAge(age);s.setAddress(address);//把学生对象作为元素添加到集合array.add(s);//给出提示System.out.println("添加学生成功");}//查看所有学生public static void findAllStudent(ArrayList<Student> array) {//首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行if(array.size() == 0) {System.out.println("不好意思,目前没有学生信息可供查询,请回去重新选择你的操作");return;}//\t 其实就是一个tab键的位置System.out.println("学号\t姓名\t年龄\t居住地");for(int x=0; x<array.size(); x++) {Student s = array.get(x);System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());}}
}

运行结果：

"C:\Program Files\Java\jdk1.8.0_191\bin\java.exe" "-javaagent:D:\ruanJian\IDEA 2020-64bit\IntelliJ IDEA 2020.3.4\lib\idea_rt.jar=6380:D:\ruanJian\IDEA 2020-64bit\IntelliJ IDEA 2020.3.4\bin" -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_191\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_191\jre\lib\rt.jar;G:\代码编程资料\VIP项目孟哥998\ideaText\out\production\ideaText" demo9_List.StudentManagerTest
欢迎来到学生管理系统！
输入1：查看所有学生信息
输入2：添加学生信息
输入3：删除学生信息
输入4：修改学生信息
输入5：退出
请输入你的选择
1
没有数据，请添加数据再查询
2
请输入学号：
1
请输入学生的姓名
小何
请输入学生的年龄
23
请输入学生的地址
安徽
添加学生成功啦
4
不好意思，您要修改的学生信息不存在
1
学号  姓名  年龄  居住地
1   小何  23  安徽
4
1
请输入学生新姓名：
小丁
请输入学生新年龄：
21
请输入学生新居住地：
东北
修改成功
1
学号  姓名  年龄  居住地
1   小丁  21  东北
3
请输入想删除的学生的学号
1
删除成功
要删除的学生不存在
1
没有数据，请添加数据再查询
5Process finished with exit code 0