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

今日内容介绍
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自定义的手机类

* A: 自定义的手机类
    * a: 案例代码
        public class Phone{
            /*
                定义手机的属性
            */
            String color ;
            String brand ;
            double size ;
        }

05测试手机类

* A: 调用方法执行流程
    * a: 实现引用类型的步骤
        * 1: 导入包 , 类都是在同一个文件夹,不需要导入包
        * 2: 创建引用类型的变量
        * 3: 变量.类型中的功能
    * b: 案例代码
        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 = 5.0;

                //获取属性值
                System.out.println(p.color+"  "+p.brand+"  "+p.size);
            }
        }

06自定义类的内存图_1

* A: 自定义类的内存图_1

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

07自定义类的内存图_2

* A: 自定义类的内存图_1

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

08两个引用类型变量内存图

* A: 自定义类的内存图_1
*

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

09自定义类的练习

* A: 实体类的代码
    /*
        电饭锅,包含属性(品牌、容量大小、颜色等)
        定义类,描述事物,电饭锅
          属性: 品牌,大小 ,颜色

        定义类,类名字,电饭锅
        类的范围,定义三个属性
    */
    public class DianFanGuo{
        //定义三个属性
        String brand ;
        double size ;
        String color ;
    }

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

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

* B: 测试类的代码
    /*
       定义的测试类
       同时测试,电饭锅,汽车,学生
    */
    public class Test{
        public static void main(String[] args){
            //创建电饭锅引用类型
            DianFanGuo dfg = new DianFanGuo();

            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.paiLiang = 0.5;

            System.out.println(c.brand+"  "+c.type+"  "+c.paiLiang);

            //创建学生引用类型
            Student stu = new Student();
            stu.name = "张三";
            stu.age = 20;
            stu.sex = '男';
            System.out.println(stu.name+"  "+stu.age+"  "+stu.sex);

        }
    }

10ArrayList创建变量的步骤

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

11ArrayList创建变量举例

* A: ArrayList创建变量的示例代码
    import java.util.ArrayList;
    public class ArrayListDemo{
        public static void main(String[] args){
            //创建集合容器,指定存储的数据类型
            //存储字符串
            ArrayList<String> array = new ArrayList<String>();

            //创建集合容器,存储整数
            ArrayList<Integer> array2 = new ArrayList<Integer>();

            //创建集合容器,存储手机类型
            ArrayList<Phone> array3 = new ArrayList<Phone>();
        }
    }

12ArrayList的常见方法

* A: ArrayList的常见方法
    * a: add(参数) 向集合中添加元素
    * b: get(int index) 取出集合中的元素,get方法的参数,写入索引
    * c: size() 返回集合的长度, 集合存储元素的个数
* B: 案例代码
    import java.util.ArrayList;
    public class ArrayListDemo_1{
        public static void main(String[] args){
            //定义集合,存储字符串元素
            ArrayList<String> array = new ArrayList<String>();
            //调用集合方法add存储元素
            array.add("abc");
            array.add("itcast");
            array.add("love");
            array.add("java");
            //输出集合的长度,调用集合方法size, size方法的返回值类型 int
            int size = array.size();
            System.out.println(size);

            //获取出集合中的一个元素,获取1索引的元素
            //集合的方法get, 获取元素后结果数据类型
            String s = array.get(1);
            System.out.println(s);

            System.out.println(array.get(0));
            System.out.println(array.get(1));
            System.out.println(array.get(2));
            System.out.println(array.get(3));
        }
    }

13ArrayList集合的遍历

* A: 案例代码
    /*
       集合的遍历
       实现思想也是索引思想
       集合的索引从0开始,到 size()-1
       方法get(int index)
    */
    import java.util.ArrayList;
    public class ArrayListDemo_2{
        public static void main(String[] args){
            ArrayList<Integer> array = new ArrayList<Integer>();
            array.add(121);
            array.add(125);
            array.add(123);
            array.add(120);
            array.add(128);

            //对集合进行遍历
            //使用方法 size+get组合进行遍历
            for(int i = 0 ; i < array.size(); i++){
                System.out.println( array.get(i) );
            }
        }
    }

14ArrayList补充方法

* A: ArrayList补充方法
    * a: add(int 索引,存储的元素)  将元素添加到指定的索引上
    * b: set(int 索引,修改后的元素)     将指定索引的元素,进行修改
    * c: remove(int 索引)             删除指定索引上的元素
    * d: clear()                    清空集合中的所有元素
* B: 案例代码
    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);
            array.add(4);

            //在索引2上,添加元素7
            array.add(2,7);

            //将0索引上的元素,修改成10
            array.set(0,10);

            //将4索引上的元素,删除
            array.remove(4);

            array.clear();

            //使用方法 size+get组合进行遍历
            for(int i = 0 ; i < array.size(); i++){
                System.out.println( array.get(i) );
            }
        }
    }
         

15随机点名器案例分析

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

16随机点名器代码实现

* A: 随机点名器案例代码
    /*
       随机点名器,集合改进 (学生的姓名和年龄)
       现实中有学生这个事物,使用定义类的形式,描述学生事物
       属性: 姓名,年龄

       姓名存储了数组, 将容器换成是集合
       String[] s = {"",""};
       集合中,存储的是学生的姓名吗?  应该存储Student类型

       存储学生:
          学生类型,存储到集合中
       总览: 遍历集合
       随机: 随机数,作为索引,到集合中找到元素
       三个功能,共享的数据,集合容器,
       定义三个方法,必须参数传递集合
    */
    import java.util.ArrayList;
    import java.util.Random;
    public class CallName{
        public static void main(String[] args){
            //定义集合,存储的是StudentName类型变量
            ArrayList <StudentName> array = new ArrayList<StudentName>();
            //调用添加方法
            add (array);
            //调用遍历集合
            printArrayList(array);

            randomStudentName(array);
        }
        /*
          随机数,当作集合的索引,到集合中找到元素
        */
        public static void randomStudentName(ArrayList<StudentName> array ){
            Random r = new Random();
            int number = r.nextInt( array.size());
            //随机数,索引,到集合中get
            StudentName s = array.get(number);
            System.out.println( s.name +"  "+s.age);
        }

        /*
            总览学生的信息,遍历集合
        */
        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);
            }
        }

        /*
           定义方法,实现存储学生的姓名和年龄
           创建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();
            StudentName sn5 = new StudentName();

            sn1.name = "张三1";
            sn1.age = 201;

            sn2.name = "张三2";
            sn2.age = 202;

            sn3.name = "张三3";
            sn3.age = 203;

            sn4.name = "张三4";
            sn4.age = 204;

            sn5.name = "张三5";
            sn5.age = 205;

            //将StudentName变量,存储到集合中
            array.add(sn1);
            array.add(sn2);
            array.add(sn3);
            array.add(sn4);
            array.add(sn5);
        }
    }

17库存案例分析加入集合

* A: 库存案例分析加入集合
    * a: 参见\day06\day06(面向对象\day06_source\对象内存图.JPG

18库存案例添加商品信息

* A: 案例代码
    /*
       定义,.描述商品的类
       商品 4个属性
         商品名字  大小     价格    库存
          String    double   double  int

        定义类,类名Goods
        这个类型的变量,存储到集合中
    */
    public class Goods{
        //定义商品名字
        String brand ;
        //大小属性
        double size ;
        // 价格属性
        double price ;
        //库存属性
        int count ;
    }

    /*
        实现库存管理案例:
          1.存储商品信息
            存储商品类型变量
            将商品类型的变量,存储到集合中
    */
    //import java.util.ArrayList;
    import java.util.*;
    public class Shopp{
        public static void main(String[] args){
            //创建ArrayList集合,存储Goods类型
            ArrayList<Goods> array = new ArrayList<Goods>();
            //调用添加商品信息的方法
            addGoods(array);
        }

        /*
           定义方法,将商品的信息存储到集合中
           集合是所有方法的共享数据,参数传递
        */
        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);
        }
    }

19库存案例查看库存清单

* A: 案例代码
    /*
        实现库存管理案例:
          1.存储商品信息
            存储商品类型变量
            将商品类型的变量,存储到集合中

          2.查看库存清单
            将集合进行遍历, 获取出集合中存储的Goods类型变量
            输出每一个Goods类型的属性
            计算求和: 总库存,总金额
    */
    //import java.util.ArrayList;
    import java.util.*;
    public class Shopp{
        public static void main(String[] args){
            //创建ArrayList集合,存储Goods类型
            ArrayList<Goods> array = new ArrayList<Goods>();
            //调用添加商品信息的方法
            addGoods(array);
        }

        /*
           定义方法,查看库存清单,遍历集合
        */
        public static void printStore(ArrayList<Goods> array){
            //输出表头
            System.out.println("----------商场库存清单----------");
            System.out.println("品牌型号     尺寸    价格    库存数");
            //定义变量,保存总库存数,和总金额
            int totalCount = 0 ;
            double totalMoney = 0;
            //遍历集合
            for(int i = 0 ; i < array.size(); i++){
                //get(索引)获取出集合中的元素,存储的是Goods类,获取的也是Goods类型
                //使用Goods类型变量,接受get方法结果
                Goods g = array.get(i);
                System.out.println(g.brand+"   "+g.size+"    "+g.price+"    "+g.count);
                totalCount = totalCount+g.count;
                totalMoney = totalMoney + g.count*g.price;
            }
            System.out.println("总库存数: "+totalCount);
            System.out.println("商品库存总金额: "+totalMoney);
        }

        /*
           定义方法,将商品的信息存储到集合中
           集合是所有方法的共享数据,参数传递
        */
        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);
        }
    }

20库存案例修改库存清单及测试代码的实现

* A: 案例代码
    /*
        实现库存管理案例:
          1.存储商品信息
            存储商品类型变量
            将商品类型的变量,存储到集合中

          2.查看库存清单
            将集合进行遍历, 获取出集合中存储的Goods类型变量
            输出每一个Goods类型的属性
            计算求和: 总库存,总金额

         3.修改商品的库存
            集合遍历 ,获取出集合中存储的Goods类型变量
            变量调用Goods类的属性count,值进行修改 (键盘输入)
    */
    //import java.util.ArrayList;
    import java.util.*;
    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;
                }
            }
        }
        /*
          方法定义,修改库存
          键盘的输入,将Goods中的属性值,修改
        */
        public static void update(ArrayList<Goods> array){
            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+"的库存数");
                //Goods属性,count进行修改
                g.count = sc.nextInt();
            }
        }
        /*
           定义方法,实现选择菜单,用户根据功能选择菜单
        */
        public static int chooseFunction(){
            System.out.println("-------------库存管理------------");
            System.out.println("1.查看库存清单");
            System.out.println("2.修改商品库存数量");
            System.out.println("3.退出");
            System.out.println("请输入要执行的操作序号:");
            Scanner sc = new Scanner(System.in);
            int number = sc.nextInt();
            return number;
        }

        /*
           定义方法,查看库存清单,遍历集合
        */
        public static void printStore(ArrayList<Goods> array){
            //输出表头
            System.out.println("----------商场库存清单----------");
            System.out.println("品牌型号     尺寸    价格    库存数");
            //定义变量,保存总库存数,和总金额
            int totalCount = 0 ;
            double totalMoney = 0;
            //遍历集合
            for(int i = 0 ; i < array.size(); i++){
                //get(索引)获取出集合中的元素,存储的是Goods类,获取的也是Goods类型
                //使用Goods类型变量,接受get方法结果
                Goods g = array.get(i);
                System.out.println(g.brand+"   "+g.size+"    "+g.price+"    "+g.count);
                totalCount = totalCount+g.count;
                totalMoney = totalMoney + g.count*g.price;
            }
            System.out.println("总库存数: "+totalCount);
            System.out.println("商品库存总金额: "+totalMoney);
        }

        /*
           定义方法,将商品的信息存储到集合中
           集合是所有方法的共享数据,参数传递
        */
        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);
        }
    }

作业测试

1.简述自定义数据类型的定义格式和使用方式?

class MyObject{}
class Demo{
    public static void main(){
        MyObject m = new MyObject();//定义了数据类型
    }
}

2.简述ArrayList集合的定义格式和常用方法的功能?

    格式:ArrayList<Object> array = new ArrayList<Object>();
    add(Obbject);//直接储存元素
    add(index,Object);在指定位置储存元素
    size();//获取集合长度
    iterator();//获取集合的迭代方式
    set(index,Object);//设置指定元素
    get(index);//获取指定元素
    remove(index);//删除指定位置的元素

4.以下选项错误的是?

A.获取数组的长度用length方法//错误 是属性
B.获取字符串的长度用length属性//错误 是方法
C.获取集合ArrayList的长度用length方法//错误 用size();方法
D.获取数组的长度用length属性//正确
E.获取字符串的长度用length方法//正确
F.获取集合ArrayList的长度用length属性//错误
G.获取集合ArrayList的长度用size属性//错误
H.获取集合ArrayList的长度用size方法//正确

5.定义一个学生类Student,包含三个属性姓名、年龄、性别,创建三个学生对象存入ArrayList集合中。

  A:遍历集合遍历输出。
  B:求出年龄最大的学生,让后将该对象的姓名变为:葫芦娃。

6.定义一个手机类Phone,包含三个属性品牌(brand)、价格(price)、颜色(color)。
创建四个手机("小米"、"华为"、"乐视"、"奇酷")对象存入ArrayList集合中,并遍历输出。

7.定义一个员工类Employee,包含三个属性姓名、工号、工资,创建三个员工对象存入ArrayList集合中,并遍历输出。

8.利用上面的三个案例,分别演示ArrayList集合中的以下常用方法:

 *  public boolean add(元素类型 e)直接向集合添加元素

 *  public void add(int index,元素类型 e)在指定索引处向集合添加元素

 *  public 元素类型 remove(int index)删除指定索引位置的元素

 *  public 元素类型 set(int index,元素类型 e)修改指定索引位置的元素

 *  public int size()获取集合长度

 *  public 元素类型 get(int index)根据指定索引获取集合元素

以上三题代码实现:

package cn.itheima.homework;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/**
 * 定义一个学生类Student,包含三个属性姓名、年龄、性别,创建三个学生对象存入ArrayList
 * 集合中遍历集合遍历输出。求出年龄最大的学生,
 * 让后将该对象的姓名变为:葫芦娃。
 *
 * @author 边天旭
 *
 *         定义一个手机类Phone,包含三个属性品牌(brand)、价格(price)、颜色(color)。
 *         创建四个手机("小米"、"华为"、"乐视"、"奇酷")对象存入ArrayList集合中,并遍历输出。
 */

public class HomeWork_01 {
    public static void main(String[] args) {
        // 定义一个学生类Student,包含三个属性姓名、年龄、性别,创建三个学生对象存入ArrayList集合中。
        List<Student> list = new ArrayList<Student>();
        Student s1 = new Student("天旭", 17, "男");
        Student s2 = new Student("庆哥", 27, "男");
        Student s3 = new Student("楠姐", 23, "女");
        list.add(s1);
        list.add(s2);
        list.add(s3);
        // A:遍历集合遍历输出。
        Iterator<Student> it = list.iterator();
        int index = 0;
        int ageArray[] = new int[list.size()];
        while (it.hasNext()) {
            System.out.println(it.next());
            ageArray[index] = list.get(index).getAge();
            index++;
        }
        // B:求出年龄最大的学生,让后将该对象的姓名变为:葫芦娃。
        int max = ageArray[0];
        for (int a = 0; a < ageArray.length; a++) {
            if (max < ageArray[a]) {
                max = ageArray[a];
            }
        }
        for (Student s : list) {
            if (s.getAge() == max) {
                s.setName("葫芦娃");
            }
        }
        System.out.println();
        for (Student s : list) {
            System.out.println(s);
        }
        System.out.println();
        List<Phone> list2 = new ArrayList<Phone>();
        // 创建四个手机("小米"、"华为"、"乐视"、"奇酷")对象存入ArrayList集合中
        Phone p1 = new Phone("小米", 1999, "白色");
        Phone p2 = new Phone("华为", 2999, "黑色");
        Phone p3 = new Phone("乐视", 3999, "绿色");
        Phone p4 = new Phone("奇酷", 4999, "蓝色");
        list2.add(p1);
        list2.add(p2);
        list2.add(p3);
        list2.add(p4);
        // 遍历输出。
        Iterator it2 = list2.iterator();
        while (it2.hasNext()) {
            System.out.println(it2.next());
        }
        System.out.println();
        List<Employee> list3 = new ArrayList<Employee>();
        Employee e1 = new Employee("刘德华", "9527", 58600);
        Employee e2 = new Employee("李弘基", "9528", 15680);
        Employee e3 = new Employee("陈奕迅", "9558", 59700);
        list3.add(e1);
        list3.add(e2);
        list3.add(e3);

        Iterator<Employee> it3 = list3.iterator();
        while (it3.hasNext()) {
            System.out.println(it3.next());
        }
    }
}

class Student {
    String name;
    int age;
    String sex;

    public Student() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Student(String name, int age, String sex) {
        super();
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

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

    @Override
    public String toString() {
        return "姓名:" + name + "  年龄:" + age + "  性别:" + sex;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + age;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        result = prime * result + ((sex == null) ? 0 : sex.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Student other = (Student) obj;
        if (age != other.age)
            return false;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        if (sex == null) {
            if (other.sex != null)
                return false;
        } else if (!sex.equals(other.sex))
            return false;
        return true;
    }
}

/**
 * 定义一个手机类Phone,包含三个属性品牌(brand)、价格(price)、颜色(color)。
 */
class Phone {
    private String brand;
    private double price;
    private String color;

    public Phone() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Phone(String brand, double price, String color) {
        super();
        this.brand = brand;
        this.price = price;
        this.color = color;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "型号:" + brand + "  价格:" + price + "  颜色:" + color;
    }
}

/**
 * 定义一个员工类Employee,包含三个属性姓名、工号、工资,创建三个员工对象存
 * 入ArrayList集合中,并遍历输出。
 */
class Employee {
    private String name;
    private String number;
    private double salary;

    public Employee() {
        super();
        // TODO Auto-generated constructor stub
    }

    public Employee(String name, String number, double salary) {
        super();
        this.name = name;
        this.number = number;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "姓名:" + name + "  工号:" + number + "  工资:" + salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
}

库存案例:

import java.util.ArrayList;
import java.util.Scanner;
public class Test{
    public static void main(String args[]){
        newMain();
    }
    //主要方法
    public static void newMain(){
        ArrayList<Commer> array = new ArrayList<Commer>();
        addCommer(array);
        while(true){
            switch(helloCommer()){
            case 1:
                printCommer(array);
                break;
            case 2:
                updata(array);
                break;
            case 3:
                System.out.println("感谢您的使用 再见!");
                return ;
            default:
                System.out.println("您的输入有误请重新输入!");
            }
        }
    }
    //界面
    public static int helloCommer(){
        System.out.println("-------------库存管理------------");
        System.out.println("1.查看库存清单");
        System.out.println("2.修改商品库存数量");
        System.out.println("3.退出");
        return new Scanner(System.in).nextInt();
    }
    //添加商品元素
    public static void addCommer(ArrayList<Commer> array){
        Commer c1 = new Commer();
        c1.name = "macBook";c1.size = 13.3; c1.price = 8999.99;
        Commer c2 = new Commer();
        c2.name = " lenovo";c2.size = 15.6; c2.price = 4399.99;
        array.add(c1);array.add(c2);
    }
    //打印库存清单
    public static void printCommer(ArrayList<Commer> array){
        int sum = 0, money = 0;
        System.out.println("-----------------商品清单-----------------");
        System.out.println("品名             尺寸/寸   价格/元           库存/台");
        for (int a = 0; a < array.size(); a++) {
            System.out.println(array.get(a).name + "    " + array.get(a).size + "   "
             + array.get(a).price
                    + "\t " + array.get(a).count + "  ");
            sum += array.get(a).count;
            money += array.get(a).count * array.get(a).price;
        }
        System.out.println("库存总量为:" + sum + "台");
        System.out.println("库存总价为:" + money + "元");
    }
    //修改库存
    public static void updata(ArrayList<Commer> array){
        for (int a = 0; a < array.size();a++){
            System.out.println("请修改商品"+array.get(a).name+"的库存");
            array.get(a).count = new Scanner(System.in).nextInt();
            System.out.println("修改成功!");
        }
    }
}
class Commer{
    String name;
    double price;
    double size;
    int count;
}

点名器案例:

//学生类
import java.util.ArrayList;
import java.util.Random;
public class CallNameDemo{
    public static void main (String args[]){
        ArrayList<Student> array = new ArrayList<Student>();
        addStudent(array);
        look(array);
        randomStudentName(array);
    }
    //存储
    public static void addStudent(ArrayList<Student> array){
        Student s1 = new Student();
        s1.name = "张三";s1.age = 12;
        Student s2 = new Student();
        s2.name = "李四";s2.age = 18;
        Student s3 = new Student();
        s3.name = "王五";s3.age = 16;
        Student s4 = new Student();
        s4.name = "赵六";s4.age = 14;
        array.add(s1);array.add(s2);
        array.add(s3);array.add(s4);
    }
    //查看
    public static void look(ArrayList<Student> array){
        for (int a = 0 ; a < array.size(); a++){
            System.out.println(array.get(a).name+" "+array.get(a).age+"岁");
        }
    }
    //抽取
    public static void randomStudentName(ArrayList<Student> array){
        int random = new Random().nextInt(array.size());
        System.out.println("幸运学生是 :   "+array.get(random).name+" "+array.get(random).age+"岁");
    }
}
class Student{
    int age ;
    String name;
}
上一篇:android 74 下载文本


下一篇:Java 基础 引用数据类型 ArrayList集合