01引用数据类型_类
1* A: 数据类型
2 * a: java中的数据类型分为：基本类型和引用类型
3* B: 引用类型的分类
4 * a: Java为我们提供好的类，比如说：Scanner,Random等。
5 * b: 我们自己创建的类，按照类的定义标准，可以在类中包含多个方法与属性，来供我们使用。
02自定义类的概述
1* A: 自定义类的概述
2 * java代码映射成现实事物的过程就是定义类的过程。
3 * 举例：
4 我们就拿一部手机进行分析，它能用来做什么呢？它可以打电话，上网，聊微信等，这些就是手机所提供的功能，也就是方法； 手机也有它的特征，如颜色、尺寸大小、品牌型号等，这些就是手机的特征，也就是属性
5 * 目前，我们只关注类中的属性，类中的方法在面向对象部分再进行学习。
03自定义类的格式
1* A: 自定义类的格式
2 * a: 使用类的形式,对现实中的事物进行描述。
3 * b: 事物由方法和属性两部分组成。
4 * 方法: 这个事物具备的功能。
5 * 属性: 这个事物具备的特征。
6 * c: 格式
7 public class 类名{
8 属性定义
9 修饰符 数据类型 变量名 = 值
10
11 方法定义
12 修饰符 返回值类型 方法名(参数列表){
13
14 }
15 }
04自定义的手机类
1* A: 自定义的手机类
2 * a: 案例代码
3 public class Phone{
4 /*
5 定义手机的属性
6 */
7 String color ;
8 String brand ;
9 double size ;
10 }
05测试手机类
1* A: 调用方法执行流程
2 * a: 实现引用类型的步骤
3 * 1: 导入包 , 类都是在同一个文件夹,不需要导入包
4 * 2: 创建引用类型的变量
5 * 3: 变量.类型中的功能
6 * b: 案例代码
7 public class TestPhone{
8 public static void main(String[] args){
9 // 2: 创建引用类型的变量
10 Phone p = new Phone();
11 //System.out.println(p); //输出内存的地址
12
13 //3: 变量.类型中的功能
14 //变量 p.的方式,调用类中的属性
15 //属性就是变量 , 赋值和获取值
16 p.color = "土豪金";
17 p.brand = "爱立信";
18 p.size = 5.0;
19
20 //获取属性值
21 System.out.println(p.color+" "+p.brand+" "+p.size);
22 }
23 }
06自定义类的内存图_1
07自定义类的内存图_2
08两个引用类型变量内存图
09自定义类的练习
1* A: 实体类的代码
2 /*
3 电饭锅，包含属性（品牌、容量大小、颜色等）
4 定义类,描述事物,电饭锅
5 属性: 品牌,大小 ,颜色
6
7 定义类,类名字,电饭锅
8 类的范围,定义三个属性
9 */
10 public class DianFanGuo{
11 //定义三个属性
12 String brand ;
13 double size ;
14 String color ;
15 }
16
17 /*
18 汽车，包含属性（品牌、排量、类型等）
19 定义类,类名 Car
20 属性 品牌 排量 类型
21 */
22 public class Car{
23 //定义汽车三个属性
24 String brand ;
25 double paiLiang ;
26 String type;
27 }
28
29 /*
30 学生，包含属性（姓名，年龄，性别等）
31 定义类,类名Student
32 三个属性: 姓名,年龄,性别 (char)
33 */
34 public class Student{
35 String name;
36 int age ;
37 char sex ;
38 }
39
40* B: 测试类的代码
41 /*
42 定义的测试类
43 同时测试,电饭锅,汽车,学生
44 */
45 public class Test{
46 public static void main(String[] args){
47 //创建电饭锅引用类型
48 DianFanGuo dfg = new DianFanGuo();
49
50 dfg.brand = "特斯拉";
51 dfg.color = "红色";
52 dfg.size = 30;
53
54 System.out.println(dfg.brand+" "+dfg.color+" "+dfg.size);
55
56 //创建汽车引用类型
57 Car c = new Car();
58 c.brand = "巨力";
59 c.type = "拖拉机";
60 c.paiLiang = 0.5;
61
62 System.out.println(c.brand+" "+c.type+" "+c.paiLiang);
63
64 //创建学生引用类型
65 Student stu = new Student();
66 stu.name = "张三";
67 stu.age = 20;
68 stu.sex = '男';
69 System.out.println(stu.name+" "+stu.age+" "+stu.sex);
70
71 }
72 }
10ArrayList创建变量的步骤
1* A: ArrayList创建变量的步骤
2 * a: 导入包 java.util包中
3 * b: 创建引用类型的变量
4 数据类型< 集合存储的数据类型> 变量名 = new 数据类型<集合存储的数据类型>();
5 集合存储的数据类型: 要将数据存储到集合的容器中
6 创建集合引用变量的时候,必须要指定好,存储的类型是什么
7 * c: 变量名.方法
8 注意: 集合存储的数据,8个基本类型对应8个引用类型
9 存储引用类型,不存储基本类型
11ArrayList创建变量举例
1* A: ArrayList创建变量的示例代码
2 import java.util.ArrayList;
3 public class ArrayListDemo{
4 public static void main(String[] args){
5 //创建集合容器,指定存储的数据类型
6 //存储字符串
7 ArrayList<String> array = new ArrayList<String>();
8
9 //创建集合容器,存储整数
10 ArrayList<Integer> array2 = new ArrayList<Integer>();
11
12 //创建集合容器,存储手机类型
13 ArrayList<Phone> array3 = new ArrayList<Phone>();
14 }
15 }
12ArrayList的常见方法
1* A: ArrayList的常见方法
2 * a: add(参数) 向集合中添加元素
3 * b: get(int index) 取出集合中的元素,get方法的参数,写入索引
4 * c: size() 返回集合的长度, 集合存储元素的个数
5* B: 案例代码
6 import java.util.ArrayList;
7 public class ArrayListDemo_1{
8 public static void main(String[] args){
9 //定义集合,存储字符串元素
10 ArrayList<String> array = new ArrayList<String>();
11 //调用集合方法add存储元素
12 array.add("abc");
13 array.add("itcast");
14 array.add("love");
15 array.add("java");
16 //输出集合的长度,调用集合方法size, size方法的返回值类型 int
17 int size = array.size();
18 System.out.println(size);
19
20 //获取出集合中的一个元素,获取1索引的元素
21 //集合的方法get, 获取元素后结果数据类型
22 String s = array.get(1);
23 System.out.println(s);
24
25
26
27 System.out.println(array.get(0));
28 System.out.println(array.get(1));
29 System.out.println(array.get(2));
30 System.out.println(array.get(3));
31 }
32 }
13ArrayList集合的遍历
1* A: 案例代码
2 /*
3 集合的遍历
4 实现思想也是索引思想
5 集合的索引从0开始,到 size()-1
6 方法get(int index)
7 */
8 import java.util.ArrayList;
9 public class ArrayListDemo_2{
10 public static void main(String[] args){
11 ArrayList<Integer> array = new ArrayList<Integer>();
12 array.add(121);
13 array.add(125);
14 array.add(123);
15 array.add(120);
16 array.add(128);
17
18 //对集合进行遍历
19 //使用方法 size+get组合进行遍历
20 for(int i = 0 ; i < array.size(); i++){
21 System.out.println( array.get(i) );
22 }
23 }
24 }
14ArrayList补充方法
1* A: ArrayList补充方法
2 * a: add(int 索引,存储的元素) 将元素添加到指定的索引上
3 * b: set(int 索引,修改后的元素) 将指定索引的元素,进行修改
4 * c: remove(int 索引) 删除指定索引上的元素
5 * d: clear() 清空集合中的所有元素
6* B: 案例代码
7 import java.util.ArrayList;
8 public class ArrayListDemo_3{
9 public static void main(String[] args){
10
11 ArrayList<Integer> array = new ArrayList<Integer>();
12 array.add(1);
13 array.add(2);
14 array.add(3);
15 array.add(4);
16
17 //在索引2上,添加元素7
18 array.add(2,7);
19
20 //将0索引上的元素,修改成10
21 array.set(0,10);
22
23 //将4索引上的元素,删除
24 array.remove(4);
25
26 array.clear();
27
28 //使用方法 size+get组合进行遍历
29 for(int i = 0 ; i < array.size(); i++){
30 System.out.println( array.get(i) );
31 }
32 }
33 }
15随机点名器案例分析
1* A: 随机点名器案例分析
2 全班同学中随机的找出一名同学，打印这名同学的个人信息。
3 我们对本案例进行分析，得出如下分析结果：
4 1.存储全班同学信息（姓名、年龄）
5 将容器换成集合，集合中存的是Student类型
6 2.打印全班同学每一个人的信息（姓名、年龄）
7 遍历集合
8 3.在班级总人数范围内，随机产生一个随机数，查找该随机数所对应的同学信息（姓名、年龄）
9 随机点名器明确地分为了三个功能。如果将多个独立功能的代码写到一起，则代码相对冗长，我们可以针对不同的功能可以将其封装到一个方法中，将完整独立的功能分离出来。
10 而在存储同学姓名时，如果对每一个同学都定义一个变量进行姓名存储，则会出现过多孤立的变量，很难一次性将全部数据持有。此时，我们采用ArrayList集合来解决多个学生信息的存储问题
16随机点名器代码实现
1* A: 随机点名器案例代码
2 /*
3 随机点名器,集合改进 (学生的姓名和年龄)
4 现实中有学生这个事物,使用定义类的形式,描述学生事物
5 属性: 姓名,年龄
6
7 姓名存储了数组, 将容器换成是集合
8 String[] s = {"",""};
9 集合中,存储的是学生的姓名吗? 应该存储Student类型
10
11 存储学生:
12 学生类型,存储到集合中
13 总览: 遍历集合
14 随机: 随机数,作为索引,到集合中找到元素
15 三个功能,共享的数据,集合容器,
16 定义三个方法,必须参数传递集合
17 */
18 import java.util.ArrayList;
19 import java.util.Random;
20 public class CallName{
21 public static void main(String[] args){
22 //定义集合,存储的是StudentName类型变量
23 ArrayList <StudentName> array = new ArrayList<StudentName>();
24 //调用添加方法
25 add (array);
26 //调用遍历集合
27 printArrayList(array);
28
29 randomStudentName(array);
30 }
31 /*
32 随机数,当作集合的索引,到集合中找到元素
33 */
34 public static void randomStudentName(ArrayList<StudentName> array ){
35 Random r = new Random();
36 int number = r.nextInt( array.size());
37 //随机数,索引,到集合中get
38 StudentName s = array.get(number);
39 System.out.println( s.name +" "+s.age);
40 }
41
42 /*
43 总览学生的信息,遍历集合
44 */
45 public static void printArrayList(ArrayList<StudentName> array){
46 for(int i = 0 ; i < array.size();i++){
47 //存储集合的时候, 集合.add(sn1) sn1 是StudentName类型变量
48 //获取的时候,集合.get方法,获取出来的是什么, 还是StudentName类型变量
49 StudentName s = array.get(i);
50 System.out.println(s.name+" "+s.age);
51 }
52 }
53
54 /*
55 定义方法,实现存储学生的姓名和年龄
56 创建StudentName类型变量,存储到集合中
57 */
58 public static void add (ArrayList<StudentName> array){
59 //创建StudentName类型变量
60 StudentName sn1 = new StudentName();
61 StudentName sn2 = new StudentName();
62 StudentName sn3 = new StudentName();
63 StudentName sn4 = new StudentName();
64 StudentName sn5 = new StudentName();
65
66 sn1.name = "张三1";
67 sn1.age = 201;
68
69 sn2.name = "张三2";
70 sn2.age = 202;
71
72 sn3.name = "张三3";
73 sn3.age = 203;
74
75 sn4.name = "张三4";
76 sn4.age = 204;
77
78 sn5.name = "张三5";
79 sn5.age = 205;
80
81 //将StudentName变量,存储到集合中
82 array.add(sn1);
83 array.add(sn2);
84 array.add(sn3);
85 array.add(sn4);
86 array.add(sn5);
87 }
88 }
17库存案例分析加入集合
18库存案例添加商品信息
1* A: 案例代码
2 /*
3 定义,.描述商品的类
4 商品 4个属性
5 商品名字 大小 价格 库存
6 String double double int
7
8 定义类,类名Goods
9 这个类型的变量,存储到集合中
10 */
11 public class Goods{
12 //定义商品名字
13 String brand ;
14 //大小属性
15 double size ;
16 // 价格属性
17 double price ;
18 //库存属性
19 int count ;
20 }
21
22 /*
23 实现库存管理案例:
24 1.存储商品信息
25 存储商品类型变量
26 将商品类型的变量,存储到集合中
27 */
28 //import java.util.ArrayList;
29 import java.util.*;
30 public class Shopp{
31 public static void main(String[] args){
32 //创建ArrayList集合,存储Goods类型
33 ArrayList<Goods> array = new ArrayList<Goods>();
34 //调用添加商品信息的方法
35 addGoods(array);
36 }
37
38 /*
39 定义方法,将商品的信息存储到集合中
40 集合是所有方法的共享数据,参数传递
41 */
42 public static void addGoods (ArrayList<Goods> array){
43 //创建商品类型变量 Goods类型的变量
44 Goods g1 = new Goods();
45 Goods g2 = new Goods();
46 g1.brand = "MacBook";
47 g1.size = 13.3;
48 g1.price = 9999.99;
49 g1.count = 3;
50
51 g2.brand = "Thinkpad";
52 g2.size = 15.6;
53 g2.price = 7999.99;
54 g2.count = 1;
55
56 //Goods类型的变量,存储到集合中
57 array.add(g1);
58 array.add(g2);
59 }
60 }
19库存案例查看库存清单
1* A: 案例代码
2 /*
3 实现库存管理案例:
4 1.存储商品信息
5 存储商品类型变量
6 将商品类型的变量,存储到集合中
7
8 2.查看库存清单
9 将集合进行遍历, 获取出集合中存储的Goods类型变量
10 输出每一个Goods类型的属性
11 计算求和: 总库存,总金额
12 */
13 //import java.util.ArrayList;
14 import java.util.*;
15 public class Shopp{
16 public static void main(String[] args){
17 //创建ArrayList集合,存储Goods类型
18 ArrayList<Goods> array = new ArrayList<Goods>();
19 //调用添加商品信息的方法
20 addGoods(array);
21 }
22
23 /*
24 定义方法,查看库存清单,遍历集合
25 */
26 public static void printStore(ArrayList<Goods> array){
27 //输出表头
28 System.out.println("----------商场库存清单----------");
29 System.out.println("品牌型号 尺寸 价格 库存数");
30 //定义变量,保存总库存数,和总金额
31 int totalCount = 0 ;
32 double totalMoney = 0;
33 //遍历集合
34 for(int i = 0 ; i < array.size(); i++){
35 //get(索引)获取出集合中的元素,存储的是Goods类,获取的也是Goods类型
36 //使用Goods类型变量,接受get方法结果
37 Goods g = array.get(i);
38 System.out.println(g.brand+" "+g.size+" "+g.price+" "+g.count);
39 totalCount = totalCount+g.count;
40 totalMoney = totalMoney + g.count*g.price;
41 }
42 System.out.println("总库存数: "+totalCount);
43 System.out.println("商品库存总金额: "+totalMoney);
44 }
45
46 /*
47 定义方法,将商品的信息存储到集合中
48 集合是所有方法的共享数据,参数传递
49 */
50 public static void addGoods (ArrayList<Goods> array){
51 //创建商品类型变量 Goods类型的变量
52 Goods g1 = new Goods();
53 Goods g2 = new Goods();
54 g1.brand = "MacBook";
55 g1.size = 13.3;
56 g1.price = 9999.99;
57 g1.count = 3;
58
59 g2.brand = "Thinkpad";
60 g2.size = 15.6;
61 g2.price = 7999.99;
62 g2.count = 1;
63
64 //Goods类型的变量,存储到集合中
65 array.add(g1);
66 array.add(g2);
67 }
68 }
20库存案例修改库存清单及测试代码的实现
1* A: 案例代码
2 /*
3 实现库存管理案例:
4 1.存储商品信息
5 存储商品类型变量
6 将商品类型的变量,存储到集合中
7
8 2.查看库存清单
9 将集合进行遍历, 获取出集合中存储的Goods类型变量
10 输出每一个Goods类型的属性
11 计算求和: 总库存,总金额
12
13 3.修改商品的库存
14 集合遍历 ,获取出集合中存储的Goods类型变量
15 变量调用Goods类的属性count,值进行修改 (键盘输入)
16 */
17 //import java.util.ArrayList;
18 import java.util.*;
19 public class Shopp{
20 public static void main(String[] args){
21 //创建ArrayList集合,存储Goods类型
22 ArrayList<Goods> array = new ArrayList<Goods>();
23 //调用添加商品信息的方法
24 addGoods(array);
25 //进入死循环中
26 while(true){
27 //调用选择功能的方法,获取到用户输入的功能序号
28 int number = chooseFunction();
29 //对序号判断,如果=1 进入查看库存功能 = 2 进入修改库存功能 =3 结束
30 switch(number){
31 case 1:
32 //进入查看库存,调用查看库存的方法,传递存储商品信息的集合
33 printStore(array);
34 break;
35
36 case 2:
37 //进入修改库存功能,调用修改库存的方法,传递集合
38 update(array);
39 break;
40
41 case 3:
42 return ;
43
44 default:
45 System.out.println("无此功能");
46 break;
47 }
48 }
49 }
50 /*
51 方法定义,修改库存
52 键盘的输入,将Goods中的属性值,修改
53 */
54 public static void update(ArrayList<Goods> array){
55 Scanner sc = new Scanner(System.in);
56 //遍历集合,获取集合中的每个元素
57 for(int i = 0 ; i < array.size(); i++){
58 //集合方法get获取的是集合的元素,元素类型Goods
59 Goods g = array.get(i);
60 System.out.println("请输入"+g.brand+"的库存数");
61 //Goods属性,count进行修改
62 g.count = sc.nextInt();
63 }
64 }
65 /*
66 定义方法,实现选择菜单,用户根据功能选择菜单
67 */
68 public static int chooseFunction(){
69 System.out.println("-------------库存管理------------");
70 System.out.println("1.查看库存清单");
71 System.out.println("2.修改商品库存数量");
72 System.out.println("3.退出");
73 System.out.println("请输入要执行的操作序号：");
74 Scanner sc = new Scanner(System.in);
75 int number = sc.nextInt();
76 return number;
77 }
78
79 /*
80 定义方法,查看库存清单,遍历集合
81 */
82 public static void printStore(ArrayList<Goods> array){
83 //输出表头
84 System.out.println("----------商场库存清单----------");
85 System.out.println("品牌型号 尺寸 价格 库存数");
86 //定义变量,保存总库存数,和总金额
87 int totalCount = 0 ;
88 double totalMoney = 0;
89 //遍历集合
90 for(int i = 0 ; i < array.size(); i++){
91 //get(索引)获取出集合中的元素,存储的是Goods类,获取的也是Goods类型
92 //使用Goods类型变量,接受get方法结果
93 Goods g = array.get(i);
94 System.out.println(g.brand+" "+g.size+" "+g.price+" "+g.count);
95 totalCount = totalCount+g.count;
96 totalMoney = totalMoney + g.count*g.price;
97 }
98 System.out.println("总库存数: "+totalCount);
99 System.out.println("商品库存总金额: "+totalMoney);
100 }
101
102 /*
103 定义方法,将商品的信息存储到集合中
104 集合是所有方法的共享数据,参数传递
105 */
106 public static void addGoods (ArrayList<Goods> array){
107 //创建商品类型变量 Goods类型的变量
108 Goods g1 = new Goods();
109 Goods g2 = new Goods();
110 g1.brand = "MacBook";
111 g1.size = 13.3;
112 g1.price = 9999.99;
113 g1.count = 3;
114
115 g2.brand = "Thinkpad";
116 g2.size = 15.6;
117 g2.price = 7999.99;
118 g2.count = 1;
119
120 //Goods类型的变量,存储到集合中
121 array.add(g1);
122 array.add(g2);
123 }
124 }
