第1章 面向对象
1.1 理解什么是面向过程、面向对象
面向过程与面向对象都是我们编程中，编写程序的一种思维方式。
面向过程的程序设计方式，是遇到一件事时，思考“我该怎么做”，然后一步步实现的过程。
例如：公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），按照面向过程的程序设计方式会思考“打扫卫生我该怎么做，然后一件件的完成”，最后把公司卫生打扫干净了。
面向对象的程序设计方式，是遇到一件事时，思考“我该让谁来做”，然后那个“谁”就是对象，他要怎么做这件事是他自己的事，反正最后一群对象合力能把事就好就行了。
例如，公司打扫卫生（擦玻璃、扫地、拖地、倒垃圾等），按照面向对象的程序设计方式会思考“我该让谁来做，如小明擦玻璃、让小丽扫地、让小郭拖地、让小强倒垃圾等”,这里的“小明、小丽、小郭、小强”就是对象，他们要打扫卫生，怎么打扫是他们自己的事，反正最后一群对象合力把公司卫生打扫干净了。
1.2 面向对象举例
买电脑（组装机）
先使用面向过程说明买电脑这件事：假如我们需要买组装电脑，这时首先会在网上查询具体每一个硬件的参数和报价。然后会去电脑城进行多家询价，接着询价结束后回家根据具体的结果分析出自己比较满意的哪家报价，接着会到这家店里进行组装，组装时还需要进行现场监督，组装完成安装相应的系统，然后电脑抱回家。
分析上述整个过程大体分一下几步：上网查询参数和报价、电脑城询价、现场安装和监督、抱电脑回家。在整个过程中我们参与了每一个细节，并且会感觉相当累。
使用面向对象说明买电脑这件事：假如我们需要买组装机，这时应该找一个懂电脑硬件的人，让他帮我们查看参数和报价，并进行询价和杀价，以及现场组装监督。而我们自己并不需要亲历亲为具体怎么做，只要告诉这个人我们想要的具体需求即可。
分析上述整个过程，发现瞬间变的十分轻松，只要找到懂电脑硬件的这个人，我们的问题都可以解决。并且在这个过程中我们不用那么辛苦。
1.3 面向对象思维方式的好处
通过生活中的真实场景使用面向对象分析完之后，我们开始分析面向过程和面向对象的差异做出总结：
面向对象思维方式是一种更符合人们思考习惯的思想
面向过程思维方式中更多的体现的是执行者（自己做事情），面向对象中更多的体现是指挥者（指挥对象做事情）。
面向对象思维方式将复杂的问题简单化。
世界万物皆对象
第2章 类与对象
2.1 对象在需求中的使用
对面向对象有了了解之后，我们来说说在具体问题中如何使用面向对象去分析问题，和如何使用面向对象。
我们把大象装冰箱为例进行分析。
在针对具体的需求，可以使用名词提炼的办法进行分析，寻找具体的对象。
需求：把大象装冰箱里
对象：大象、冰箱
分三步：
1、打开冰箱门
2、将大象装进去
3、关闭冰箱门
分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能：
冰箱打开
冰箱存储
冰箱关闭
用伪代码描述，上述需求中有两个具体的事物 大象 和 冰箱
描述大象：
class 大象
{
}
描述冰箱
class冰箱
{
void 打开(){}
void 存储(大象){}
void 关闭(){}
}
当把具体的事物描述清楚之后，需要使用这些具体的事物，Java使用具体的事物，需要通过new关键字来创建这个事物的具体实例。
使用对象：
1、创建冰箱的对象
冰箱 bx = new 冰箱();
2、调用冰箱的功能
对象.功能()；
bx.打开();
bx.存储(new 大象());
bx.关闭();
总结：
1、先按照名词提炼问题领域中的对象
2、对对象进行描述，其实就是在明确对象中应该具备的属性和功能
3、通过new的方式就可以创建该事物的具体对象
4、通过该对象调用它以后的功能。
2.2 对象在代码中的体现
在分析现实生活中的事物时发现，这些事物都有其具体的特点和功能，这些特点和功能就组成了这个特殊的事物。
描述小汽车。
分析：
事物的特点（属性）：
颜色。
轮胎个数。
事物的(功能)：
运行。
发现：事物其实就是由特点（属性）和行为（功能）组成的。
可以简单理解：属性就是数值，其实就是变量；行为就是功能，就是方法。
小汽车 {
颜色；
轮胎个数；
运行() { }
}
通过计算机语言Java来描述这个事物。
定义类的格式
public class 类名 {
//可编写0至n个属性
数据类型 变量名1；
数据类型 变量名2；
//可编写0至n个方法
修饰符 返回值类型 方法名(参数){
执行语句;
}
}
汽车类
public class Car {
String color;
int number;
void run() {
System.out.println(color + ":" + number);
}
}
通过代码的描述，知道类的真正意义就是在描述事物。属性和功能统称为事物中的成员。
事物的成员分为两种：成员属性和成员功能。
成员属性在代码中的体现就是成员变量
成员功能在代码中的体现就是成员方法
把写好的代码测试一下。需要一个可以独立运行类。
创建对象的格式：
类名 对象名 = new 类名();
测试类
public class CarDemo {
public static void main(String[] args) {
/*
* 测试：Car类中的run方法。
*/
// 1,创建Car的对象。给对象起个名字。
Car c = new Car();// c是类类型的变量。c指向了一个具体的Car类型的对象。
// 2,通过已有的对象调用该对象的功能。格式：对象.对象成员;
// 3,可以该对象的属性赋值。
c.color = "red";
c.number = 4;
c.run();
}
}
2.3 对象的内存图解
经过上面对小汽车的描述，和Java代码测试，我们虽然可以将生活中的事物使用Java代码描述出来，但是这些代码在内存中是如何执行的，接下来我们需要研究下对象在内存的图解。
接下来就是分析对象在内存中的分配情况。这里需要画图一步一步演示，严格按照画图流程讲解内存对象创建过程。
package cn.itcast.demo01;
/*
* 类的方式,描述现实中的事物小汽车
*
* 小汽车 属性和功能
* 属性：颜色 轮胎个数 变量定义
* 功能：跑--方法
*
* 属性和方法,都属于类的成员
* 属性,成员变量
* 方法,成员方法
*/
public class Car {
//定义Car类的属性
//定义颜色属性
String color;
//定义轮胎个数
int count;
//定义跑的功能
public void run(){
System.out.println("小汽车在跑" + "..." + color + "..." + count);
}
}
package cn.itcast.demo01;
/*
* 测试,自定义的类Car
* 创建出Car类的变量
* 变量,调用属性,成员变量
* 变量,调用方法
*/
public class CarTest {
public static void main(String[] args) {
//创建出Car类的变量,创建出Car类型的对象,小汽车真的有了
Car c = new Car();
//对象.调用类中的属性和方法
c.color = "黑色";
c.count = 5;
c.run();
}
}
2.4 类和对象的区别
面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，**面向对象的思想中提出两个概念，即类和对象。其中，类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。**接下来通过一个图例来抽象描述类与对象的关系，如下图所示。
在上图中，可以将玩具模型看作是一个类，将一个个玩具看作对象，从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。从上图中可以明显看出对象是根据类创建的，并且一个类可以对应多个对象，接下来分别讲解什么是类和对象。
经过前面几个知识点的学习，基本上掌握了类是用于描述事物的，类中可以定义事物的属性和行为。而对象是通过描述的这个类，使用new关键字创建出来，通过对象就可以调用该对象具体的属性和功能了。
2.5 局部变量和成员变量区别
理解清楚了类和对象之后，结合前5天的学习知识，发现在描述类的属性和前面学习定义变量差别不大，唯一区别就是位置发生了改变，那么类中定义的变量，和在方法定义的变量有啥差别呢？
回忆以前学习时变量的定义方式，和位置，以及现在定义类中属性的特点。总结下面几点异同
区别一：定义的位置不同
定义在类中的变量是成员变量
定义在方法中或者{}语句里面的变量是局部变量
区别二：在内存中的位置不同
成员变量存储在对内存的对象中
局部变量存储在栈内存的方法中
区别三：声明周期不同
成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失
局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失
区别四：初始化不同
成员变量因为在堆内存中，所有默认的初始化值
局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。
package cn.itcast.demo02;
public class Car {
//定义Car类的属性
//定义颜色属性
String color;
//定义轮胎个数
int count;
//定义跑的功能
public void run(){
int x = 1;//he value of the local variable x is not used局部变量需要赋值
System.out.println(x);
System.out.println("小汽车在跑" + "..." + color + "..." + count);
}
}
package cn.itcast.demo02;
/*
*** 成员变量和局部变量的区别
* 1.定义位置上的区别
* 成员变量,定义在类中,方法外
* 局部变量,方法内,语句内
* 2.作用域不同
* 成员变量,作用范围是整个类
* 局部变量,方法内,语句内
* 前两个最重要,因为我们看得到,摸得着
* 3.默认值不同
* 成员变量,有自己的默认值,String - null int - 0 double - 0.0 布尔型-false
* 局部变量,没有默认值,不赋值就不能使用
* 4.内存位置不同
* 成员变量,跟随对象进入堆内存中,并且赋默认值
* 局部变量,跟随自己的方法,进入栈内存
* 5.生命周期不同
* 成员变量,跟随对象,在堆中存储,在内存中等等JVM虚拟机清理,生命周期相对较长
* 局部变量,跟随方法,方法弹出栈,生命周期相对较短**
*/
public class CarTest {
public static void main(String[] args) {
//创建出Car类的变量,创建出Car类型的对象,小汽车真的有了
Car c = new Car();
//对象.调用类中的属性和方法
c.color = "黑色";
c.count = 5;
c.run();
}
}
成员变量和局部变量的区别
1.定义位置上的区别
成员变量,定义在类中,方法外
局部变量,方法内,语句内
2.作用域不同
成员变量,作用范围是整个类
局部变量,方法内,语句内
前两个最重要,因为我们看得到,摸得着
3.默认值不同
成员变量,有自己的默认值,String - null int - 0 double - 0.0 布尔型-false
局部变量,没有默认值,不赋值就不能使用
4.内存位置不同
成员变量,跟随对象进入堆内存中,并且赋默认值
局部变量,跟随自己的方法,进入栈内存
5.生命周期不同
成员变量,跟随对象,在堆中存储,在内存中等等JVM虚拟机清理,生命周期相对较长
局部变量,跟随方法,方法弹出栈,生命周期相对较短
2.6 基本类型和引用类型作为参数传递
引用类型数据和基本类型数据作为参数传递有没有差别呢？我们用如下代码进行说明，并配合图解让大家更加清晰
class Demo
{
public static void main(String[] args)
{
int x = 4;
show(x);
System.out.println(“x=”+x);
}
public static void show(int x)
{
x = 5;
}
}
基本类型作为参数传递时，其实就是将基本类型变量x空间中的值复制了一份传递给调用的方法show()，当在show()方法中x接受到了复制的值，再在show()方法中对x变量进行操作，这时只会影响到show中的x。当show方法执行完成，弹栈后，程序又回到main方法执行，main方法中的x值还是原来的值。
class Demo
{
int x ;
public static void main(String[] args)
{
Demo d = new Demo();
d.x = 5;
show(d);
System.out.println("x="+d.x);
}
public static void show(Demo d)
{
d.x = 6;
}
}
当引用变量作为参数传递时，这时其实是将引用变量空间中的内存地址(引用)复制了一份传递给了show方法的d引用变量。这时会有两个引用同时指向堆中的同一个对象。当执行show方法中的d.x=6时，会根据d所持有的引用找到堆中的对象，并将其x属性的值改为6.show方法弹栈。
由于是两个引用指向同一个对象，不管是哪一个引用改变了引用的所指向的对象的中的值，其他引用再次使用都是改变后的值。
package cn.itcast.demo03;
/*
*
*/
public class Person {
String name;
}
package cn.itcast.demo03;
/*
* 方法的参数类型,是基本数据类型,引用数据类型
*/
public class PersonTest {
public static void main(String[] args) {
int a = 1;
function(a);
System.out.println(a);//1
Person p = new Person();
p.name = "张三";
System.out.println("初始赋值:" + p.name);
function(p);
System.out.println("调用function函数赋值:" + p.name);
}
/*
* 定义方法,参数类型是引用数据类型
*/
public static void function(Person p){
p.name = "李四";
}
/*
* 定义方法,参数类型是基本数据类型
*/
public static void function(int a){
a += 5;
}
}
第3章 封装
3.1 封装概述
提起封装，大家并不陌生。前面我们学习方法时，就提起过，将具体功能封装到方法中，学习对象时，也提过将方法封装在类中，其实这些都是封装。
封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。接下来我们具体学习封装。
封装表现：
1、方法就是一个最基本封装体。
2、类其实也是一个封装体。
从以上两点得出结论，封装的好处：
1、提高了代码的复用性。
2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。
3、提高了安全性。
3.2 封装举例
机箱：
一台电脑，它是由CPU、主板、显卡、内存、硬盘、电源等部件组长，其实我们将这些部件组装在一起就可以使用电脑了，但是发现这些部件都散落在外面，很容造成不安全因素，于是，使用机箱壳子，把这些部件都装在里面，并在机箱壳上留下一些插口等，若不留插口，大家想想会是什么情况。
总结：机箱其实就是隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。
3.3 私有private
了解到封装在生活的体现之后，又要回到Java中，细说封装的在Java代码中的体现，先从描述Person说起。
描述人。Person
属性：年龄。
行为：说话：说出自己的年龄。
class Person {
int age;
String name;
public void show() {
System.out.println("age=" + age + ",name" + name);
}
}
public class PersonDemo {
public static void main(String[] args) {
// 创建Person对象
Person p = new Person();
p.age = -20; // 给Person对象赋值
p.name = "人妖";
p.show(); // 调用Person的show方法
}
}
通过上述代码发现，虽然我们用Java代码把Person描述清楚了，但有个严重的问题，就是Person中的属性的行为可以任意访问和使用。这明显不符合实际需求。
可是怎么才能不让访问呢？需要使用一个Java中的关键字也是一个修饰符 private(私有，权限修饰符)。只要将Person的属性和行为私有起来，这样就无法直接访问。
class Person {
private int age;
private String name;
public void show() {
System.out.println("age=" + age + ",name" + name);
}
}
年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了，这样还是不行，那肿么办呢？按照之前所学习的封装的原理，隐藏后，还需要提供访问方式。只要对外提供可以访问的方法，让其他程序访问这些方法。同时在方法中可以对数据进行验证。
一般对成员属性的访问动作：赋值(设置 set)，取值(获取 get)，因此对私有的变量访问的方式可以提供对应的 setXxx或者getXxx的方法。
class Person {
// 私有成员变量
private int age;
private String name;
// 对外提供设置成员变量的方法
public void setAge(int a) {
// 由于是设置成员变量的值，这里可以加入数据的验证
if (a < 0 || a > 130) {
System.out.println(a + "不符合年龄的数据范围");
return;
}
age = a;
}
// 对外提供访问成员变量的方法
public void getAge() {
return age;
}
}
总结：
类中不需要对外提供的内容都私有化，包括属性和方法。
以后再描述事物，属性都私有化，并提供setXxx getXxx方法对其进行访问。
注意：私有仅仅是封装的体现形式而已。
package cn.itcast.demo04;
/*
* 描述现实生活中的人-这个事物
* 属性:姓名 年龄--成员变量
* 功能:说话--方法
*
* 出现安全问题,age问题,可能出现赋值为负数的情况
* 负数不会导致程序问题,违反生活中的真实情况
*
* 提高安全问题:让外面的类,不允许直接调用我的成员变量
* 新的关键字private 私有 属于成员修饰符,不能修饰局部变量
* 被private修饰的成员,只能在自己类中被使用
*
*对私有变量,提供公共的访问方式:方法
*/
public class Person {
//人的姓名,成员变量
String name;
//人的年龄,成员变量
private int age;
//变量age被私有化,提供方法,让外面的类来使用
//定义方法,对age变量进行赋值,方法名字,必须set开头
public void setAge(int a){
//对变量参数a进行范围的限制
if(a <=0 || a > 100){
//如果a超过范围,手动将age赋值为20
age = 20;
}else{
//如果a没有超过范围,直接对age赋值
age = a;
}
}
//定义方法,对变量age获取值来使用,方法名字必须get开头
public int getAge(){
return age;
}
//定义人的说话功能,方法中,要求说出自己的姓名和年龄
public void speak(){
System.out.println(name + "..." + age);
}
}
package cn.itcast.demo04;
/*
* 定义好的Person类进行测试
* 创建对象,对象调用属性和方法
*/
public class PersonTest {
public static void main(String[] args) {
//创建Person类的对象 new
Person p = new Person();
//对成员变量赋值
//对私有成员变量age赋值,只能使用Set方法赋值
p.setAge(22);
p.name = "张三";
//调用类中的方法
p.speak();
//输出成员变量age值,必须调用getAge方法
System.out.println(p.getAge());
}
}
3.4 this关键字
3.4.1 成员变量和局部变量同名问题
当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？可以在成员变量名前面加上this.来区别成员变量和局部变量
class Person {
private int age;
private String name;
public void speak() {
this.name = "小强";
this.age = 18;
System.out.println("name=" + this.name + ",age=" + this.age);
}
}
class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
p.speak();
}
}
3.4.2 对象的内存解释
我们已经学习了如何把生活中的事物使用Java代码描述，接下来我们分析对象在内存中的分配情况。这里需要画图一步一步演示，严格按照画图流程讲解内存对象创建使用过程。
class Person {
private int age;
public int getAge() {
return this.age;
}
public void setAge(int age) {
this.age = age;
}
}
public class PersonDemo {
public static void main(String[] args) {
Person p = new Person();
p.setAge(30);
System.out.println("大家好，今年我" + p.getAge() + "岁");
}
}
下图为程序中内存对象的创建使用过程。
程序执行流程说明：
1、 先执行main方法（压栈），执行其中的 Person p = new Person()；
2、 在堆内存中开辟空间，并为其分配内存地址0x1234，紧接着成员变量默认初始化(age = 0)；将内存地址0x1234赋值给栈内中的Person p 变量
3、 继续执行p.setAge(30)语句，这时会调用setAge(int age)方法，将30赋值为setAge方法中的“age”变量；执行this.age = age语句，将age变量值30 赋值给成员变量this.age为30；
4、 setAge()方法执行完毕后（弹栈），回到main()方法，执行输出语句System.out.println()，控制台打印p对象中的age年龄值。
注意：
this到底代表什么呢？this代表的是对象，具体代表哪个对象呢？哪个对象调用了this所在的方法，this就代表哪个对象。
上述代码中的 p.setAge(30)语句中，setAge(int age)方法中的this代表的就是p对象。
3.4.3 this的应用
学习this的用法之后，现在做个小小的练习。
需求：在Person类中定义功能，判断两个人是否是同龄人
package cn.itcast.demo06;
public class Person {
private String name;
private int age;
public void setName(String name){
this.name = name;
}
public void setAge(int age){
this.age = age;
}
public void speak(){
System.out.println("人的名字:" + this.name + " 人的年龄：" + this.age);
}
/*
* 定义方法,与别人比较年龄大小
* 返回值:布尔型
* 参数：Person
*/
public boolean compare(Person p){
return (this.age == p.age);
}
}
package cn.itcast.demo06;
public class PersonTest {
public static void main(String[] args) {
//创建2个Person的实例对象
Person p1 = new Person();
Person p2 = new Person();
p1.setAge(15);
p2.setAge(16);
//p1对象调用自己的方法compare传递p2对象
boolean b = p1.compare(p2);
System.out.println(b);
}
}
第4章 综合案例—随机点名案例重构
4.1 案例介绍
随机点名器，即在全班同学中随机的找出一名同学，打印这名同学的个人信息。
此案例在我们前几天课程学习中，已经介绍，现在我们要做的是对原有的案例进行升级，使用新的方式来实现。
我们来完成随机点名器，它具备以下3个内容：
存储所有同学姓名
总览全班同学姓名
随机点名其中一人，打印到控制台
4.2 案例分析
全班同学中随机的找出一名同学，打印这名同学的个人信息。
我们对本案例进行分析，得出如下分析结果：
1.存储全班同学信息（姓名、年龄）
2.打印全班同学每一个人的信息（姓名、年龄）
3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学信息（姓名、年龄）并打印
随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。
而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们采用ArrayList集合来解决多个学生信息的存储问题。
4.3 重构内容分析
将原来使用的简单Student类，封装为包装属性和方法的相对完整的Student类，并将所有访问属性的地方改为通过get/set方法访问。
重构部分已使用红色样色字体表示
4.4 实现代码
package cn.itcast.demo07;
/*
* 学生类：
* 属性：姓名,年龄
*/
public class Student {
String name;
int age;
public void setName(String name){
this.name = name;
}
public void setAge(int age){
if(age <=0 || age > 100){
this.age = 20;
}else{
this.age = age;
}
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
}
package cn.itcast.demo07;
import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;
/*
* 随机点名器
* 现实中有学生这个事物,使用定义类的形式,描述学生事物
* 属性：姓名,年龄
* 姓名存储了数组,将容器换成是集合
*
* 存储学生:
* 学生类型,存储到集合中
*
* 总览：遍历集合
* 随机：随机数类Random,随机数,作为索引,到集合中找到元素
*
* 三个功能,共享的数据,集合容器
* 定义三个方法,必须参数传递集合
*
* 类-引用数据类型,与之前学习的所有引用数据类型相同
* 自定义类也是一种数据类型
* 只是自定义数据类型并非Java为我们预先提供好的类型,而是我们自己定义的一种引用数据类型来描述事物
*
* 创建集合的常用格式在此说明一下：
* C1:导包：import java.util.ArrayList;
* C2:创建对象：与其他普通的引用数据类型创建方式完全相同,但是要指定容器中存储的数据类型
* C:ArrayList<存储元素的数据类型> 变量名 = new ArrayList<存储元素的数据类型>();
* <存储元素的数据类型> ===> 中的数据类型必须是引用数据类型,不能是基本数据类型
*
* 类的名字：首字母大写,第二个字母首字母大写,例如：BeiJing
* public classs HelloWorld{
*
* }
* 方法的名字：首字母小写,每个单词首字母大写,例如:addSchool
* public static void main(String[] args){}
*
*随机数类Random：
*R1：导包：import java.util.Random
*R2:创建实例格式:Random 变量名 = new Random();
*R3:调用方法：
* public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
* public double nextDouble() 产生[0,1)范围的随机小数，包含0.0，不包含1.0。
*
*/
public class CallName {
public static void main(String[] args) {
//1.定义集合ArrayList,存储Student类型
ArrayList<Student> array = new ArrayList<Student>();
//2.调用添加方法
addStudent(array);
//3.进入死循环
//(原因:只允许按到数字3退出系统,才结束整个系统,否则一直循环,由于不知道循环次数,一般采用while循环)
while(true){
//4.调用输入选择数字功能,键盘输入需要的功能对应的数字
int choose = chooseFunction();
//5.对序号判断:1-进入查看库存功能 2-进入修改库存功能 3-结束
switch (choose) {
case 1:
//5.1.调用遍历集合
printStudent(array);
break;
case 2:
//5.2.集合中随机抽取元素
randomStudent(array);
break;
case 3:
//5.3.结束系统
System.out.println("点名系统结束,欢迎下次使用");
return;
default:
System.out.println("功能还在完善中,请期待哦...");
break;
}
}
}
/*2.调用添加方法
* 定义方法,存储Student对象,到集合容器中
* 返回值：void
* 参数：创建Student类型变量,存储到集合中
*/
public static void addStudent(ArrayList<Student> array){
//创建Student类型变量,实例化
Student sn1 = new Student();
Student sn2 = new Student();
Student sn3 = new Student();
sn1.setAge(11);
sn1.setName("章1");
sn2.setAge(12);
sn2.setName("章2");
sn3.setAge(13);
sn3.setName("章3");
//将Student类型变量,存储到集合中
array.add(sn1);
array.add(sn2);
array.add(sn3);
System.out.println("初始化学生信息完毕");
}
/*4.调用输入选择数字功能,键盘输入需要的功能对应的数字
* 定义方法,键盘输入数字,选择对应功能
* 返回值：int
* 参数：无
*/
public static int chooseFunction(){
System.out.println("--------------------学生随机点名系统----------------------");
System.out.println("1.遍历学生姓名");
System.out.println("2.随机点名功能");
System.out.println("3.退出系统");
System.out.println("请输入要执行的操作序号：");
//接受键盘输入
//S2:创建对象实例：Scanner sc = new Scanner(System.in);
Scanner sc = new Scanner(System.in);
//S3.调用方法：int i = sc.nextInt();//用来接收控制台录入的数字
return sc.nextInt();
}
/*
* 5.1.调用遍历集合
* 定义方法,遍历集合中的元素,注意事项是：遍历拿到的是Student类型变量,还需要去获取Student类型变量所对应的属性
* 返回值：void
* 参数：共享的数据集合容器
*/
public static void printStudent(ArrayList<Student> array){
for (int i = 0; i < array.size(); i++) {
//存储集合的时候，集合.add(sn1) sn1是Student类型变量
//获取的时候,集合.get()获取出来的是什么,还是Student类型变量
//若想获得Student类型变量相应属性,需要采用Student类型变量名.属性
Student sn = array.get(i);
System.out.println("姓名：" + sn.getName() + " 年龄：" + sn.getAge());
}
System.out.println("============遍历学生姓名结束==================");
}
/*5.2.集合中随机抽取元素
* 定义方法,用随机类Random,随机一个索引,拿去集合获取一个Student类型变量,然后在对象.属性 打印相应的属性
* 返回值：void
* 参数：共享数据的集合容器
*/
public static void randomStudent(ArrayList<Student> array){
System.out.println("开始随机点名喽,这次我们点到：");
//R2:创建实例格式：Random 变量名 = new Random();
Random ran = new Random();
// R3:调用方法：public int nextInt(int maxValue) 产生[0,maxValue)范围的随机整数，包含0，不包含maxValue；
int index = ran.nextInt(array.size());
//存储集合的时候，集合.add(sn1) sn1是Student类型变量
//获取的时候,集合.get()获取出来的是什么,还是Student类型变量
//若想获得Student类型变量相应属性,需要采用Student类型变量名.属性
Student sn = array.get(index);
System.out.println("姓名：" + sn.getName() + " 年龄：" + sn.getAge());
System.out.println("随机点名结束一次...");
}
}
第5章 总结
5.1 知识点总结
类与对象
类，用于描述多个对象的共同特征，它是对象的模板。
对象，用于描述现实中的个体，它是类的实例。
类的定义：使用关键字class来定义java中的类
格式：
class 类名 {
//属性
数据类型 变量名;
…
//方法
修饰符 返回值类型 方法名(参数){ }
…
}
创建对象：
格式：
封装（private关键字）
封装，把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
封装的体现：
变量:使用 private 修饰，这就是变量的封装
方法:也是一种封装，封装了多条代码
类： 也是一种封装，封装了多个方法
private关键字，私有的意思
它可以用来修饰类中的成员(成员变量，成员方法)
private的特点：
private修饰的成员只能在当前类中访问，其他类中无法直接访问
this关键字
this关键字，本类对象的引用
this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用
this什么时候存在的？当创建对象的时候，this存在的
this的作用：用来区别同名的成员变量与局部变量（this.成员变量）
public void setName(String name) {
this.name = name;
}