第九天 面向对象-类,封装,对象,private,this【悟空教程】

第09天 面向对象

第1章 面向对象

1.1 面向对象

1.1.1 面向对象概述

1.1.1.1 概述

我们回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。

在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。

那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。

面向过程的代表语言：C语言

当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

1.1.1.2 特点

• 是一种更符合我们思考习惯的思想
• 可以将复杂的事情简单化
• 将我们从执行者变成了指挥者
  • 角色发生了转换

1.1.1.3 举例

• 买电脑
• 洗衣服
• 吃饭

1.1.1.4 面向对象特性

• 封装
• 继承
• 多态

1.1.2 类与对象

面向对象的思维方式在Java代码中表现为类的定义与对象的使用。理清类与对象的概念与关系是面向对象的重点。

1.1.2.1 类的基本概念

类是具有相同特征（属性）和行为(功能)的一类事物的抽象。

我们将现实事物的特征抽象为类中的成员变量，现实事物的行为功能抽象为类中的成员方法。

注意：实际上所属关系是直接属于类的，均称为成员，如成员变量、成员方法、后边学习的成员内部类，并不单指成员变量。

1.1.2.2 类的定义格式

类在Java中代码的体现形式：

• 使用class(类)来抽象一个现实生活中的事物
• 定义成员变量对应事物的属性，一般使用private修饰，提供get/set方法
• 定义成员方法对应事物的功能，一般使用public修饰
• 定义格式：

public class 类名{

private 数据类型 变量名1;

private 数据类型 变量名2;

…其他成员变量

public 返回值类型 方法名(参数类型 参数名，参数类型 参数名2…) {

方法体;

}

每个属性对应的get/set方法,使用this区分成员变量与局部变量

}

如：人类

public class Person {

private String name;

private int age;

public void eat() {

System.out.println(“吃了”);

}

public void setName(String name) {

this.name = name;

}

public String getName() {

return name;

}

public void setAge (int age) {

this.age = age;

}

public int getAge() {

return age;

}

}

1.1.2.3 类的使用格式

类的使用非常简单，一般分为两个动作：创建对象与调用方法。

类的定义是现实事物的抽象，真正使用的是类创建的对象。通常使用对象来调用方法。

对象创建格式:

数据类型 对象名= new 数据类型();

对象方法的调用：

无返回值：

对象名.方法名(参数);

有返回值：

返回值类型 变量名 = 对象名.方法名(参数);

1.1.2.4 成员变量

直接定义在类中的变量称为成员变量，在面向对象思想设计上，是类的组成部分。

成员变量通常使用private修饰，阻止本类以外的其他类访问。

成员变量不能重名，局部变量不能重名，成员与局部变量可以重名，但是需要使用this区分。

使用this访问的为成员变量，直接访问的为局部。在方法内访问变量，如果没有该名称的局部变量会自动查找是否有该名称的成员变量。

1.1.2.5 成员方法

正常定义成员方法时，一般是不需要添加static修饰符的。static修饰符会在后边详细简介。

成员方法一般可分为两类

• 没有业务的属性get/set方法，与属性对应
• 有业务的普通方法，属于类的功能

package cn.javahelp;

/*

* 定义自定义类型 Person类

*

* 属性（成员变量）

* 姓名 String

* 年龄 int

* 行为（成员方法）

* 吃饭

* 睡觉

* 打豆豆

*

* 为成员变量赋值/获取成员变量的值的方法

*

* private 修饰的成员(成员变量，成员方法) 让外界无法直接访问 内部可以访问

*

* this区分成员变量与局部变量(注意：这是定义时所展现出来的功能，其功能本质，一会单独说)

*

* 成员方法 一般不使用static修饰

* 分为两种

* 1.get/set方法

* 2.属于类的功能的方法

*/

public class Person {

//定义成员变量

private String name;

private int age;

private String sex;

//吃饭

public void eat(){

System.out.println(name+"吃了");

}

//睡觉

public void sleep(){

System.out.println(name+"睡了");

}

//打豆豆

public void hitBeanBean(){

System.out.println(name+"打了，爽了，敲代码了！");

}

//为name赋值的方法 方法名 setName 参数 String name 返回值 void

public void setName(String name){

this.name=name;

}

//获取name的值的方法 方法名 getName 参数 无 返回值 String name

public String getName(){

return name;

}

//为age赋值的方法 方法名 setAge 参数 int age 返回值 void

public void setAge(int age){

this.age=age;

}

//获取age的值的方法 方法名 getAge 参数 无 返回值 int age

public int getAge(){

return age;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

}

package cn.javahelp;

/*

* 测试Person类

*

* 导包 在同一个文件夹下不需要导包

* 创建对象 数据类型 变量名 = new 数据类型()

* 调用方法

* 返回值类型 新变量名 = 变量名.方法名(实际参数);

*

*

* 方法调用时，用static修饰的方法调用其他方法时，其他方法必须使用static修饰

* 指的是

* 在同一个类中，直接调用其他方法时，其他方法必须使用static修饰

* 如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

*/

public class Test {

public static void main(String[] args) {

//创建对象

Person p= new Person();

//调用方法

p.setName("柳岩");

p.setAge(38);

//因为age用private修饰了 所以外界不能直接访问了

//p.age = -1;

//如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

p.eat();

p.sleep();

p.hitBeanBean();

String name = p.getName();

System.out.println(name);

System.out.println(p.getAge());

//main方法直接调用method方法 method方法必须使用static修饰

//method();

}

public void method(){

System.out.println("我是一个方法");

}

}

1.1.2.6 成员变量和局部变量的区别

• 在类中的位置不同
  • 成员变量：类中，方法外
  • 局部变量：方法中或者方法声明上(形式参数)
• 在内存中的位置不同
  • 成员变量：堆内存
  • 局部变量：栈内存
• 生命周期不同
  • 成员变量：随着对象的创建而存在，随着对象的消失而消失
  • 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
• 初始化值的不同
  • 成员变量：有默认值
  • 局部变量：没有默认值。必须先定义，赋值，最后使用

public class DemoVariable {

int x;

public void show() {

int y = 0;

System.out.println(x);

System.out.println(y);

}

}

1.1.2.7 类与对象的关系

类是抽象概念，对象是类的具体实例。我们通常真正使用的是某个类的实例对象，进而调用该对象的方法。

一个类可以有多个对象，一个对象只属于一个类(在讲完多态后会有不同的理解)。

可以说创建对象并调用方法是类最主要的使用方式。

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

1.1.2.8 类名作为形式参数和返回值（扩展）

类名作为形式参数案例: 需要的其实是该类的对象

public class Student {

public void study() {

System.out.println("好好学习,天天向上");

}

}

public class Teacher {

public void test(Student s) {

s.study();

}

}

public class Test {

public static void main(String[] args) {

Teacher t = new Teacher();

Student s = new Student();

t.test(s);

}

}

类名作为返回值案例: 返回的其实是该类的对象

public class Student {

public void study() {

System.out.println("好好学习,天天向上");

}

}

public class Teacher {

public Student getStudent() {

Student s = new Student();

return s;

}

}

public class Test {

public static void main(String[] args) {

Teacher t = new Teacher();

Student s = t.getStudent();

s.study();

}

}

1.1.3 自定义类练习

在第6天自定义类型基础上，我们可以将现实生活中的任何事物抽象成一个更为完整的类，请自定义并使用一种数据类型。如人类、动物类、汽车类、衣服类、玩具类等

1.1.3.1 自定义人类：

/*

* 定义自定义类型 Person类

*

* 属性（成员变量）

* 姓名 String

* 年龄 int

* 行为（成员方法）

* 吃饭

* 睡觉

* 打豆豆

*

* 为成员变量赋值/获取成员变量的值的方法

*

* private 修饰的成员(成员变量，成员方法) 让外界无法直接访问 内部可以访问

*

* this区分成员变量与局部变量(注意：这是定义时所展现出来的功能，其功能本质，一会单独说)

*

* 成员方法 一般不使用static修饰

* 分为两种

* 1.get或set方法

* 2.属于类的功能的方法

*

*

*

*

*/

public class Person {

//定义成员变量

private String name;

private int age;

private String sex;

//吃饭

public void eat(){

System.out.println(name+"吃了");

}

//睡觉

public void sleep(){

System.out.println(name+"睡了");

}

//打豆豆

public void hitBeanBean(){

System.out.println(name+"打了，爽了，敲代码了！");

}

//为name赋值的方法 方法名 setName 参数 String name 返回值 void

public void setName(String name){

this.name=name;

}

//获取name的值的方法 方法名 getName 参数 无 返回值 String name

public String getName(){

return name;

}

//为age赋值的方法 方法名 setAge 参数 int age 返回值 void

public void setAge(int age){

this.age=age;

}

//获取age的值的方法 方法名 getAge 参数 无 返回值 int age

public int getAge(){

return age;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

}

/*

* 测试Person类

*

* 导包 在同一个文件夹下不需要导包

* 创建对象 数据类型 变量名 = new 数据类型()

* 调用方法

* 返回值类型 新变量名 = 变量名.方法名(实际参数);

*

*

* 方法调用时，用static修饰的方法调用其他方法时，其他方法必须使用static修饰

* 指的是

* 在同一个类中，直接调用其他方法时，其他方法必须使用static修饰

* 如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

*/

public class Test {

public static void main(String[] args) {

//创建对象

Person p= new Person();

//调用方法

p.setName("柳岩");

p.setAge(38);

//因为age用private修饰了 所以外界不能直接访问了

//p.age = -1;

//如果使用对象名.方法名()这种方式 其他方法一般不使用static修饰

p.eat();

p.sleep();

p.hitBeanBean();

String name = p.getName();

System.out.println(name);

System.out.println(p.getAge());

//main方法直接调用method方法 method方法必须使用static修饰

//method();

}

public void method(){

System.out.println("我是一个方法");

}

}

1.1.3.2 自定义car类

/*

* 车类

*

* 属性

* 颜色

* 品牌

* 价格

* 车牌号

* 车主

*

* 功能

* 运输货物

* 兜风

* get/set

*/

public class Car {

private String color;//颜色

private String pinPai;//品牌

private double price;//价格

private String number;//车牌号

private String admin;//车主

//运输方法 方法名yunShu 参数 String 货物 返回值 无

public void yunShu(String huoWu){

System.out.println(admin+"开着"+color+pinPai+"价值"+price

+"车牌号为"+number+"的车"+"运输了"+huoWu);

}

//兜风 方法名 douFeng 参数 String name 返回值 无

public void douFeng(String name){

System.out.println(admin+"开着"+color+pinPai+"价值"+price

+"车牌号为"+number+"的车"+"带着"+name+"去兜风");

}

//为color赋值 方法名 setColor 参数 String color 返回值 void

public void setColor(String color){

this.color = color;

}

//获取color的值 方法名 getColor 参数 无 返回值 String color

public String getColor(){

return color;

}

//获取pinPai的值

public String getPinPai() {

return pinPai;

}

//为pinPai赋值

public void setPinPai(String pinPai) {

this.pinPai = pinPai;

}

//获取price的值

public double getPrice() {

return price;

}

//为price赋值

public void setPrice(double price) {

this.price = price;

}

//获取number的值

public String getNumber() {

return number;

}

//为number赋值

public void setNumber(String number) {

this.number = number;

}

//获取admin的值

public String getAdmin() {

return admin;

}

//为admin赋值

public void setAdmin(String admin) {

this.admin = admin;

}

}

/*

* 测试 自定义类型 车类

*

*/

public class Test {

public static void main(String[] args) {

Car c = new Car();

//调用方法

c.setAdmin("老王");

c.setColor("绿色");

c.setPinPai("三蹦子");

c.setPrice(250.38);

c.setNumber("JP74110");

c.yunShu("猪");

c.douFeng("柳岩");

}

}

1.1.3.3 自定义手机类

定义手机类

public class Phone {

//品牌

String brand;

//价格

int price;

//颜色

String color;

//打电话

public void call(String name) {

System.out.println("给"+name+"打电话");

}

//发短信

public void sendMessage() {

System.out.println("群发短信");

}

}

手机类的测试类

public class Demo02Phone {

public static void main(String[] args) {

//创建对象

Phone p = new Phone();

//输出成员变量值

System.out.println("品牌："+p.brand);//null

System.out.println("价格："+p.price);//0

System.out.println("颜色："+p.color);//null

System.out.println("------------");

//给成员变量赋值

p.brand = "锤子";

p.price = 2999;

p.color = "棕色";

//再次输出成员变量值

System.out.println("品牌："+p.brand);//锤子

System.out.println("价格："+p.price);//2999

System.out.println("颜色："+p.color);//棕色

System.out.println("------------");

//调用成员方法

p.call("唐嫣");

p.sendMessage();

}

}

1.1.4 对象的内存解释

对象在内存中的位置：

对象由new关键字创建，如同数组，实体存在于堆内存中

任何事物均可以定义成类，创建对象，属于引用类型

而对象的引用变量是一个普通变量。存储的值是该对象堆内存中的地址。

• 定义Phone类

public class Phone {

String brand;

int price;

String color;

public void call(String name) {

System.out.println("给"+name+"打电话");

}

public void sendMessage() {

System.out.println("群发短信");

}

}

1.1.4.1 一个对象的内存图

public class Demo01Phone {

public static void main(String[] args) {

Phone p = new Phone();

System.out.println(p.brand + "---" + p.price + "---" + p.color);

p.brand = "锤子";

p.price = 2999;

p.color = "棕色";

System.out.println(p.brand + "---" + p.price + "---" + p.color);

p.call("林青霞");

p.sendMessage();

}

}

1.1.4.2 两个对象，使用同一个方法的内存图

public class Demo02Phone {

public static void main(String[] args) {

Phone p1 = new Phone();

p1.brand = "小米5s";

p1.price = 1999;

p1.color = "银色";

System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);

p1.call("林青霞");

p1.sendMessage();

Phone p2 = new Phone();

p2.brand = "IPhone7S";

p2.price = 7999;

p2.color = "土豪金";

System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);

p2.call("张曼玉");

p2.sendMessage();

}

}

1.1.4.3 两个引用，指向同一个对象的内存图

public class Demo03Phone {

public static void main(String[] args) {

Phone p1 = new Phone();

p1.brand = "OPPO";

p1.price = 2999;

p1.color = "白色";

System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);

Phone p2 = p1;

p2.brand = "魅族";

p2.price = 1999;

p2.color = "蓝色";

System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);

System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);

}

}

1.2 封装

1.2.1 封装的概述和好处

1.2.1.1 封装概述

• 是面向对象三大特征之一
• 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。

1.2.1.2 封装原则：

• 将不需要对外提供的内容都隐藏起来。
• 把属性隐藏，提供公共方法对其访问。
• 成员变量private，提供对应的getXxx()/setXxx()方法

1.2.1.3 好处：

• 通过方法来控制成员变量的操作，提高了代码的安全性
• 把代码用方法进行封装，提高了代码的复用性

1.3 private关键字

1.3.1 private关键字：

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

public class Student {

String name;

//int age;

private int age;

public void setAge(int a) {

if(a<0 || a>200) {

System.out.println("你给的年龄有误");

}else {

age = a;

}

}

public int getAge() {

return age;

}

public void show() {

System.out.println("姓名是："+name+",年龄是："+age);

}

}

public class DemoStudent {

public static void main(String[] args) {

//创建学生对象

Student s = new Student();

s.show();

s.name = "柳岩";

//s.age = 18;

//s.age = -18;

//s.setAge(-18);

s.setAge(28);

s.show();

}

}

1.3.2 private最常见的应用：

• 把成员变量用private修饰
• 提供对应的getXxx()/setXxx()方法
• 一个标准案例的使用

1.3.3 成员变量私有的标准代码

public class Student {

private String name;

private int age;

public void setName(String n) {

name = n;

}

public String getName() {

return name;

}

public void setAge(int a) {

age = a;

}

public int getAge() {

return age;

}

}

public class DemoStudent {

public static void main(String[] args) {

//创建对象

Student s = new Student();

System.out.println(s.getName()+"---"+s.getAge());

s.setName("赵丽颖");

s.setAge(18);

System.out.println(s.getName()+"---"+s.getAge());

}

}

1.4 this关键字

1.4.1 this关键字

一般出现在类的一个方法的定义当中，代表当前对象的引用。我们通常用其将本对象中的成员与其他作用域区分开来。

当一个类定义好之后，如果不创建对象this是没有意义的。

一个类可以有多个对象。每个对象都有各自的属性值，各个对象的方法均是类中定义的那个方法逻辑。定义中的this就代表调用方法的这个对象。

1.4.2 this关键字的由来

• this:代表所在类的对象引用
• 记住：方法被哪个对象调用，this就代表那个对象

1.4.3 this关键字的使用

• 局部变量隐藏成员变量(局部变量和成员变量重名)

public class Student {

private String name;

private int age;

public void setName(String name) {

//name = name;

this.name = name;

}

public String getName() {

return name;

}

public void setAge(int age) {

//age = age;

this.age = age;

}

public int getAge() {

return age;

}

}

public class DemoStudent {

public static void main(String[] args) {

//创建对象

Student s = new Student();

System.out.println(s.getName()+"---"+s.getAge());

s.setName("柳岩");

s.setAge(18);

System.out.println(s.getName()+"---"+s.getAge());

}

}

第2章 知识点相关题

2.1 定义“书”类，Book，包含以下成员：

成员属性：

名称：String

作者：String

出版社：String

出版日期：String

单价：double

成员方法：

1). get/set方法

2).showMe()方法，打印所有内部属性的值；

定义类：Test1，定义main()方法，按以下要求编写代码：

• 实例化一个Book对象，调用set()方法为属性赋值：
• “Java实战”,”Jack”,”javahelp”,”2011-03-15”,88.5
• 实例化一个Book对象，调用set()方法为属性赋值：
• “JavaEE高级”,”Anson”，”javahelp”,”2012-02-05”,66.70
• 分别调用两个Book对象的showMe()方法打印各自的属性值；

2.2 定义“猫”类，Cat，包含以下成员：

成员属性：

名称：String

性别：char

年龄：int

出生日期：String

成员方法：

1). get/set方法

2).showMe()方法，打印所有内部属性的值；

3).eat()方法，打印：小猫吃鱼；

定义类：Test2，定义main()方法，按以下要求编写代码：

• 实例化一个Cat对象，调用set()方法为属性赋值： “波斯猫”,’公’,2,”2011-05-06”
• 实例化一个Cat对象，调用set()方法为属性赋值： “机器猫”,’公’,5,”2012-08-06”
• 分别调用两个Cat对象的showMe()方法打印各自的属性值；
• 分别调用两个Cat对象的eat()方法；

2.3 定义 “手机类” ， Phone 包含以下成员：

成员属性:

品牌brand,

价格price

颜色 color

行为:打电话call, 调用方法打印***手机正在给10086打电话

发短信sendMessage, 调用方法打印***手机正在发短信

玩游戏,playGame，调用方法打印***手机正在玩王者农药

定义测试类，定义main方法，要求如下:

• 创建一个华为手机对象，调用方法设置颜色为黑色，价格为2399
• 创建一个苹果手机对象，调用方法设置颜色为玫瑰金，价格为5699
• 创建一个三星手机对象，调用方法设置颜色为钻石白，价格为4699
• 华为调用打电话的方法， 苹果调用发短息的方法，三星调用玩游戏的方法

2.4 定义一个人类，包含以下成员：

成员属性：

name 姓名

age 年龄

方法：

Show（）

要求打印出对象的所有属性

要求在类中定义构造方法（有参数和无参数两种）和get、set方法

然后创建出测试类,然后创建三个对象

1).通过有参构造创建一个对象---（小明，20）

2)通过有参构造创建一个对象---（小红，22）

3)通过有参构造创建一个对象---（小新，16）

2).然后通过show方法打印这个对象的所有属性

2.5 定义类：Person1，为其添加“默认无参构造方法”：打印：“构造一个Person对象”

定义测试类：Demo，添加main()方法，填写如下内容：

Person1 p1 = new Person1();

System.out.println(“--------------------“);

Person1 p2 = new Person1();

System.out.println(“--------------------“);

Person1 p3;

观察执行结果，请回答以下问题：

A. 构造方法的名称有什么特点？

B. 构造方法是否有“返回值类型”和“形参”的定义？

C. 此构造方法什么时候被执行？

2.6 创建Test_1类的main方法，并按以下要求完成代码内容：

• 在主方法中创建int 类型的对象a并赋值
• 创建static void method（int a）方法传入的参数为int 类型，并对传入的数据进行修改
• 在主方法中调用method方法后，打印a并查看数值

2.7 创建Test_2类的main方法，并按以下要求完成代码内容：

• 在主方法中创建String类型的对象str并赋值
• 创建static void method（String str）方法传入的参数为String 类型，并对传入的数据进行修改
• 在主方法中调用method方法后，打印str并查看数据

2.8 自定义类，并自定义测试方法，调用方法证明this可以区分成员变量和局部变量

第3章 代码题

3.1 定义一个空调类和对应的测试类

该题考查点：属性和方法的使用！

要求：

1.空调有品牌和价格两个属性，并且将属性私有化，提供公有的getXxx与setXxx方法对属性赋值和取值；

2.提供一个无返回值的无参数的开机的方法，内容打印一句话：“空调开机了...”；

3.提供一个无返回值的带1个int类型参数的定时关机的方法,(int类型的参数表示设定的分钟数)，内容打印一句话：“空调将在xxx分钟后自动关闭...”；

4.在测试类中创建出空调对象，并给空调的品牌和价格赋任意值；

5.使用空调对象获取空调的品牌和价格并打印到控制台上；

6.使用空调对象调用开机方法；

7.使用空调对象调用定时关机方法，并传递具体数据值，在控制台上可以看到的效果为：空调将在xxx分钟后自动关闭...

其中语句中的“xxx”是调用方法时传递的具体数据值；

答案：

3.2 定义一个学生类和对应的测试类

该题考查点：this关键字的使用！

要求：

1.学生有姓名和年龄两个属性，并且将属性私有化，提供公有的getXxx与setXxx方法对属性赋值和取值；

2.提供一个无返回值的无参数的自我介绍的方法，内容打印一句话：

“大家好，我叫xxx，今年xxx岁了！”

3.提供一个返回值为String类型，参数为学生类型的比较年龄差值的方法，如果当前对象的年龄比参数中的学生的年龄大，则返回：“我比同桌大xxx岁！”；如果当前对象的年龄比参数中的学生的年龄小，则返回：“我比同桌小xxx岁！”；如果当前对象的年龄和参数中的学生的年龄一样大，则返回：“我和同桌一样大！”

4.在测试类中分别创建你和你同桌两个人的对象，并分别给你和你同桌的姓名和年龄属性赋上对应的值；

5.调用你自己的对象的自我介绍的方法，展示出你自己的姓名和年龄；

6.用你自己的对象调用比较年龄差值的方法，把你同桌作为参数使用，并打印方法返回的字符串的内容；

答案：

3.3 定义一个商品类和对应测试类

要求：

1.定义商品类，有名称和价格两个属性，并且将属性私有化，提供公有的getXxx与setXxx方法对属性赋值和取值；设置有参无参构造方法

2.编写测试类，在测试类中通过构造分别创建3个商品对象，并分别给3个商品对象的名称和价格赋值；

3.然后求出是三个商品的平均价格；

3.4 创建student类，包含年龄，姓名，成绩属性，本类中有对学生成绩打等级的方法，并返回该等级（A,B,C）

在主方法中： 创建三个Student对象并传入method(ArrayList<Student> stu)方法中

method方法内要求： 该方法内有对等级进行判断的方法，如果为A等级则打印该学生姓名，并奖励一朵小红花~~~~

答案：

第4章 ArrayList集合封装练习

4.1 存储自定义对象并遍历

public class Student {

private String name;

private int age;

public Student() {

}

public Student(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;

}

}

public class Demo03ArrayListTest {

public static void main(String[] args) {

//创建集合对象

ArrayList<Student> array = new ArrayList<Student>();

//创建学生对象

Student s1 = new Student("赵丽颖",18);

Student s2 = new Student("唐嫣",20);

Student s3 = new Student("景甜",25);

Student s4 = new Student("柳岩",19);

//把学生对象作为元素添加到集合中

array.add(s1);

array.add(s2);

array.add(s3);

array.add(s4);

//遍历集合

for(int x=0; x<array.size(); x++) {

Student s = array.get(x);

System.out.println(s.getName()+"---"+s.getAge());

}

}

}

4.2 创建一个集合，存储学生对象，学生对象的数据来自于键盘录入，最后，遍历集合

public class Student {

private String name;

private String age;

public Student() {

}

public Student(String name, String age) {

this.name = name;

this.age = age;

}

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 class Demo04ArrayListTest {

public static void main(String[] args) {

//创建集合对象

ArrayList<Student> list = new ArrayList<Student>();

//为了提高代码的复用性，我把键盘录入数据给学生对象，并存储到集合中的动作用一个方法来实现

//调用方法

addStudent(list);

addStudent(list);

addStudent(list);

//遍历集合

for(int x=0; x<list.size(); x++) {

Student s = list.get(x);

System.out.println(s.getName()+"---"+s.getAge());

}

}

/*

* 两个明确：

* 返回值类型：void

* 参数列表：ArrayList<Student> list

*/

public static void addStudent(ArrayList<Student> list) {

//键盘录入数据,创建学生对象,把键盘录入的数据赋值给学生对象的成员变量

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

//把学生对象作为元素存储到集合中

list.add(s);

}

}

4.3 学生管理系统ArrayList集合

4.3.1 学生管理系统项目演示

4.3.2 学生管理系统之标准学生类

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;

}

}

4.3.3 学生管理系统的主类

public class StudentManager {

public static void main(String[] args) {

//创建集合对象，用于存储学生数据

ArrayList<Student> list = 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(list);

break;

case "2":

//添加学生

addStudent(list);

break;

case "3":

//删除学生

deleteStudent(list);

break;

case "4":

//修改学生

updateStudent(list);

break;

case "5":

//退出

//System.out.println("谢谢你的使用");

//break;

default:

System.out.println("谢谢你的使用");

System.exit(0); //JVM退出

break;

}

}

}

/*

* 修改学生的方法

* 修改学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就修改该学生

*/

public static void updateStudent(ArrayList<Student> list) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

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

String id = sc.nextLine();

//定义一个索引

int index = -1;

//遍历集合

for(int x=0; x<list.size(); x++) {

//获取每一个学生对象

Student s = list.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);

//修改集合中的学生对象

list.set(index, s);

//给出提示

System.out.println("修改学生成功");

}

}

/*

* 删除学生的方法

* 删除学生的思路：键盘录入一个学号，到集合中去查找，看是否有学生使用的是该学号，如果有就删除该学生

*/

public static void deleteStudent(ArrayList<Student> list) {

//创建键盘录入对象

Scanner sc = new Scanner(System.in);

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

String id = sc.nextLine();

//我们必须给出学号不存在的时候的提示

//定义一个索引

int index = -1;

//遍历集合

for(int x=0; x<list.size(); x++) {

//获取到每一个学生对象

Student s = list.get(x);

//拿这个学生对象的学号和键盘录入的学号进行比较

if(s.getId().equals(id)) {

index = x;

break;

}

}

if(index == -1) {

System.out.println("不好意思,你要删除的学号对应的学生信息不存在,请回去重新你的选择");

}else {

list.remove(index);

System.out.println("删除学生成功");

}

}

//添加学生的方法

public static void addStudent(ArrayList<Student> list) {

//创建键盘录入对象

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<list.size(); x++) {

Student s = list.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);

//把学生对象作为元素添加到集合

list.add(s);

//给出提示

System.out.println("添加学生成功");

}

//查看所有学生

public static void findAllStudent(ArrayList<Student> list) {

//首先来判断集合中是否有数据，如果没有数据，就给出提示，并让该方法不继续往下执行

if(list.size() == 0) {

System.out.println("不好意思,目前没有学生信息可供查询,请回去重新选择你的操作");

return;

}

//\t 其实就是一个tab键的位置

System.out.println("学号\t\t姓名\t年龄\t居住地");

for(int x=0; x<list.size(); x++) {

Student s = list.get(x);

System.out.println(s.getId()+"\t"+s.getName()+"\t"+s.getAge()+"\t"+s.getAddress());

}

}

}

第5章 综合案例---随机点名案例重构

5.0.1 案例介绍与演示

将第6天的随机点名的案例由之前简单的Person对象，重构为相对完整的Person对象并使用。

5.0.2 案例回顾

在全班同学中随机地打印出一名同学名字。

共三个步骤：

1.存储全班同学(Person对象)

2.打印全班同学每一个人的名字

3.在班级总人数范围内，随机产生一个随机数索引，查找该随机数索引所对应的同学(Person对象)，并通过该对象访问name属性

5.0.3 重构内容分析

将原来使用的简单Person类，封装为包装成员变量和成员方法的相对完整的Person类，并将所有访问属性的地方改为通过get/set方法访问。

/*

自定义类型 人类

属性

姓名 String

年龄 int

性别 String

身高 double

是否热爱java boolean

*/

public class Person {

// 姓名

String name;

// 年龄

int age;

// 性别

String sex;

// 身高

double height;

// 是否喜欢java

boolean isLoveJava;

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;

}

public String getSex() {

return sex;

}

public void setSex(String sex) {

this.sex = sex;

}

public double getHeight() {

return height;

}

public void setHeight(double height) {

this.height = height;

}

public boolean isLoveJava() {

return isLoveJava;

}

public void setLoveJava(boolean isLoveJava) {

this.isLoveJava = isLoveJava;

}

}

/*

随机点名器

用集合存储所有同学

总览全班同学姓名

随机点名其中一人，打印到控制台

1.定义一个集合用来存储所有同学

导包

创建对象 存储的是Person

调用方法

2.向集合中添加人

3.遍历集合，依次获取每个人，打印每个人的名字

4.随机点名

生成一个最大不超过集合最大索引的随机数 0 - 集合最大索引的一个随机数

依据随机数得到集合中相对应的人，打印其名字

*/

//导入集合ArrayList

import java.util.ArrayList;

import java.util.Random;

public class RandomName

{

public static void main(String[] args)

{

//定义一个集合用来存储所有人

ArrayList<Person> list = new ArrayList<Person>();

//向集合中添加人 创建Person对象 将Person添加到集合中

Person p = new Person();

p.setName("柳岩");

Person p2 = new Person();

p2.setName("唐嫣");

Person p3 = new Person();

p3.setName("金莲");

list.add(p);

list.add(p2);

list.add(p3);

System.out.println("-----------------------");

//遍历集合，依次获取每个人，打印每个人的名字

for(int i = 0 ;i < list.size();i++){

Person thisP = list.get(i);

//调用getName方法 获取每个人的名字

System.out.println(thisP.getName());

}

System.out.println("-----------------------");

//随机点名

Random r = new Random();

//生成一个最大不超过集合最大索引的随机数 0 - 集合最大索引的一个随机数

int randomIndex = r.nextInt(list.size());

//依据随机数得到集合中相对应的人

Person person = list.get(randomIndex);

System.out.println("今天你答题:"+person.getName());

}

}

第6章 超市购物小票

6.1 案例介绍与演示

模拟真实购物逻辑，以上述图片为需求原型，根据不同购物物品完成购物小票内容打印到控制台。(简化项目逻辑，票脚部分只完成数据统计)

数据：

• 将超市购物小票案例中零散数据(名称、货号、单价、数量、计价单位、金额)封装为货物对象。
• 所有的货物对象放置到集合中统一管理。

逻辑：

用户循环进行三个操作：

• 输入购买数量，代表为所有货物的数量赋值，从而计算每项商品金额
• 打印小票，将已有数据打印
• 退出系统(因为该程序为循环操作，无法终止，如果不想再进行操作，则退出系统)

6.1.1 案例分析

a) 涉及SE基础内容

变量定义：记录部分数据

集合的使用：用于存储多个完整数据

运算符的使用：计算变量

流程控制语句的使用：

• if语句：用于判断是否购买了商品
• switch语句：用于进行三个操作(输入购买数量、打印小票、退出系统)的分支
• for/while语句：switch外部使用for/while循环，当执行一个操作后，继续进行下一个操作选择

方法封装：

由于代码量比较多，可以将输入购买数量、打印小票封装为方法使用

字符串/键盘录入：

打印小票完整过程均为字符串的拼写及打印，数量输入为键盘录入Scanner完成

b) 实现步骤

• 定义GoodsItem类(名称、货号、单价、数量、计价单位、金额)

/*

* 定义商品项类:

* 名称,货号,单价,数量,计价单位,金额

*/

public class GoodsItem {

// 成员变量

private String name;

private String id;

private double price;

private int number;

private String unit;

private double money;

// 构造方法

public GoodsItem() {

}

public GoodsItem(String name, String id, double price, int number, String unit, double money) {

this.name = name;

this.id = id;

this.price = price;

this.number = number;

this.unit = unit;

this.money = money;

}

// getters/setters

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

public int getNumber() {

return number;

}

public void setNumber(int number) {

this.number = number;

}

public String getUnit() {

return unit;

}

public void setUnit(String unit) {

this.unit = unit;

}

public double getMoney() {

return money;

}

public void setMoney(double money) {

this.money = money;

}

}

• 成员位置定义集合，定义方法向集合中存储所有GoodsItem数据

public class ShoppingReceipt {

//成员位置定义集合,存储所有的商品项对象

static ArrayList<GoodsItem> data = new ArrayList<GoodsItem>();

}

• 实现主干逻辑
  • 打印欢迎语句

public static void main(String[] args) {

//打印欢迎语句

System.out.println("欢迎使用超市管理系统!");

• 物品展示与购买界面 initData()方法

//main方法中添加 为集合准备数据

initData();

//定义方法,向成员位置的集合赋值

public static void initData() {

//创建多个商品项对象

GoodsItem sls = new GoodsItem("少林寺核桃", "090115", 15.5, 0, "个", 0);

GoodsItem shk = new GoodsItem("尚康饼干", "090027", 14.5, 0, "个", 0);

//将多个商品项对象放入集合中

data.add(sls);

data.add(shk);

}

使用for/while进行循环进行操作

使用switch给出操作选择：1输入购买数量2打印小票3退出

完成switch中三个case的逻辑

//使用死循环完成反复操作的逻辑

//for(;;) {}

while(true) {

//使用switch给出操作选择：1输入购买数量2打印小票3退出

//提示信息

System.out.println("请输入您要进行的操作:1输入购买数量 2打印小票 3退出");

//通过键盘录入得到数据

Scanner sc = new Scanner(System.in);

int optNumber = sc.nextInt();

//完成switch中三个case的逻辑

switch (optNumber) {

case 1:

//调用给所有数据的数量与金额赋值方法

enterNumber();

break;

case 2:

//调用打印购物小票的方法

printReceipt();

break;

case 3:

System.out.println("欢迎下次光临");

//退出程序

System.exit(0);

default:

System.out.println("请输入正确的数字!");

break;

}

}

运用方法封装功能：将1输入购买数量、2打印小票封装为独立方法，在case中调用，提高代码可读性。

/**

* 为所有的数据赋值数量与金额

*/

public static void enterNumber() {

//集合的遍历

for (int i = 0; i < data.size(); i++) {

//依次获取到集合中每一个元素

GoodsItem thisGoods = data.get(i);

//提示用户,输入该商品项的数量

//获取该商品项名称

String thisGoodsName = thisGoods.getName();

System.out.println("请输入"+thisGoodsName+"的购买数量");

//键盘录入接受商品数量

Scanner sc = new Scanner(System.in);

int thisGoodsNumber = sc.nextInt();

//根据数量计算金额 金额 = 单价 * 数量

double thisGoodsMoney = thisGoods.getPrice() * thisGoodsNumber;

//为该商品的数量与金额赋值

thisGoods.setNumber(thisGoodsNumber);

thisGoods.setMoney(thisGoodsMoney);

}

}

/**

* 定义打印小票方法

*/

private static void printReceipt() {

//static ArrayList<GoodsItem> data = new ArrayList<GoodsItem>();

//票头

System.out.println(" 欢 迎 光 临");

System.out.println("品名 售价 数量 单位 金额");

System.out.println("-------------------------------------------");

//票体

//定义变量,记录所有的商品数量

int totalNumber = 0;

//定义变量,记录所有的商品金额

double totalMoney = 0;

//便利集合

for (int i = 0; i < data.size(); i++) {

//依次获取每一个商品项

GoodsItem g = data.get(i);

//打印商品项

System.out.println(""+g.getName()+g.getId()+" "+g.getPrice()+" "+g.getNumber()+" "+g.getUnit()+" "+g.getMoney());

//累加数量与金额

totalNumber += g.getNumber();

totalMoney += g.getMoney();

}

System.out.println("-------------------------------------------");

//票脚

System.out.println("共"+data.size()+"项商品");

System.out.println("共"+totalNumber+"件商品");

System.out.println("共"+totalMoney+"元");

System.out.println();

}