06_Java基础语法_第6天（自定义类、ArrayList集合）_讲义

傷城~ 2022-05-07 08:12 170阅读 0赞

今日内容介绍  
1、自定义类型的定义及使用  
2、自定义类的内存图  
3、ArrayList集合的基本功能  
4、随机点名器案例及库存案例代码优化

01引用数据类型\_类

*  A: 数据类型
    
     *  a: java中的数据类型分为：基本类型和引用类型
 *  B: 引用类型的分类
    
     *  a: Java为我们提供好的类，比如说：Scanner,Random等。
     *  b: 我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。

02自定义类的概述

*  A: 自定义类的概述
    
     *  **java代码映射成现实事物的过程就是定义类的过程。**
     *  举例：  
        我们就拿一部手机进行分析，它能用来做什么呢？它可以打电话，上网，聊微信等，  
        这些就是手机所提供的功能，也就是方法；手机也有它的特征，如颜色、尺寸大小、品牌型号等，  
        这些就是手机的特征，也就是属性
     *  目前，我们只关注类中的属性，类中的方法在面向对象部分再进行学习。

03自定义类的格式

A: 自定义类的格式
        * a: 使用类的形式,对现实中的事物进行描述。
        * b: 事物由方法和属性两部分组成。
            * 方法: 这个事物具备的功能。
            * 属性: 这个事物具备的特征。
        * c: 格式
            public class 类名{
                属性定义
                  修饰符 数据类型 变量名 = 值
                
                方法定义
                  修饰符 返回值类型  方法名(参数列表){
                      
                  }
            }

04自定义的手机类

/*
    	定义类：
    		使用类的形式,对现实中的事物进行描述
    		事物：方法,属性
    			方法：这个事物具备的功能
    			属性：变量
    		格式：
    			public class 类名{
    				属性定义
    					修饰符 数据类型 变量名 = 值
    				方法定义
    					修饰符 返回值类型 方法名(参数列表){
    						
    						
    					}
    			}
    			要求:使用java中的类,描述生活中的手机这个事物
    				颜色,品牌,大小
    */
    public class phone{
    	/*
    		定义手机的属性
    	*/
    	String color;
    	String brand;
    	double size;
    	
    }

05测试手机类

/*
    	测试,刚定义好的phone类
    	创建引用类型变量的格式
    		数据类型 变量名 = new 数据类型();
    		
    		实现引用类型的步骤
    			1.导入包,类都是同一个文件夹,不需要导入包
    			2.创建引用类型的变量
    			3.变量,类型中的功能
    */
    public class Testphone{
    	public static void main(String[] args){
    		//2.创建引用数据类型的变量
    		phone p = new phone();
    		System.out.println(p);//输出内存的地址
    		
    		//3.变量.类型中的功能
    		//变量p.的方式,调用类中的属性
    		//属性就是变量,赋值和获取值
    		//p.color = "土豪金";
    		//p.brand = "爱立信";
    		//p.size = 4.7;
    		
    		//获取属性值
    		//当上面不赋值,你也会发现有值null null 0.0 说明phone类中的属性,随着容器进入到堆内存
    		//属性进入内存 赋值默认值
    		System.out.println(p.color + " " + p.brand + " " + p.size);
    		
    	}
    }

![在这里插入图片描述][70]  
06自定义类的内存图\_1  
![自定义类的内存图\_1][1]  
07两个引用类型变量内存图  
![在这里插入图片描述][70 1]  
08自定义类的练习  
学习了引用数据类型（类）以后，我们就能够使用类描述任何东西了。看几个具体的描述，如下：  
 电饭锅，包含属性（品牌、容量大小、颜色等）  
 汽车，包含属性（品牌、排量、类型等）  
 学生，包含属性（姓名，年龄，性别等）

/*
    	A:实体类的代码：
    	电饭煲，包含属性(品牌、容量大小、颜色等)
    	定义类，描述事物,电饭煲
    		属性：品牌,大小,颜色
    	
    	定义类,类名字,电饭煲
    	类的范围：定义三个属性
    */
    public class Electric_cooker{
    	//定义三个属性
    	String brand;
    	double size;
    	String color;
    }

/*
    	汽车,包含属性(品牌,排量,类型等)
    	定义类,类名:Car
    		属性:品牌 排量 类型
    */
    public class Car{
    	//定义汽车的三个属性
    	String brand;
    	double Vehicle_displacement;
    	String type;
    }

/*
    	学生,包含属性(姓名,年龄,性别)
    	定义类,类型Student
    		三个属性：姓名,年龄,性别(char)
    */
    public class Student{
    	//定义学生的三个属性
    	String name;
    	int age;
    	char sex;	
    }

/*
    	定义的测试类
    	同时测试：电饭煲,汽车,学生
    	
    	创建引用类型变量的格式
    	数据类型 变量名 = new 数据类型();
    	
    	实现引用类型的步骤
    		1.导入包,类都是同一个文件夹,不需要导入包
    		2.创建引用类型的变量
    		3.变量,类型中的功能
    */
    public class Test{
    	public static void main(String[] args){
    		//创建电饭煲引用类型
    		Electric_cooker dfg = new Electric_cooker();
    		
    		dfg.brand = "特斯拉";
    		dfg.color = "红色";
    		dfg.size = 30;
    		
    		System.out.println("电饭煲" + dfg.brand + " " + dfg.color + " " + dfg.size);
    		
    		//创建汽车引用类型
    		Car c = new Car();
    		c.brand = "巨力";
    		c.type = "拖拉机";
    		c.Vehicle_displacement = 0.5;
    		
    		System.out.println("汽车" + c.brand + " " + c.type + " " + c.Vehicle_displacement);
    		
    		//创建学生引用数据类型
    		Student stu = new Student();
    		
    		stu.name = "小强";
    		stu.age = 18;
    		stu.sex = '男';//char型用单引号包裹
    		
    		System.out.println("学生" + stu.name + " " + stu.age + " " + stu.sex);
    	}
    }

![在这里插入图片描述][70 2]  
09ArrayList集合  
在前面我们学习了数组，数组可以保存多个元素，但在某些情况下无法确定到底要保存多少个元素，此时数组将不再适用，因为数组的长度不可变。例如，要保存一个学校的学生，由于不停有新生来报道，同时也有学生毕业离开学校，这时学生的数目很难确定。为了保存这些数目不确定的元素，JDK中提供了一系列特殊的类，这些类可以存储任意类型的元素，并且长度可变，统称为集合。在这里，我们先介绍ArrayList集合，其他集合在后续课程中学习。  
ArrayList集合是程序中最常见的一种集合，它属于引用数据类型（类）。在ArrayList内部封装了一个长度可变的数组，当存入的元素超过数组长度时，ArrayList会在内存中分配一个更大的数组来存储这些元素，因此可以将ArrayList集合看作一个长度可变的数组。  
09.1 集合的创建  
创建集合的常用格式在此说明一下：  
**导包：import java.util.ArrayList;**  
创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：  
**ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();**  
 集合中存储的元素，只能为<>括号中指定的数据类型元素；  
 **“<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；**  
下面给出8种基本数据类型所对应的引用数据类型表示形式:  
![在这里插入图片描述][70 3]  
10ArrayList创建变量的步骤

* A: ArrayList创建变量的步骤
        * a: 导入包 java.util包中
        * b: 创建引用类型的变量
            数据类型<集合存储的数据类型>  变量名 = new 数据类型<集合存储的数据类型>();
            集合存储的数据类型: 要将数据存储到集合的容器中
            创建集合引用变量的时候,必须要指定好,存储的类型是什么
        * c: 变量名.方法 
            注意: 集合存储的数据,8个基本类型对应8个引用类型
            存储引用类型,不存储基本类型

11ArrayList创建变量举例

/*
    	ArrayList集合的使用
    	也是引用数据类型
    	步骤：
    		1.导入包 java.util包中
    		2.创建引用类型的变量
    			数据类型<集合存储的数据类型> 变量名 = new 数据类型<集合存储的数据类型>();
    			集合存储的数据类型：要将数据存储到集合的容器中
    			创建集合引用变量的时候,必须要制定好,存储的类型是什么
    			
    			ArrayList<String> array = new ArrayList<String>();
    		3.变量名.方法
    		
    		注意：集合存储的数据,8个基本类型对应8个引用类型
    		存储引用类型,不存储基本类型
    */
    import java.util.ArrayList;
    
    public class ArrayListDemo{
    	public static void main(String[] args){
    			//创建集合容器,指定存储的数据类型
    			//存储字符串
    			ArrayList<String> array = new ArrayList<String>();
    			
    			//创建集合容器,存储整数
    			//ArrayList<int> array1 = new ArrayList<int>();//报错,集合存储的数据不存储基本类型
    			//int===》Integer
    			ArrayList<Integer> array1 = new ArrayList<Integer>();
    			
    			//创建集合类型,存储手机类型
    			ArrayList<Phone> array2 = new ArrayList<Phone>();
    	}
    	
    }

12ArrayList的常见方法

接下来，我们来学习下ArrayList集合提供的一些常用方法，如下表：  
![在这里插入图片描述][70 4]  
通过代码演示上述方法的使用。ArrayListDemo01.java

/*
    	ArrayList集合中的方法：
    	add(参数类型)向集合中添加元素,数据存储进去
    	方法中的参数类型,定义结合对象时候的类型是一致的
    	
    	ArrayList<Integer> array = new ArrayList<Integer>();
    	array.add(3);
    	
    	get(int index)取出集合中的元素,get方法的参数,写入索引
    	
    	size()返回集合的长度,集合存储元素的个数
    */
    import java.util.ArrayList;
    
    public class ArrayListDemo_1{
    	public static void main(String[] args){
    		//定义集合,存储字符串元素
    		ArrayList<String> array = new ArrayList<String>();
    		
    		//调用集合方法add存储元素
    		array.add("I ");
    		array.add("love ");
    		array.add("java ");
    		array.add("hehe ");
    		array.add("hehe");
    		
    		//输出集合的长度,调用集合方法size,size方法的返回值类型int
    		int size = array.size();
    		System.out.println(size);
    		
    		//获取出集合中的一个元素,获取1索引的元素
    		//集合的方法get(),获取元素后结果数据类型
    		//String s = array.get(11);//Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 11, Size: 5
    		String s = array.get(1);
    		System.out.println(s);
    		
    	}
    	
    }

强调一点，ArrayList集合相当于是一个长度可变的数组，所以访问集合中的元素也是采用索引方式访问，第一个元素存储在索引0的位置，第二个元素存储在索引1的位置，依次类推。

13ArrayList集合的遍历  
通过集合遍历，得到集合中每个元素，这是集合中最常见的操作。集合的遍历与数组的遍历很像，都是通过索引的方式，集合遍历方式如下：ArrayListDemo02.java

/*
    	ArrayList集合中的遍历：
    	实现的思想也是索引思想
    	集合的索引从0开始,到size()-1
    	方法get(int index)
    */
    import java.util.ArrayList;
    
    public class ArrayListDemo_2{
    	public static void main(String[] args){
    		//定义集合,存储字符串元素
    		ArrayList<String> array = new ArrayList<String>();
    		
    		//调用集合方法add存储元素
    		array.add("I ");
    		array.add("love ");
    		array.add("java ");
    		array.add("hehe ");
    		array.add("hehe");
    		
    		//输出集合的长度,调用集合方法size,size方法的返回值类型int
    		int size = array.size();
    		System.out.println(size);
    		
    		//获取出集合中的一个元素,获取1索引的元素
    		//集合的方法get(),获取元素后结果数据类型
    		//String s = array.get(11);//Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 11, Size: 5
    		String s = array.get(1);
    		System.out.println(s);
    		
    		//遍历数组
    		//使用方法size+get组合进行遍历
    		for(int i = 0; i < array.size(); i++){
    			System.out.println(array.get(i));
    		}
    	}
    	
    }

![在这里插入图片描述][70 5]  
14ArrayList补充方法  
ArrayList集合提供的一些常用方法，如下表：  
![在这里插入图片描述][70 6]  
 boolean add（int index, Object obj）  
 功能：在集合中指定index位置，添加新元素obj  
 功能说明：假设集合list中有元素\[“java”,“javaEE”\]，当使用add(1，“javaWeb”)后，集合list中的元素为\[“java”,“javaWeb”,“JavaEE”\]。  
 Object set（int index, Object obj）  
 功能：用指定元素obj替代集合中指定index位置的元素  
 功能说明：假设集合list中有元素\[“java”,“javaEE”\]，当使用set(0，“javaWeb”)后，集合list中的元素为\[“javaWeb”,“JavaEE”\]。  
 Object remve（int index）  
 功能：从集合中删除指定index处的元素，返回该元素  
 功能说明：假设集合list中有元素\[“java”,“javaEE”\]，当使用remove(0)后，集合list中的元素为\[“JavaEE”\]，返回值为“java”。  
 void clear（）  
 功能：清空集合中所有元素  
 功能说明：假设集合list中有元素\[“java”,“javaEE”\]，当使用clear()后，集合list中的元素为空\[\]。

/*
    	集合ArrayList方法的补充：
    		add(int 索引,存储的元素)  将元素添加到指定的索引上
    		set(int 索引,修改后的元素) 将指定索引的元素,进行修改
    		remove(int 索引) 删除指定索引上的元素
    		clear() 清空集合中所有的元素
    */
    import java.util.ArrayList;
    
    public class ArrayListDemo_3{
    	public static void main(String[] args){
    		ArrayList<Integer> array = new ArrayList<Integer>();
    		array.add(1);
    		array.add(2);
    		array.add(3);
    		System.out.println("add(int 索引,存储的元素)  将元素添加到指定的索引上");
    		//在索引2上,添加元素7
    		array.add(2,7);
    		//使用方法size+get组合进行遍历
    		for(int i = 0; i < array.size(); i++){
    			System.out.println(array.get(i));
    		}
    		System.out.println("set(int 索引,修改后的元素) 将指定索引的元素,进行修改");
    		//将0索引上的元素,修改成10
    		array.set(0,10);
    		//使用方法size+get组合进行遍历
    		for(int i = 0; i < array.size(); i++){
    			System.out.println(array.get(i));
    		}
    		System.out.println("remove(int 索引) 删除指定索引上的元素");
    		//将1索引上的元素,删除
    		array.remove(1);
    		//使用方法size+get组合进行遍历
    		for(int i = 0; i < array.size(); i++){
    			System.out.println(array.get(i));
    		}
    		System.out.println("clear() 清空集合中所有的元素");
    		//清空元素
    		array.clear();
    		//使用方法size+get组合进行遍历
    		for(int i = 0; i < array.size(); i++){
    			System.out.println(array.get(i));
    		}
    	}
    	
    }

![在这里插入图片描述][70 7]  
15随机点名器案例分析  
随机点名器案例  
15.1 案例介绍  
随机点名器，即在全班同学中随机的找出一名同学，打印这名同学的个人信息。  
此案例在我们昨天课程学习中，已经介绍，现在我们要做的是对原有的案例进行升级，使用新的技术来实现。  
我们来完成随机点名器，它具备以下3个内容：  
 存储所有同学姓名  
 总览全班同学姓名  
 随机点名其中一人，打印到控制台  
15.2 案例需求分析  
全班同学中随机的找出一名同学，打印这名同学的个人信息。  
我们对本案例进行分析，得出如下分析结果：  
1.存储全班同学信息（姓名、年龄）  
2.打印全班同学每一个人的信息（姓名、年龄）  
3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学信息（姓名、年龄）  
随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。  
而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们采用ArrayList集合来解决多个学生信息的存储问题。

* A: 随机点名器案例分析
        全班同学中随机的找出一名同学，打印这名同学的个人信息。
        我们对本案例进行分析，得出如下分析结果：
            1.存储全班同学信息（姓名、年龄）
                将容器换成集合，集合中存的是Student类型
            2.打印全班同学每一个人的信息（姓名、年龄）
                 遍历集合
            3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学信息
            （姓名、年龄）
            随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长
            ，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。
            而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，
                则会出现过多孤立的变量，很难一次性将全部数据持有。
            此时，我们采用ArrayList集合来解决多个学生信息的存储问题

/*
    	随机点名器,集合改进(学生的姓名和年龄)
    	现实中有学生这个事物,使用定义类的形式,描述学生事物
    	属性：姓名,年龄
    	
    	姓名存储了数组,将容器换成是集合
    	String[] s = {"",""};
    	集合中,存储的是学生的姓名嘛？应该存储Student类型
    	
    	存储学生：
    		学生类型,存储到集合中
    	总览：遍历集合
    	随机：随机数,作为索引,到集合中找到元素
    	
    	三个功能,共享的数据,集合容器
    	定义三个方法,必须参数传递集合
    	
    	类，它是引用数据类型，与之前学习的所有引用数据类型相同，
    	自定义类也是一种数据类型。
    	只是自定义类型并非Java为我们预先提供好的类型，而是我们自己定义的一种引用数据类型用来描述一个事物。
    	
    	创建集合的常用格式在此说明一下：
    	C1:导包：import java.util.ArrayList;
    	C2:创建对象：与其他普通的引用数据类型创建方式完全相同，但是要指定容器中存储的数据类型：
    	C3:ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();
    	“<要存储元素的数据类型>”中的数据类型必须是引用数据类型，不能是基本数据类型；
    	
    	类的名字：首字母大写，第二个单词首字母大写 例如：BeiJngShiHaiDiangQuYiYuan
    		public class HelloWorld{   
    				
    		方法的名字：首字母小写，每个单词首字母大写 例如：addSchool
    		
    		public static void main(String[] args){		//2.定义主方法
    
    	随机数类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。
    
    */
    //C1:导包：import java.util.ArrayList;
    import java.util.ArrayList;
    // R1：导包:import java.util.Random;
    import java.util.Random;
    
    public class CallName{
    	public static void main(String[] args){
    		//1.定义集合,存储的是StudentName类型变量
    		ArrayList<StudentName> array = new ArrayList<StudentName>();
    		System.out.println("--------------------学生随机点名系统----------------------");
    		
    		System.out.println("1.添加学生姓名");
    		//2.调用添加方法
    		add(array);
    		
    		System.out.println("2.遍历学生姓名");
    		//3.调用遍历集合
    		printArrayList(array);
    		
    		System.out.println("3.随机点名功能");
    		//4.集合中随机抽取元素
    		randomStudentName(array);
    		//结束程序
    		System.out.println("============已退出系统===========================");
    	}
    	/*
    		定义方法,实现存储学生的姓名和年龄
    		返回值？没有
    		参数？创建StudentName类型变量,存储到集合中
    	*/
    	public static void add(ArrayList<StudentName> array){
    		//创建StudentName类型变量
    		StudentName sn1 = new StudentName();
    		StudentName sn2 = new StudentName();
    		StudentName sn3 = new StudentName();
    		StudentName sn4 = new StudentName();
    		
    		sn1.name = "张三1";
    		sn1.age = 21;
    		
    		sn2.name = "张三2";
    		sn2.age = 22;
    		
    		sn3.name = "张三3";
    		sn3.age = 23;
    		
    		sn4.name = "张三4";
    		sn4.age = 24;
    		
    		//将StudentName变量,存储到集合中
    		array.add(sn1);
    		array.add(sn2);
    		array.add(sn3);
    		array.add(sn4);
    		System.out.println("============添加学生姓名结束==================");
    	}
    	
    	/*
    		总览学生的信息,遍历集合中的元素
    		返回值？没有
    		参数？创建StudentName类型变量,存储到集合中
    	*/
    	public static void printArrayList(ArrayList<StudentName> array){
    		for(int i = 0; i < array.size(); i++){
    			//存储集合的时候,集合.add(sn1) sn1是StudentName类型变量
    			//获取的时候,集合.get()方法,获取出来的是什么,还是StudentName类型变量
    			StudentName s = array.get(i);
    			System.out.println("学生姓名 " + s.name + " 学生年龄 " + s.age);
    		}	
    		System.out.println("============遍历学生姓名结束==================");	
    	}
    	
    	/*
    		随机数,当作集合的索引,到集合中找到元素
    		返回值？没有
    		参数？存储StudentName类型变量的集合
    	*/
    	public static void randomStudentName(ArrayList<StudentName> array){
    		//R2:创建实例格式：Random 变量名 = new Random();
    		Random ran = new Random();
    		//R3:调用方法
    		int ranIndex = ran.nextInt(array.size());
    		//随机数,索引,到集合中get到StudentName类型变量
    		StudentName s = array.get(ranIndex);
    		System.out.println("学生姓名 " + s.name + " 学生年龄 " + s.age);
    	}
    }

![在这里插入图片描述][70 8]  
![在这里插入图片描述][70 9]  
16 库存案例修改库存清单及测试代码的实现  
16.1 案例介绍  
现在，我们将原有的库存管理案例，采用更好的集合方式实现。  
![在这里插入图片描述][70 10]  
将对下列功能进行方法封装：  
 打印库存清单功能  
 库存商品数量修改功能  
 退出程序功能  
16.2 案例需求分析  
管理员能够进行的操作有3项（查看、修改、退出），我们可以采用（switch）菜单的方式来完成。  
\-------------库存管理------------  
1.查看库存清单  
2.修改商品库存数量  
3.退出  
请输入要执行的操作序号：  
每一项功能操作，我们采用方法进行封装，这样，可使程序的可读性增强。  
选择“1.查看库存清单”功能，则控制台打印库存清单  
选择“2.修改商品库存数量”功能，则对每种商品库存数进行更新  
选择“3.退出”功能，则退出库存管理，程序结束  
16.3 实现代码

/*
    	集合应该是方法参数传递的
    	实现库存管理案例：
    		1.存储商品信息
    		 创建出集合,存储商品类型变量
    		 将商品类型的变量,存储到集合中
    		 
    		2.查看库存清单
    			将集合进行遍历,获取出集合中存储的Goods类型变量
    			输出每个Goods类型的属性
    			计算求和：总库存,总金额
    			
    		3.修改商品的库存
    			集合遍历,获取出集合中存储的Goods类型变量
    			变量调用Goods类的属性count值,进行修改(键盘输入)
    */
    //import java.util.*;===>把util里所有类导进来
    import java.util.ArrayList;
    
    //Scanner类使用步骤：
    //S1:导包
    import java.util.Scanner;
    
    public class Shopp{
    	public static void main(String[] args){
    		//创建ArrayList集合,存储Goods类型
    		ArrayList<Goods> array = new ArrayList<Goods>();
    		//调用添加商品信息的方法
    		addGoods(array);	
    		//进入死循环中
    		while(true){
    			//调用选择功能的方法,获取到用输入的功能序号
    			int number = chooseFunction();
    			//对序号判断:1-进入查看库存功能 2-进入修改库存功能 3-结束
    			switch(number){
    				case 1:
    					//进入查看库存,调用查看库存的方法,传递存储商品信息的集合
    					printStore(array);
    				break;
    				
    				case 2:
    					//进入修改库存功能,调用查看库存的方法
    					update(array);
    				break;
    				
    				case 3:
    					//结束系统
    					return;
    					 
    				default:
    					System.out.println("功能还在完善中...");
    				break;
    			}
    		}
    		
    		
    	}
    	/*
    		定义方法,将商品的信息存储到集合中
    		集合是所有方法的共享数据,参数传递
    	*/
    	public static void addGoods(ArrayList<Goods> array){
    		//创建商品类型变量 Goods类型的变量
    		Goods g1 = new Goods();
    		Goods g2 = new Goods();
    		g1.brand = "MacBook";
    		g1.size = 13.3;
    		g1.price = 9999.99;
    		g1.count = 3;
    		
    		g2.brand = "Thinkpad";
    		g2.size = 15.6;
    		g2.price = 7999.99;
    		g2.count = 1;
    		
    		//Goods类型的变量,存储到集合中
    		array.add(g1);
    		array.add(g2);
    		
    	}
    	/*
    		定义方法,查看库存清单,遍历集合
    		
    	*/
    	public static void printStore(ArrayList<Goods> array){
    		//输出表头
    		//1.实现表头固定数据，打印输出语句
    		System.out.println("--------------------商城库存清单--------------------");
    		System.out.println("品牌型号         尺寸         价格         库存数");
    		//2.表尾部，一部分固定数据，一部分需要科学计算
    		//定义变量,保存总库存数和总金额
    		int totalCount = 0;
    		double totalPrice = 0;
    		//3.遍历集合
    		for(int i = 0;i < array.size();i++){
    			//get(索引)获取集合中的元素,存储的是Goods类,获取的也是Goods类型
    			//使用Gooos类型变量,接受get方法的结果
    			Goods g = array.get(i);
    			//利用获取到的Goods类型,去取到商品类的属性
    			System.out.println(g.brand + "       " + g.size + "         " + g.price + "       " + g.count);
    			totalCount += g.count;
    			totalPrice += g.count * g.price;
    		}		
    		//4.打印尾部数据
    		System.out.println("总库存数：" + totalCount + " 台");
    		System.out.println("库存商品总金额：" + totalPrice + " 元");
    		System.out.println("----------------------------------------------------");
    	}
    	/*
    		方法定义,修改库存
    		键盘的输入,将Goods中的属性值,修改
    	*/
    	public static void update(ArrayList<Goods> array){
    		//遍历集合,遍历到一个,修改一个
    		//1.接受键盘输入
    		Scanner sc = new Scanner(System.in);
    		for(int i = 0;i < array.size();i++){
    			//集合方法get获取的是集合的元素,元素的类型Goods类型
    			Goods g = array.get(i);
    			System.out.println("请输入" + g.brand + "的库存数");
    			//键盘输入,录入库存,存储到库存的数组中
    			int newCount = sc.nextInt();
    			//Goods属性,count进行修改
    			g.count = newCount;
    		}		
    	}
    	/*
    		定义方法,实现选择菜单,根据功能选择菜单
    	
    	*/
    	public static int chooseFunction(){
    		System.out.println("--------------------库存管理----------------------");
    		System.out.println("1.查看库存清单");
    		System.out.println("2.修改商品库存管理");
    		System.out.println("3.退出系统");
    		System.out.println("请输入要执行的操作序号：");
    		//S2:创建Scanner对象实例
    		Scanner sc = new Scanner(System.in);
    		return sc.nextInt();//S3:用来接收控制台录入的数字		
    	}
    }

![在这里插入图片描述][70 11]  
![在这里插入图片描述][70 12]  
17 总结  
17.1 知识点总结  
 引用数据类型（类）  
 类的类型为两种：  
 第一种，Java为我们提供好的类，如Scanner类，Scanner类等，这些已存在的类中包含了很多的方法与属性，可供我们使用。  
 第二种，我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。  
 创建类的格式

public class 类名 {
                  //可以定义属性
                  //也可以定义方法
    }

 使用类的格式：

类名 变量名 = new 类名();

 使用类中的属性与方法格式

使用属性： 变量名.属性
    使用方法： 变量名.方法()

 ArrayList集合  
 它属于引用数据类型（类）。我们可以看作一个长度可变的数组。  
 创建集合的方式

ArrayList<要存储元素的数据类型> 变量名 = new ArrayList<要存储元素的数据类型>();

 集合中的常用方法  
 boolean add（Object obj）  
 Object get（int index）  
 int size（）  
 boolean add（int index, Object obj）  
 Object set（int index, Object obj）  
 Object remve（int index）  
 void clear（）

[70]: /images/20220506/147f0dc3874a459b809bf2d14a71489e.png
[1]: /images/20220506/d6fca39388a44eb8a9c45d00b9220d42.png
[70 1]: /images/20220506/5831993f5b744565bb6dd1cd168dd173.png
[70 2]: /images/20220506/2a66e473dc7243bb95d28fbf3f0b29da.png
[70 3]: /images/20220506/019bc8781437468e91ac17197855cfd2.png
[70 4]: /images/20220506/6df2080ffccd43d0867652e3d1894230.png
[70 5]: /images/20220506/780727da3c6d4f93af50620a9fa6ce16.png
[70 6]: /images/20220506/6f05fa0ffc574124a7c2fed1774987f9.png
[70 7]: /images/20220506/c691ed4eebf3490294434a77351252c7.png
[70 8]: /images/20220506/e8124886c3bd4e458f12786b3fd98d87.png
[70 9]: /images/20220506/743f9283c6a74e4eaaf3d8731cf5c961.png
[70 10]: /images/20220506/ef0e964ef7d846d7b02f3a94258eadaa.png
[70 11]: /images/20220506/a02d061f80b3409bb5ad7ec0c232d4e5.png
[70 12]: /images/20220506/e9675c7187a145abbbe6fed265553bd2.png