今日内容介绍

1、自定义类型的定义及使用

2、自定义类的内存图

3、ArrayList集合的基本功能

4、随机点名器案例及库存案例代码优化

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. 			  修饰符 数据类型 变量名 = 值
  11. 			方法定义
  12. 			  修饰符 返回值类型  方法名(参数列表){
  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);  //输出内存的地址
  13. 		     	//3: 变量.类型中的功能
  14. 				//变量 p.的方式,调用类中的属性
  15. 				//属性就是变量 , 赋值和获取值
  16. 				p.color = "土豪金";
  17. 				p.brand = "爱立信";
  18. 				p.size = 5.0;
  20. 				//获取属性值
  21. 				System.out.println(p.color+"  "+p.brand+"  "+p.size);
  22. 			}
  23. 		}

06自定义类的内存图_1

  1. * A: 自定义类的内存图_1
  2. 	* a:

07自定义类的内存图_2

  1. * A: 自定义类的内存图_1
  2. 	* a:

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

  1. * A: 自定义类的内存图_1
  2. 	* a:

09自定义类的练习

  1. * A: 实体类的代码
  2. 	/*
  3. 	    电饭锅，包含属性（品牌、容量大小、颜色等）
  4. 		定义类,描述事物,电饭锅
  5. 		  属性: 品牌,大小 ,颜色
  7. 		定义类,类名字,电饭锅
  8. 		类的范围,定义三个属性
  9. 	*/
  10. 	public class DianFanGuo{
  11. 		//定义三个属性
  12. 		String brand ;
  13. 	    double size ;
  14. 		String color ;
  15. 	}
  17. 	/*
  18. 	   汽车，包含属性（品牌、排量、类型等）
  19. 	   定义类,类名 Car
  20. 	     属性 品牌 排量 类型
  21. 	 */
  22. 	public class Car{
  23. 		//定义汽车三个属性
  24. 		String brand ;
  25. 		double paiLiang ;
  26. 		String type;
  27. 	}
  29. 	 /*
  30. 	   学生，包含属性（姓名，年龄，性别等）
  31. 	   定义类,类名Student
  32. 	     三个属性: 姓名,年龄,性别 (char)
  33. 	*/
  34. 	public class Student{
  35. 		String name;
  36. 		int age ;
  37. 		char sex ;
  38. 	}
  40. * B: 测试类的代码
  41. 	/*
  42. 	   定义的测试类
  43. 	   同时测试,电饭锅,汽车,学生
  44. 	*/
  45. 	public class Test{
  46. 		public static void main(String[] args){
  47. 			//创建电饭锅引用类型
  48. 			DianFanGuo dfg = new DianFanGuo();
  50. 			dfg.brand = "特斯拉";
  51. 			dfg.color = "红色";
  52. 			dfg.size = 30;
  54. 			System.out.println(dfg.brand+"  "+dfg.color+"  "+dfg.size);
  56. 			//创建汽车引用类型
  57. 			Car c = new Car();
  58. 			c.brand = "巨力";
  59. 			c.type = "拖拉机";
  60. 			c.paiLiang = 0.5;
  62. 			System.out.println(c.brand+"  "+c.type+"  "+c.paiLiang);
  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);
  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>();
  9. 			//创建集合容器,存储整数
  10. 			ArrayList<Integer> array2 = new ArrayList<Integer>();
  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);
  20. 			//获取出集合中的一个元素,获取1索引的元素
  21. 			//集合的方法get, 获取元素后结果数据类型
  22. 			String s = array.get(1);
  23. 			System.out.println(s);
  25. 			System.out.println(array.get(0));
  26. 			System.out.println(array.get(1));
  27. 			System.out.println(array.get(2));
  28. 			System.out.println(array.get(3));
  29. 		}
  30. 	}

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);
  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){
  11. 			ArrayList<Integer> array = new ArrayList<Integer>();
  12. 			array.add(1);
  13. 			array.add(2);
  14. 			array.add(3);
  15. 			array.add(4);
  17. 			//在索引2上,添加元素7
  18. 			array.add(2,7);
  20. 			//将0索引上的元素,修改成10
  21. 			array.set(0,10);
  23. 			//将4索引上的元素,删除
  24. 			array.remove(4);
  26. 			array.clear();
  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. 	   属性: 姓名,年龄
  7. 	   姓名存储了数组, 将容器换成是集合
  8. 	   String[] s = {"",""};
  9. 	   集合中,存储的是学生的姓名吗?  应该存储Student类型
  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);
  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. 		}
  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. 		}
  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();
  66. 			sn1.name = "张三1";
  67. 			sn1.age = 201;
  69. 			sn2.name = "张三2";
  70. 			sn2.age = 202;
  72. 			sn3.name = "张三3";
  73. 			sn3.age = 203;
  75. 			sn4.name = "张三4";
  76. 			sn4.age = 204;
  78. 			sn5.name = "张三5";
  79. 			sn5.age = 205;
  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库存案例分析加入集合

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

18库存案例添加商品信息

  1. * A: 案例代码
  2. 	/*
  3. 	   定义,.描述商品的类
  4. 	   商品 4个属性
  5. 	     商品名字  大小     价格    库存
  6. 		  String    double   double  int
  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. 	}
  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. 		}
  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;
  51. 			g2.brand = "Thinkpad";
  52. 			g2.size = 15.6;
  53. 			g2.price = 7999.99;
  54. 			g2.count = 1;
  56. 			//Goods类型的变量,存储到集合中
  57. 			array.add(g1);
  58. 			array.add(g2);
  59. 		}
  60. 	}

19库存案例查看库存清单

  1. * A: 案例代码
  2. 	/*
  3. 	    实现库存管理案例:
  4. 		  1.存储商品信息
  5. 		    存储商品类型变量
  6. 			将商品类型的变量,存储到集合中
  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. 		}
  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. 		}
  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;
  59. 			g2.brand = "Thinkpad";
  60. 			g2.size = 15.6;
  61. 			g2.price = 7999.99;
  62. 			g2.count = 1;
  64. 			//Goods类型的变量,存储到集合中
  65. 			array.add(g1);
  66. 			array.add(g2);
  67. 		}
  68. 	}

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

  1. * A: 案例代码
  2. 	/*
  3. 	    实现库存管理案例:
  4. 		  1.存储商品信息
  5. 		    存储商品类型变量
  6. 			将商品类型的变量,存储到集合中
  8. 	      2.查看库存清单
  9. 		    将集合进行遍历, 获取出集合中存储的Goods类型变量
  10. 			输出每一个Goods类型的属性
  11. 			计算求和: 总库存,总金额
  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;
  36. 					case 2:
  37. 					//进入修改库存功能,调用修改库存的方法,传递集合
  38. 					update(array);
  39. 					break;
  41. 					case 3:
  42. 					return ;
  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. 		}
  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. 		}
  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;
  115. 			g2.brand = "Thinkpad";
  116. 			g2.size = 15.6;
  117. 			g2.price = 7999.99;
  118. 			g2.count = 1;
  120. 			//Goods类型的变量,存储到集合中
  121. 			array.add(g1);
  122. 			array.add(g2);
  123. 		}
  124. 	}

2017.9.2Java中的自定义类型的定义及使用&&自定义类的内存图的更多相关文章

  1. UE4 中Struct Emum 类型的定义方式 笔记

    UE4 基础,但是不经常用总是忘记,做个笔记加深记忆: 图方便就随便贴一个项目中的STRUCT和 Enum 的.h 文件 Note:虽然USTRUCT可以定义函数,但是不能加UFUNCTION 标签喔 ...

  2. OC中保存自定义类型对象的持久化方法

    OC中如果要将自定义类型的对象保存到文件中,必须进行以下三个条件: 想要把存放自定义类型的数组进行 持久化(就是将内存中的临时数据以文件<数据库等>的形式写到磁盘上)必须满足: 1. 自定 ...

  3. Oracle中如何自定义类型

    一:Oracle中的类型有很多种,主要可以分为以下几类:1.字符串类型.如:char.nchar.varchar2.nvarchar2.2.数值类型.如:int.number(p,s).integer ...

  4. 向集合中添加Person类型并对其排序

    package com.bjpowernode.t03sort; import java.util.ArrayList;import java.util.Collections; /* * 向集合中添 ...

  5. 《Go语言实战》Go 类型：基本类型、引用类型、结构类型、自定义类型

    Go 语言是一种静态类型的编程语言,所以在编译器进行编译的时候,就要知道每个值的类型,这样编译器就知道要为这个值分配多少内存,并且知道这段分配的内存表示什么. 提前知道值的类型的好处有很多,比如编译器 ...

  6. struts2基础---->自定义类型转换器

    这一章,我们开始struts2中自定义类型转换器的学习. 自定义类型转换器

  7. Q_DECLARE_METATYPE（继承QObject的类都已经自动注册），注册后的类型可以作为QVariant的自定义类型

    简介 这个宏用来注册一个类(含默认构造.默认析构.拷贝构造函数)为QMetaType类型 ,注册后的类型可以作为QVariant的自定义类型. 这个宏应该放在类或者结构体外面的下面,也可以放在一个非公 ...

  8. Android进阶AIDL使用自定义类型

    原文首发于微信公众号:jzman-blog,欢迎关注交流! 上篇文章中主要介绍从 AIDL 的使用方式以及 Android 开发中不同进程之间的通信,遗留的问题是如何在 AIDL 中使用自定义类型,具 ...

  9. springmvc——自定义类型转换器

    一.什么是springmvc类型转换器? 在我们的ssm框架中,前端传递过来的参数都是字符串,在controller层接收参数的时候springmvc能够帮我们将大部分字符串类型的参数自动转换为我们指 ...

随机推荐

  1. storm中几个概念的大小关系

    从图可以看出来:topology>supervisor>worker>excutor>task; 也就是说一个topology可以运行在多个supervisor上,一个supe ...

  2. CountDownLatch 多线程，等待所有线程结束

    CountDownLatch,一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待. 主要方法 public CountDownLatch(int count); 构造 ...

  3. thinkphp执行流程

    1. 入口文件index.php 用户对url的访问首先被定位到http://<serverIp>/<appName>/index.php, 这里的入口文件index.php做 ...

  4. JS字符串与二进制的相互转化

    //字符串转ascii码,用charCodeAt(); //ascii码转字符串,用fromCharCode(); var str = "A"; var code = str.ch ...

  5. 接收时间戳model [JsonConverter(typeof(UnixDateTimeConverter))]

    /// <summary>        /// 创建时间        /// </summary>        [JsonProperty("createtim ...

  6. [转]jQuery Validate使用说明

    本文转自:http://www.cnblogs.com/gimin/p/4757064.html jQuery Validate 导入 js 库 <script src="./jque ...

  7. 迟到的UED(转发)

    2013UCAN用户体验设计论坛–精彩视频赏析 - 交互设计 博文 视觉设计 | TaoBaoUEDhttp://ued.taobao.org/blog/2013/09/2013ucan/

  8. Android4.4源码学习笔记

    1.StatusBar和Recents是如何建立联系的 在BaseStatusBar的start()函数通过getComponent(RecentsComponent.class)得到了Recents ...

  9. javascript接入阿里云服务器

    authInfo = r.data.authInfo[0]//后台请求的 var client = new OSS({ region: 'oss-cn-beijing',// 云账号AccessKey ...

  10. textarea高度随着内容的多少而变化，高度可以删减

    问题:可以多行输入,并且输入框的高度随着内容的多少而变化,输入框的高度不能只增不减 由于 input 只能单行输入 textarea可以多行输入,并且高度可以随着内容的增加而增加,但是当内容删减的时候 ...