5.学生管理系统 - JavaSE | Yume Shoka = 123 = 456

# ArrayList

# ArrayList 类概述

什么是集合
提供一种存储空间可变的存储模型，存储的数据容量可以发生改变
ArrayList 集合的特点
底层是数组实现的，长度可以变化
泛型的使用
用于约束集合中存储元素的数据类型

# ArrayList 类常用方法

# 构造方法

方法名	说明
public ArrayList()	创建一个空的集合对象

# 成员方法

方法名	说明
public boolean remove(Object o)	删除指定的元素，返回删除是否成功
public E remove(int index)	删除指定索引处的元素，返回被删除的元素
public E set(int index,E element)	修改指定索引处的元素，返回被修改的元素
public E get(int index)	返回指定索引处的元素
public int size()	返回集合中的元素的个数
public boolean add(E e)	将指定的元素追加到此集合的末尾
public void add(int index,E element)	在此集合中的指定位置插入指定的元素

	public class ArrayListDemo02 {
	public static void main(String[] args) {
	ArrayList<String> array = new ArrayList<String>();
	array.add("hello");
	array.add("world");
	array.add("java");

	public boolean remove(Object o)：删除指定的元素，返回删除是否成功
	System.out.println(array.remove("world"));

	//public E remove (int index)：删除指定索引处的元素，返回被删除的元素
	// System.out.println(array.remove(1));

	//IndexOutOfBoundsException
	// System.out.println(array.remove(3));

	//public E set (int index,E element)：修改指定索引处的元素，返回被修改的元素
	// System.out.println(array.set(1,"javaee"));

	//IndexOutOfBoundsException
	// System.out.println(array.set(3,"javaee"));

	//public E get (int index)：返回指定索引处的元素
	// System.out.println(array.get(0));
	// System.out.println(array.get(1));
	// System.out.println(array.get(2));
	//System.out.println (array.get (3)); //？？？？？？自己测试

	//public int size ()：返回集合中的元素的个数
	System.out.println(array.size());

	// 输出集合
	System.out.println("array:" + array);
	}
	}

# ArrayList 存储字符串并遍历

创建一个存储字符串的集合，存储 3 个字符串元素，使用程序实现在控制台遍历该集合

	/*
	思路：
	1: 创建集合对象
	2: 往集合中添加字符串对象
	3: 遍历集合，首先要能够获取到集合中的每一个元素，这个通过 get (int index) 方法实现
	4: 遍历集合，其次要能够获取到集合的长度，这个通过 size () 方法实现
	5: 遍历集合的通用格式
	*/
	public class ArrayListTest01 {
	public static void main(String[] args) {
	// 创建集合对象
	ArrayList<String> array = new ArrayList<String>();

	// 往集合中添加字符串对象
	array.add("刘正风");
	array.add("左冷禅");
	array.add("风清扬");

	// 遍历集合，其次要能够获取到集合的长度，这个通过 size () 方法实现
	// System.out.println(array.size());

	// 遍历集合的通用格式
	for(int i=0; i<array.size(); i++) {
	String s = array.get(i);
	System.out.println(s);
	}
	}
	}

# ArrayList 存储学生对象并遍历

创建一个存储学生对象的集合，存储 3 个学生对象，使用程序实现在控制台遍历该集合

	/*
	思路：
	1: 定义学生类
	2: 创建集合对象
	3: 创建学生对象
	4: 添加学生对象到集合中
	5: 遍历集合，采用通用遍历格式实现
	*/
	public class ArrayListTest02 {
	public static void main(String[] args) {
	// 创建集合对象
	ArrayList<Student> array = new ArrayList<>();

	// 创建学生对象
	Student s1 = new Student("林青霞", 30);
	Student s2 = new Student("风清扬", 33);
	Student s3 = new Student("张曼玉", 18);

	// 添加学生对象到集合中
	array.add(s1);
	array.add(s2);
	array.add(s3);

	// 遍历集合，采用通用遍历格式实现
	for (int i = 0; i < array.size(); i++) {
	Student s = array.get(i);
	System.out.println(s.getName() + "," + s.getAge());
	}
	}
	}

# ArrayList 存储学生对象并遍历升级版

创建一个存储学生对象的集合，存储 3 个学生对象，使用程序实现在控制台遍历该集合

学生的姓名和年龄来自于键盘录入

	/*
	思路：
	1: 定义学生类，为了键盘录入数据方便，把学生类中的成员变量都定义为 String 类型
	2: 创建集合对象
	3: 键盘录入学生对象所需要的数据
	4: 创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
	5: 往集合中添加学生对象
	6: 遍历集合，采用通用遍历格式实现
	*/
	public class ArrayListTest {
	public static void main(String[] args) {
	// 创建集合对象
	ArrayList<Student> array = new ArrayList<Student>();

	// 为了提高代码的复用性，我们用方法来改进程序
	addStudent(array);
	addStudent(array);
	addStudent(array);

	// 遍历集合，采用通用遍历格式实现
	for (int i = 0; i < array.size(); i++) {
	Student s = array.get(i);
	System.out.println(s.getName() + "," + s.getAge());
	}
	}

	/*
	两个明确：
	返回值类型：void
	参数：ArrayList<Student> array
	*/
	public static void addStudent(ArrayList<Student> array) {
	// 键盘录入学生对象所需要的数据
	Scanner sc = new Scanner(System.in);

	System.out.println("请输入学生姓名:");
	String name = sc.nextLine();

	System.out.println("请输入学生年龄:");
	String age = sc.nextLine();

	// 创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
	Student s = new Student();
	s.setName(name);
	s.setAge(age);

	// 往集合中添加学生对象
	array.add(s);
	}
	}

# 学生管理系统

# 学生管理系统实现步骤

案例需求
针对目前我们的所学内容，完成一个综合案例：学生管理系统！该系统主要功能如下：
添加学生：通过键盘录入学生信息，添加到集合中
删除学生：通过键盘录入要删除学生的学号，将该学生对象从集合中删除
修改学生：通过键盘录入要修改学生的学号，将该学生对象其他信息进行修改
查看学生：将集合中的学生对象信息进行展示
退出系统：结束程序
实现步骤
1. 定义学生类，包含以下成员变量
  private String sid // 学生 id
  private String name // 学生姓名
  private String age // 学生年龄
  private String address // 学生所在地
2. 学生管理系统主界面的搭建步骤
  2.1 用输出语句完成主界面的编写
  2.2 用 Scanner 实现键盘输入
  2.3 用 switch 语句完成选择的功能
  2.4 用循环完成功能结束后再次回到主界面
3. 学生管理系统的添加学生功能实现步骤
  3.1 定义一个方法，接收 ArrayList<Student> 集合
  3.2 方法内完成添加学生的功能
  ①键盘录入学生信息
  ②根据录入的信息创建学生对象
  ③将学生对象添加到集合中
  ④提示添加成功信息
  3.3 在添加学生的选项里调用添加学生的方法
4. 学生管理系统的查看学生功能实现步骤
  4.1 定义一个方法，接收 ArrayList<Student> 集合
  4.2 方法内遍历集合，将学生信息进行输出
  4.3 在查看所有学生选项里调用查看学生方法
5. 学生管理系统的删除学生功能实现步骤
  5.1 定义一个方法，接收 ArrayList<Student> 集合
  5.2 方法中接收要删除学生的学号
  5.3 遍历集合，获取每个学生对象
  5.4 使用学生对象的学号和录入的要删除的学号进行比较，如果相同，则将当前学生对象从集合中删除
  5.5 在删除学生选项里调用删除学生的方法
6. 学生管理系统的修改学生功能实现步骤
  6.1 定义一个方法，接收 ArrayList<Student> 集合
  6.2 方法中接收要修改学生的学号
  6.3 通过键盘录入学生对象所需的信息，并创建对象
  6.4 遍历集合，获取每一个学生对象。并和录入的修改学生学号进行比较。如果相同，则使用新学生对象替换当前学生对象
  6.5 在修改学生选项里调用修改学生的方法
7. 退出系统
  使用 System.exit (0); 退出 JVM

# 学生类的定义

	public class Student {
	private String sid;
	private String name;
	private String age;
	private String address;

	public Student() {
	}

	public Student(String sid, String name, String age, String address) {
	this.sid = sid;
	this.name = name;
	this.age = age;
	this.address = address;
	}

	public String getSid() {
	return sid;
	}

	public void setSid(String sid) {
	this.sid = sid;
	}

	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;
	}

	}

# 测试类的定义

	public class StudentManager {
	/*
	1: 用输出语句完成主界面的编写
	2: 用 Scanner 实现键盘录入数据
	3: 用 switch 语句完成操作的选择
	4: 用循环完成再次回到主界面
	*/
	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 实现键盘录入数据
	Scanner sc = new Scanner(System.in);
	String line = sc.nextLine();

	// 用 switch 语句完成操作的选择
	switch (line) {
	case "1":
	addStudent(array);
	break;
	case "2":
	deleteStudent(array);
	break;
	case "3":
	updateStudent(array);
	break;
	case "4":
	findAllStudent(array);
	break;
	case "5":
	System.out.println("谢谢使用");
	System.exit(0); //JVM 退出
	}
	}
	}

	// 定义一个方法，用于添加学生信息
	public static void addStudent(ArrayList<Student> array) {
	// 键盘录入学生对象所需要的数据，显示提示信息，提示要输入何种信息
	Scanner sc = new Scanner(System.in);

	String sid;

	while (true) {
	System.out.println("请输入学生学号：");
	sid = sc.nextLine();

	boolean flag = isUsed(array, sid);
	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.setSid(sid);
	s.setName(name);
	s.setAge(age);
	s.setAddress(address);

	// 将学生对象添加到集合中
	array.add(s);

	// 给出添加成功提示
	System.out.println("添加学生成功");
	}

	// 定义一个方法，判断学号是否被使用
	public static boolean isUsed(ArrayList<Student> array, String sid) {
	// 如果与集合中的某一个学生学号相同，返回 true; 如果都不相同，返回 false
	boolean flag = false;

	for(int i=0; i<array.size(); i++) {
	Student s = array.get(i);
	if(s.getSid().equals(sid)) {
	flag = true;
	break;
	}
	}

	return flag;
	}


	// 定义一个方法，用于查看学生信息
	public static void findAllStudent(ArrayList<Student> array) {
	// 判断集合中是否有数据，如果没有显示提示信息
	if (array.size() == 0) {
	System.out.println("无信息，请先添加信息再查询");
	// 为了让程序不再往下执行，我们在这里写上 return;
	return;
	}

	// 显示表头信息
	//\t 其实是一个 tab 键的位置
	System.out.println("学号\t\t\t姓名\t\t年龄\t\t居住地");

	// 将集合中数据取出按照对应格式显示学生信息，年龄显示补充 “岁”
	for (int i = 0; i < array.size(); i++) {
	Student s = array.get(i);
	System.out.println(s.getSid() + "\t" + s.getName() + "\t" + s.getAge() + "岁\t\t" + s.getAddress());
	}
	}

	// 定义一个方法，用于删除学生信息
	public static void deleteStudent(ArrayList<Student> array) {
	// 键盘录入要删除的学生学号，显示提示信息
	Scanner sc = new Scanner(System.in);

	System.out.println("请输入你要删除的学生的学号：");
	String sid = sc.nextLine();

	// 在删除 / 修改学生操作前，对学号是否存在进行判断
	// 如果不存在，显示提示信息
	// 如果存在，执行删除 / 修改操作

	int index = -1;

	for (int i = 0; i < array.size(); i++) {
	Student s = array.get(i);
	if (s.getSid().equals(sid)) {
	index = i;
	break;
	}
	}

	if (index == -1) {
	System.out.println("该信息不存在，请重新输入");
	} else {
	array.remove(index);
	// 给出删除成功提示
	System.out.println("删除学生成功");
	}
	}

	// 定义一个方法，用于修改学生信息
	public static void updateStudent(ArrayList<Student> array) {
	// 键盘录入要修改的学生学号，显示提示信息
	Scanner sc = new Scanner(System.in);

	System.out.println("请输入你要修改的学生的学号：");
	String sid = sc.nextLine();

	// 键盘录入要修改的学生信息
	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.setSid(sid);
	s.setName(name);
	s.setAge(age);
	s.setAddress(address);

	// 遍历集合修改对应的学生信息
	for (int i = 0; i < array.size(); i++) {
	Student student = array.get(i);
	if (student.getSid().equals(sid)) {
	array.set(i, s);
	}
	}

	// 给出修改成功提示
	System.out.println("修改学生成功");
	}
	}

# 继承

# 继承的实现

继承的概念
- 继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法
实现继承的格式
- 继承通过 extends 实现
- 格式：class 子类 extends 父类
  - 举例：class Dog extends Animal
继承带来的好处
- 继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类则可以使用父类中非私有的成员。

示例代码

	public class Fu {
	public void show() {
	System.out.println("show方法被调用");
	}
	}
	public class Zi extends Fu {
	public void method() {
	System.out.println("method方法被调用");
	}
	}
	public class Demo {
	public static void main(String[] args) {
	// 创建对象，调用方法
	Fu f = new Fu();
	f.show();

	Zi z = new Zi();
	z.method();
	z.show();
	}
	}

# 继承好处和弊端

继承好处
- 提高了代码的复用性 (多个类相同的成员可以放到同一个类中)
- 提高了代码的维护性 (如果方法的代码需要修改，修改一处即可)
继承弊端
- 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
继承的应用场景：
- 使用继承，需要考虑类与类之间是否存在 is..a 的关系，不能盲目使用继承
  - is..a 的关系：谁是谁的一种，例如：老师和学生是人的一种，那人就是父类，学生和老师就是子类

# 继承中的成员访问特点

# 继承中变量的访问特点

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错 (不考虑父亲的父亲…)

	class Fu {
	int num = 10;
	}
	class Zi {
	int num = 20;
	public void show(){
	int num = 30;
	System.out.println(num);
	}
	}
	public class Demo1 {
	public static void main(String[] args) {
	Zi z = new Zi();
	z.show(); // 输出 show 方法中的局部变量 30
	}
	}

# super

this&super 关键字：
- this：代表本类对象的引用
- super：代表父类存储空间的标识 (可以理解为父类对象引用)
this 和 super 的使用分别
- 成员变量：
  - this. 成员变量 - 访问本类成员变量
  - super. 成员变量 - 访问父类成员变量
- 成员方法：
  - this. 成员方法 - 访问本类成员方法
  - super. 成员方法 - 访问父类成员方法
构造方法：
- this (…) - 访问本类构造方法
- super (…) - 访问父类构造方法

# 继承中构造方法的访问特点

注意：子类中所有的构造方法默认都会访问父类中无参的构造方法

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化，原因在于，每一个子类构造方法的第一条语句默认都是：super ()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

1. 通过使用super关键字去显示的调用父类的带参构造方法
2. 在父类中自己提供一个无参构造方法

推荐方案：

自己给出无参构造方法

# 继承中成员方法的访问特点

通过子类对象访问一个方法

子类成员范围找
父类成员范围找
如果都没有就报错 (不考虑父亲的父亲…)

# super 内存图

对象在堆内存中，会单独存在一块 super 区域，用来存放父类的数据

# 方法重写

1、方法重写概念
- 子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）
2、方法重写的应用场景
- 当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
3、Override 注解
- 用来检测当前的方法，是否是重写的方法，起到【校验】的作用

# 方法重写的注意事项

方法重写的注意事项

私有方法不能被重写 (父类私有成员子类是不能继承的)
子类方法访问权限不能更低 (public> 默认 > 私有)

示例代码

	public class Fu {
	private void show() {
	System.out.println("Fu中show()方法被调用");
	}

	void method() {
	System.out.println("Fu中method()方法被调用");
	}
	}

	public class Zi extends Fu {

	/* 编译【出错】，子类不能重写父类私有的方法 */
	@Override
	private void show() {
	System.out.println("Zi中show()方法被调用");
	}

	/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
	@Override
	private void method() {
	System.out.println("Zi中method()方法被调用");
	}

	/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
	@Override
	public void method() {
	System.out.println("Zi中method()方法被调用");
	}
	}

# Java 中继承的注意事项

Java 中继承的注意事项
1. Java 中类只支持单继承，不支持多继承
  - 错误范例：class A extends B, C
2. Java 中类支持多层继承

多层继承示例代码：

	public class Granddad {

	public void drink() {
	System.out.println("爷爷爱喝酒");
	}

	}

	public class Father extends Granddad {

	public void smoke() {
	System.out.println("爸爸爱抽烟");
	}

	}

	public class Mother {

	public void dance() {
	System.out.println("妈妈爱跳舞");
	}

	}
	public class Son extends Father {
	// 此时，Son 类中就同时拥有 drink 方法以及 smoke 方法
	}

# 继承练习

# 老师和学生

需求：定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试
步骤：
①定义老师类 (姓名，年龄，教书 ())
②定义学生类 (姓名，年龄，学习 ())
③定义测试类，写代码测试
④共性抽取父类，定义人类 (姓名，年龄)
⑤定义老师类，继承人类，并给出自己特有方法：教书 ()
⑥定义学生类，继承人类，并给出自己特有方法：学习 ()
⑦定义测试类，写代码测试

示例代码：

	class Person {
	private String name;
	private int age;

	public Person() {
	}

	public Person(String name, int age) {
	this.name = name;
	this.age = 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;
	}
	}

	class Teacher extends Person {

	public Teacher() {}

	public Teacher(String name,int age) {
	super(name,age);
	}

	public void teach() {
	System.out.println("用爱成就每一位学员");
	}

	}

	class Student extends Person{
	public Student() {}

	public Student(String name, int age) {
	super(name,age);
	}

	public void study(){
	System.out.println("学生学习");
	}

	}

	class PersonDemo {
	public static void main(String[] args){
	// 创建老师类对象并进行测试
	Teacher t1 = new Teacher();
	t1.setName("林青霞");
	t1.setAge(30);
	System.out.println(t1.getName() + "," + t1.getAge());
	t1.teach();


	Teacher t2 = new Teacher("风清扬", 33);
	System.out.println(t2.getName() + "," + t2.getAge());
	t2.teach();

	// 创建学生类对象测试
	Student s = new Student("张三"，23)；
	System.out.println(s.getName() + "," + s.getAge());
	s.study();
	}
	}

# 猫和狗

需求：请采用继承的思想实现猫和狗的案例，并在测试类中进行测试
分析：
①猫：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set 方法，抓老鼠 ()
②狗：
成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set 方法，看门 ()
③共性：
成员变量：姓名，年龄；构造方法：无参，带参；成员方法：get/set 方法
步骤：
1、定义动物类 (Animal)
【成员变量：姓名，年龄】【构造方法：无参，带参】【成员方法：get/set 方法】
2、定义猫类 (Cat)，继承动物类
【构造方法：无参，带参】【成员方法：抓老鼠 () 】
3、定义狗类 (Dog)，继承动物类
【构造方法：无参，带参】【成员方法：看门 () 】
4、定义测试类 (AnimalDemo)，写代码测试