第八天 自定义类型&方法&集合混合使用【悟空教程】
第08天 自定义类型&方法&集合混合使用
第1章 引用类型作为参数与返回值
1.1 引用类型是一种数据类型
自定义引用类型与int、double等数据类型相同，均是一种数据类型。当方法定义参数与返回值类型时，可以定位基本数据类型，也可以定义为引用数据类型，二者在定义上没有任何差别。
基本类型与引用类型传参过程中，仅仅是值的数据类型不同。
如：
基本类型int传参时，赋值为10，是一个具体数值
引用类型Person传参时，赋值为new Person(),是一个地址值，如0x8372
1.2 引用类型定义方法与返回值为参数练习
1.定义方法，基本类型作为参数 如：求两个数的和
/*
定义方法，基本类型作为参数 如：求两个整数的和
*/
public class Test1
{
public static void main(String[] args)
{
int a = 10;
int b = 20;
int he = sum(a,b);
System.out.println(he);
System.out.println(a);
System.out.println(b);
}
//求两个整数的和 参数 两个整数 返回值 一个整数
public static int sum(int a, int b){
a = 2 * a;
b = 2 * b;
int he = a + b;
return he;
}
}
2.定义方法，数组作为参数 如：打印数组中所有偶数
/*
定义方法，数组作为参数 如：打印数组中所有偶数
*/
public class Test2
{
public static void main(String[] args)
{
int[] arr ={3,8,2,5,0};
showOuShu(arr);
}
//打印数组中所有偶数 参数 一个整数数组 返回值 无
public static void showOuShu(int[] arr){
int count = 0;
//遍历数组，依次获取数组中每个数值，判断这个数值是否为偶数，如果是则打印
for(int i = 0 ;i<arr.length;i++){
//依次获取数组中每个数值
int number = arr[i];
//判断这个数值是否为偶数
if(number % 2 ==0){
//如果是则打印
System.out.println(number);
count++;
}
}
System.out.println("偶数个数:"+count);
}
}
3.定义方法，集合作为参数 如：打印集合中所有偶数
/*
定义方法，集合作为参数 如：打印集合中所有偶数
*/
//导入ArrayList
import java.util.ArrayList;
public class Test3
{
public static void main(String[] args)
{
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(3);
list.add(8);
list.add(2);
list.add(5);
list.add(0);
showOuShu(list);
}
//打印集合中所有偶数 参数 一个存储整数的集合 返回值 void
/*
遍历集合
依次获取集合中所有的数据
判断数据是否为偶数
如果是 则打印
*/
public static void showOuShu(ArrayList<Integer> list){
//遍历集合
for(int i = 0 ;i < list.size();i++){
//依次获取集合中所有的数据
int number = list.get(i);
//判断数据是否为偶数
if(number % 2 == 0){
System.out.println(number);
}
}
}
}
4.定义方法，自定义数据类型作为参数 如：将一个人的年龄增长10岁
public class Person
{
String name;
int age;
}
/*
定义方法，自定义数据类型作为参数 如：将一个人的年龄增长10岁
*/
public class Test4
{
public static void main(String[] args)
{
Person p = new Person();
addAge(p);
System.out.println("---------------------------");
System.out.println(p.age);
}
//将一个人的年龄增长10岁 参数 一个人 返回值 void
public static void addAge(Person p){
p.age+=10;
System.out.println(p.age);
}
}
同样，我们也可以尝试各种数据类型作为返回值使用。
1.3 引用类型传参与基本类型传参区别
-
当基本类型传参时，栈内存中，各个方法内的变量互不相关，仅存在一个相互赋值的动作。
-
当引用类型传参时，各个方法内的引用变量指向同一个堆内存中的对象，任何一个引用修改了对象，其他引用再使用时，均访问的是修改后的变量。
/*
自定义数据类型 Animal类
属性
姓名 String
年龄 int
种类 String
*/
public class Animal
{
String name;
int age;
String kind;
}
/*
定义一个方法 从一群小动物中，找出所有年龄大于3的小动物，将这些小动物放在一个集合中，并返回，在main方法中遍历返回的集合，打印所有年龄大于3的小动物的信息
*/
//导入ArrayList
import java.util.ArrayList;
public class Test5
{
public static void main(String[] args)
{
//存储所有动物的集合
ArrayList<Animal> list = new ArrayList<Animal>();
//向集合中添加动物
Animal a1 = new Animal();
a1.name = "柳岩";
a1.age = 38;
a1.kind = "女人";
Animal a2 = new Animal();
a2.name = "点点";
a2.age = 3;
a2.kind = "斑点狗";
Animal a3 = new Animal();
a3.name = "小白";
a3.age = 2;
a3.kind = "白痴猫";
Animal a4 = new Animal();
a4.name = "小金";
a4.age = 4;
a4.kind = "金丝猴";
//将所有动物存储到集合中
list.add(a1);
list.add(a2);
list.add(a3);
list.add(a4);
//调用检查年龄的方法 返回一个年龄大于3的动物的集合
ArrayList<Animal> checkList = checkAnimals(list);
//遍历返回的集合，打印所有年龄大于3的小动物的信息
for(int i = 0 ;i < checkList.size();i++){
//依次获取每个年龄大于3的小动物
Animal thisA = checkList.get(i);
System.out.println("姓名:"+thisA.name);
System.out.println("年龄:"+thisA.age);
System.out.println("品种:"+thisA.kind);
System.out.println("------------------------");
}
}
/*
1.定义一个动物类
2.定义方法 方法参数 一个存储所有动物的集合 返回值 一个存储所有年龄大于三的动物的集合
a.定义一个集合用来存储年龄大于3的动物
b.遍历所有动物的集合，依次获取每个动物
c.判断每个动物的年龄是否大于3
d.如果大于3，将当前这个动物存储到年龄大于三的动物的集合
e.返回 年龄大于3的动物的集合
*/
public static ArrayList<Animal> checkAnimals(ArrayList<Animal> list){
//定义一个存储年龄大于3动物的集合
ArrayList<Animal> checkList = new ArrayList<Animal>();
//遍历所有动物的集合 list
for(int i = 0 ;i < list.size();i++){
//依次获取每个动物
Animal thisA = list.get(i);
//判断每个动物的年龄是否大于3
if(thisA.age >3){
//将当前这个动物存储到年龄大于三的动物的集合
checkList.add(thisA);
}
}
//返回 年龄大于3的动物的集合
return checkList;
}
}
第2章 综合案例---超市购物小票封装自定义类
2.0.1 案例介绍与演示
将超市购物小票案例中零散数据(名称、货号、单价、计价单位等)封装为货物对象。
2.0.2 案例分析
a) 案例回顾
在超市购物小票案例中，我们封装了三个方法，在switch中为3个case执行用户选择的三个不同的操作：1输入购买数量 2打印购物小票 3退出系统
而所有的变量均”零散地”定义在成员位置。
b) 重构内容分析
1：将原来的成员位置零散定义的变量，封装为商品项GoodsItem对象。
2：将所有使用变量值的地方全部改为使用GoodsItem对象
c) 实现步骤
-
定义Person类
定义Person类，包含成员变量名称、年龄、地址
-
重构使用到变量的逻辑
将所有使用到成员位置商品属性的代码处，均由直接使用改为通过对象名访问对象属性的方式。
/*
自定义数据类型 商品项类
属性
商品名称 String
商品id String
商品单价 double
商品数量 int
商品金额 double
*/
public class GoodsItem
{
//商品名称
String name;
//商品id
String id;
//商品单价
double price ;
//商品数量
int number;
//商品金额
double money;
}
/*
使用switch语句完成三个分支的代码逻辑
当用户输入1时，让用户输入所要购买的商品数量
当用户输入2时，给用户打印出对应的购物小票
当用户输入3时，退出系统
1.定义商品数据
2.提示用户输入相对应的操作 1.输入商品数量 2.打印小票 3.退出系统
3.接收用户输入的选择
4.使用switch进行判断
5.整体是一个死循环
代码重构
1.定义一个商品项类
2.在成员位置创建两个商品对象
3.给两个商品对象的属性赋值
定义一个方法为商品对象初始化属性的方法 方法名 init 参数 无 返回值 无
4.修改购买方法和打印小票方法 因为里边访问的变量都不存在了 需要改成商品对象去访问属性的方式
*/
//导入Scanner
import java.util.Scanner;
public class Supermarket
{
//定义少林寺酥饼核桃商品对象
static GoodsItem sls = new GoodsItem();
//定义然光Q移商品对象
static GoodsItem rg = new GoodsItem();
public static void main(String[] args)
{
//调用init方法 用来初始化数据
init();
while(true){
//提示用户输入相对应的操作 1.输入商品数量 2.打印小票 3.退出系统
System.out.println("请输入您的操作：1.输入商品数量 2.打印购物小票 3.退出系统");
//接收用户输入的选择 使用Scanner完成
// Scanner sc = new Scanner(System.in);
//调用nextInt方法 接收用户的选择
// int choose = sc.nextInt();
//调用键盘录入整数方法enterNumber接收用户输入的选择
int choose = enterNumber();
//使用switch进行判断用户的选择
switch(choose){
case 1:
//调用buy方法 完成用户输入商品数量
buy();
break;
case 2:
//调用printTicket方法 打印购物小票
printTicket();
break;
case 3:
System.out.println("爱买不买,下次带钱来！！");
System.exit(0);
break;
default:
System.out.println("你瞎啊!");
break;
}
}
}
//定义一个方法为商品对象初始化属性的方法 方法名 init 参数 无 返回值 无
public static void init(){
//给少林寺对象赋值
sls.name = "少林寺酥饼核桃";
sls.id = "090115";
sls.price = 15.50;
//给然光对象赋值
rg.name = "然光Q移";
rg.id = "090028";
rg.price = 16.00;
}
//定义一个键盘录入整数的方法 方法名 enterNumber 需要的数据 无 返回的数据 一个用户输入的整数
public static int enterNumber(){
Scanner sc = new Scanner(System.in);
int number = sc.nextInt();
return number;
}
//将用户输入商品数量封装成方法 方法名 buy 需要的数据 无 返回的数据 无
public static void buy(){
Scanner sc = new Scanner(System.in);
//依次让用户给每个商品的数量重新赋值
System.out.println("请输入少林寺酥饼核桃的购买数量:");
sls.number = sc.nextInt();
sls.money = sls.number*sls.price;
System.out.println("请输入然光Q移的购买数量：");
rg.number = sc.nextInt();
rg.money = rg.number*rg.price;
}
//打印购物小票方法 方法名 printTicket 需要的数据 无 返回的数据 无
public static void printTicket(){
//===============票头=========================
System.out.println(" 欢 迎 光 临");
System.out.println("品名 售价 数量 金额");
System.out.println("-------------------------------------");
//===============票体=========================
System.out.println(sls.name+"("+sls.id+")"+" "+sls.price+" * "+sls.number+" = "+sls.money);
System.out.println(rg.name+"("+rg.id+")"+" "+rg.price+" * "+rg.number+" = "+rg.money);
System.out.println("-------------------------------------");
//===============票脚=========================
//项数
int lineNumber = 2;
//总数量
int totalNumber = sls.number + rg.number;
//总金额
double totalMoney = sls.money + rg.money;
System.out.println(lineNumber+" 项商品 共计："+totalNumber+" 件");
System.out.println("总计:"+totalMoney);
}
}
第3章 综合案例---超市购物小票数据使用集合
3.0.1 案例介绍与演示
将本日第二章内容所有的Person对象放置到集合中使用。
3.0.2 案例分析
a) 重构内容分析
1：将原来的成员位置的多个商品项GoodsItem对象封装到一个ArrayList集合中
2：将所有使用变量值的地方全部改为先从集合中后去对象，再使用GoodsItem对象获取属性值的方式。
b) 实现步骤
-
成员位置定义ArrayList集合
-
定义方法，用于为集合赋值，准备要操作的数据。
-
重构使用到变量的逻辑
将所有使用到成员位置商品项的代码处，均由使用对象名访问对象属性的方式改为先从集合中获取对象，再获取属性值的方式。
3.0.3 自定义类型与集合的使用优点分析
当使用自定义类型时，将数据与数据之间产生了合理必要的联系：一个商品的属性应都属于一个商品，则可以以一个商品作为数据操作的基本单位。
当使用集合时，由原来成员位置定义多个对象改为定义一个集合对象。所有使用数据的地方循环遍历即可，无论有再多新数据的产生，其代码不需要更改。
/*
自定义数据类型 商品项类
属性
商品名称 String
商品id String
商品单价 double
商品数量 int
商品金额 double
*/
public class GoodsItem
{
//商品名称
String name;
//商品id
String id;
//商品单价
double price ;
//商品数量
int number;
//商品金额
double money;
}
/*
使用switch语句完成三个分支的代码逻辑
当用户输入1时，让用户输入所要购买的商品数量
当用户输入2时，给用户打印出对应的购物小票
当用户输入3时，退出系统
1.定义商品数据
2.提示用户输入相对应的操作 1.输入商品数量 2.打印小票 3.退出系统
3.接收用户输入的选择
4.使用switch进行判断
5.整体是一个死循环
代码重构
准备数据
1.定义一个商品项类
2.在成员位置定义一个集合 用来存储所有商品
3.为成员位置的集合初始化商品
4.修改购买和打印小票方法 将商品对象从集合中取出来，访问商品对象的属性
*/
//导入Scanner
import java.util.Scanner;
//导入ArrayList
import java.util.ArrayList;
public class Supermarket2
{
//在成员位置定义一个集合 用来存储所有商品
static ArrayList<GoodsItem> list = new ArrayList<GoodsItem>();
public static void main(String[] args)
{
//调用init方法 用来初始化数据
init();
while(true){
//提示用户输入相对应的操作 1.输入商品数量 2.打印小票 3.退出系统
System.out.println("请输入您的操作：1.输入商品数量 2.打印购物小票 3.退出系统");
//接收用户输入的选择 使用Scanner完成
int choose = enterNumber();
//使用switch进行判断用户的选择
switch(choose){
case 1:
//调用buy方法 完成用户输入商品数量
buy();
break;
case 2:
//调用printTicket方法 打印购物小票
printTicket();
break;
case 3:
System.out.println("爱买不买,下次带钱来！！");
System.exit(0);
break;
default:
System.out.println("你瞎啊!");
break;
}
}
}
//定义一个方法为商品对象初始化属性的方法 方法名 init 参数 无 返回值 无
public static void init(){
//定义少林寺酥饼核桃商品对象
GoodsItem sls = new GoodsItem();
//给少林寺对象赋值
sls.name = "少林寺酥饼核桃";
sls.id = "090115";
sls.price = 15.50;
//定义然光Q移商品对象
GoodsItem rg = new GoodsItem();
//给然光对象赋值
rg.name = "然光Q移";
rg.id = "090028";
rg.price = 16.00;
//定义人参果商品对象
GoodsItem rsg = new GoodsItem();
//给然光对象赋值
rsg.name = "人参果";
rsg.id = "090001";
rsg.price = 111111.00;
//将商品对象添加到集合中
list.add(sls);
list.add(rg);
list.add(rsg);
}
//定义一个键盘录入整数的方法 方法名 enterNumber 需要的数据 无 返回的数据 一个用户输入的整数
public static int enterNumber(){
Scanner sc = new Scanner(System.in);
int number = sc.nextInt();
return number;
}
//将用户输入商品数量封装成方法 方法名 buy 需要的数据 无 返回的数据 无
public static void buy(){
Scanner sc = new Scanner(System.in);
/*
遍历存储商品的集合list，依次获取每个商品
让用户给每个商品的数量赋值
计算每个商品的金额
*/
for(int i = 0 ;i < list.size();i++){
//依次获取每个商品
GoodsItem thisItem = list.get(i);
System.out.println("请输入"+thisItem.name+"商品的购买数量:");
//让用户给每个商品的数量赋值
thisItem.number = sc.nextInt();
//计算每个商品的金额
thisItem.money = thisItem.number * thisItem.price;
}
}
//打印购物小票方法 方法名 printTicket 需要的数据 无 返回的数据 无
public static void printTicket(){
//===============票头=========================
System.out.println(" 欢 迎 光 临");
System.out.println("品名 售价 数量 金额");
System.out.println("-------------------------------------");
//===============票体=========================
/*
遍历商品集合，依次获取每个商品，打印每个商品的属性
*/
for(int i = 0 ;i<list.size();i++){
//依次获取每个商品
GoodsItem thisItem = list.get(i);
//依次获取每个商品
System.out.println(thisItem.name+"("+thisItem.id+")"+" "+thisItem.price+" * "+thisItem.number+" = "+thisItem.money);
}
//System.out.println(sls.name+"("+sls.id+")"+" "+sls.price+" * "+sls.number+" = "+sls.money);
//System.out.println(rg.name+"("+rg.id+")"+" "+rg.price+" * "+rg.number+" = "+rg.money);
System.out.println("-------------------------------------");
//===============票脚=========================
//项数
int lineNumber = list.size();
//总数量
int totalNumber = 0;
//总金额
double totalMoney = 0.0;
/*
遍历商品集合 ，依次获取每个商品
将每个商品的数量累加
将每个商品的金额累加
*/
//遍历商品集合
for(int i = 0 ;i < list.size();i++){
//依次获取每个商品
GoodsItem thisItem = list.get(i);
//总数量
totalNumber += thisItem.number;
//总金额
totalMoney += thisItem.money;
}
System.out.println(lineNumber+" 项商品 共计："+totalNumber+" 件");
System.out.println("总计:"+totalMoney);
}
}
第4章 综合案例---超市购物小票（之前知识）
4.1 案例介绍与演示
使用Eclipse完成day07超市购物小票案例。
package cn.javahelp2;
/*
* 自定义数据类型 商品项类
*
* 属性
*
* 商品id String
* 商品名称 String
* 商品单价 double
* 商品数量 int
* 商品金额 double
*/
public class GoodsItem {
String id;
String name;
double price;
int number;
double money;
}
package cn.javahelp2;
import java.util.ArrayList;
import java.util.Scanner;
/*
* 使用switch语句完成三个分支的代码逻辑
* 当用户输入1时，让用户输入所要购买的商品数量
* 当用户输入2时，给用户打印出对应的购物小票
* 当用户输入3时，退出系统
*
* 分析
* 准备数据
* 1.定义一个商品类
* 2.在成员位置定义一个集合 用来存储所有商品
* 3.定义一个方法 init方法 为集合初始化数据
* 完成整体流程
* 4.提示用户输入相对应的操作 1.购买 2.打印小票 3.退出购买
* 5.接收用户输入的操作
* 调用Scanner的nextInt方法
* 6.使用switch对用户的操作进行判断
* 7.整体流程是一个死循环
* 完成每个方法
* 8.完成购买方法 为集合中每个商品的数量赋值
* 9.完成打印小票方法
* 票头 死数据打印
* 票体 依次打印集合中每个商品的属性
* 票脚 求和
*
*/
public class Supermarket {
//在成员位置定义一个集合 用来存储所有商品
static ArrayList<GoodsItem> list = new ArrayList<GoodsItem>();
public static void main(String[] args) {
//调用init方法为商品集合初始化数据
init();
//整体流程是一个死循环
while(true){
//提示用户输入相对应的操作 1.购买 2.打印小票 3.退出购买
System.out.println("请输入相对应的操作: 1.购买 2.打印小票 3.退出系统");
//接收用户输入的操作
Scanner sc = new Scanner(System.in);
int choose = sc.nextInt();
//使用switch对用户的操作进行判断
switch (choose) {
case 1:
buy();
break;
case 2:
printTicket();
break;
case 3:
System.out.println("爱买不买，下次带钱来！");
System.exit(0);
break;
default:
System.out.println("你瞎啊？这都看不到么！！");
break;
}
}
}
//完成打印小票方法
/*
* 票头
* 死数据打印
* 票体
* 依次打印集合中每个商品的属性
* 遍历集合，依次获取每个商品，打印每个商品的属性信息
* 票脚
* 项数 集合的长度
* 求总数量 所有商品数量的和
* 总金额 所有商品金额的和
* 遍历集合，依次获取每个商品
* 商品数量累加
* 商品金额累加
*/
public static void printTicket() {
//票头
System.out.println(" 欢迎欢迎 ！！ 热烈欢迎！！");
System.out.println("商品名称 商品单价 商品数量 商品金额");
System.out.println("---------------------------------------");
//票体 遍历集合，依次获取每个商品，打印每个商品的属性信息
for (int i = 0; i < list.size(); i++) {
//依次获取每个商品
GoodsItem thisItem = list.get(i);
//打印每个商品的属性信息
System.out.println(thisItem.name+"("+thisItem.id+")"+" "+thisItem.price+" * "+thisItem.number+" = "+thisItem.money);
}
System.out.println("---------------------------------------");
//票脚
//项数
int lineNumber = list.size();
//总数量
int totalNumber = 0;
//总金额
double totalMoney = 0.0;
//遍历集合，依次获取每个商品
for (int i = 0; i < list.size(); i++) {
//依次获取每个商品
GoodsItem thisItem = list.get(i);
//求总数量
totalNumber += thisItem.number;
//求总金额
totalMoney += thisItem.money;
}
System.out.println(lineNumber+" 项商品 共计："+totalNumber+"件");
System.out.println("总价："+totalMoney+"元");
}
//完成购买方法 为集合中每个商品的数量赋值
/*
* 1.创建Scanner对象
* 2.遍历集合，依次获取每个商品，让用户为每个商品的数量赋值，计算商品金额
*/
public static void buy() {
//创建Scanner对象
Scanner sc = new Scanner(System.in);
//遍历集合，依次获取每个商品，让用户为每个商品的数量赋值，计算商品金额
for (int i = 0; i < list.size(); i++) {
//依次获取每个商品
GoodsItem thisItem = list.get(i);
//让用户为每个商品的数量赋值
System.out.println("请输入"+thisItem.name+"商品的购买数量:");
thisItem.number = sc.nextInt();
//计算商品金额
thisItem.money = thisItem.number * thisItem.price;
}
}
//定义一个方法 init方法 为集合初始化数据
/*
* 创建商品对象 给商品对象的属性赋值
* 将商品对象添加到成员位置的集合中
*/
public static void init(){
// 创建商品对象 给商品对象的属性赋值
GoodsItem sls = new GoodsItem();
sls.id = "090018";
sls.name = "少林寺酥饼核桃";
sls.price = 15.50;
GoodsItem rg = new GoodsItem();
rg.id = "090025";
rg.name = "然光Q移";
rg.price = 16.00;
GoodsItem rsg = new GoodsItem();
rsg.id = "090001";
rsg.name = "人参果";
rsg.price = 16000.00;
//将商品对象添加到成员位置的集合中
list.add(sls);
list.add(rg);
list.add(rsg);
}
}
