java小白训练营2109-day03-数据结构：基本类型+包装类型+数组+对象

程序

程序员写程序的
旧的程序员：程序开发语言，追求“扣”，节约CPU、内存（32m*3）、磁盘资源（4.3g火球），扣每个字节（=8bit位） 数据结构，数据要占用小的存储空间。int a = 10（内存）; syso(a) 运行的更快：算法
网络（33.6k 猫，拨号）逐行

关注点：数据结构+算法

新的程序员：CPU，多核，内存（16g）、硬盘（1t 高速）、网络（千兆）
软件设计时就没有那么扣了，习惯小的就行，功能实现就行，速度能接受就行
框架（SSM SpringMVC+Spring+Mybatis）+架构（SpringCloud微服务+互联网架构nginx+redis+mycat+大数据架构）

关注点：数据结构+算法+框架…………+架构…………
java语言是最基础开发，框架（半成品），架构（已经很多内容进行优化）
盖房子：砖头、预制板、钢筋水泥柱子

数据结构

int a = 10;
String name = "陈晨";
程序在处理数据时，应该尽量占用小的存储空间，理论上越小越好，越小越快
把生活中的数据要抽象成计算机所能识别数据。
各个语言java，整型、小数、字符、布尔值（基本类型）、字符串、数组（一组，多个值）、对象、树、图
利用这些数据结构最终就能找到一个合适的数据存储方式

java中数据类型分类

1）基本类型：8种 int a = 10; （速度快）
2）引用类型：非基本类型都是引用类型，字符串String s= “陈晨”; 数组Arrays; 对象Object （速度慢）
java 是一个面向对象，把生活中的所有的内容都可以抽象成对象

八种基本类型

计算机最小单位bit比特，编程语言最小单位 byte 字节 1字节=8比特
1）byte 字节，1字节 2^8，256，-128~127
2）short 短整型，2字节 2^16，65536，-32768~32767
3）int 整型，4字节 2^32，42亿，正负21亿（默认）
4）long 长整型，8字节 2^64

5）float 单精度浮点数，4字节 2^32
6）double 双精度浮点数，8字节 2^64（默认）

7）char 字符型，2字节，1~4字节 UTF-8 ，全球代码unicode 4个字节 ASCII/ISO-8859-1/UTF-16/UTF-8
8）boolean 布尔型，就2个值true 1和false 0，bit/byte,1字节

案例：数字100和200使用什么类型来存储

要求：使用尽量小的存储类型 byte、short、int、long？

package cn.tedu.data;


//基本类型测试
public class TestPrimity {
	public static void main(String[] args) {
		//需求：100和200使用什么类型存储？
		//Type mismatch: cannot convert from int to byte
		//类型不匹配，不能转换整型到字节型
		//默认写一个数字，java把它当成整型
		//100也是整型，它在byte的存储的范围内，java自动转换类型
		byte b = 100; 
		//byte b = 200; 就不能存储到byte中，超出范围
		
		//在一个方法体不能声明同样名称
		short b1 = 200;
		
		System.out.println(b);
		
		
		//需求：存储1九个0（10亿），1十个0（100亿）使用什么类型存储
		int i1 = 1000000000; 	//在整数范围内容，可以存储
		long i2 = 10000000000L;	//不在整数范围内，必须用long，必须标识它是long，在数字后符号l/L
		
		//结论：写一个数字尽量使用小的存储范围，习惯int；
	}
}

字符

char c = ‘a’; //使用单撇括起来，只能一个字符，还可以是个整数
char c = 97;

package cn.tedu.data;

//字符
public class TestChar {
	public static void main(String[] args) {
		char c1 = '0';
		System.out.println(c1);
		
		char c2 = 48;
		System.out.println(c2);
		
		/*
		 * 结论：
		 * 发现一个规则，字符其实可以由一个定死整数来表达
		 * a 97
		 * b 98
		 * 0 48
		 * 规则：ASCII码表
		 * 把字母或者数字使用十进制表达，
		 * 进而可以把十进制转成二进制
		 * 人类识别语言，可以转换计算机识别二进制
		 * 
		 * 键盘敲入a，在屏幕显示a
		 * 计算机接收到键盘输入a，把这个a转换97
		 * 然后把97转换二进制0110 0001（8bit）
		 * 计算机在内存中就可以存放 0110 0001
		 * 从内存中取出二进制，然后转换97，然后查询ASCII表
		 * 查询到97对应字母a，最后在屏幕上显示a
		 */
	}
}

常见的字符集

1）ASCII 标准信息交换码 128字符
2）ISO-8859-1 扩展了ASCII，加西欧和、符号，扩展256字符
3）GB2312 只支持中文简体，BIG5繁体，GBK
4）unicode 编码规则，字符集：UTF-32，每个字节都占4个字节，UTF-16，UTF-8 压缩 英文1个字节，中文3个字节，生僻字，繁体4个字节
现今文件编码，数据库编码，页面html网页编码都会，习惯都是要utf-8

包装类型

针对每个基本类型它就有一个包装类型，包装类型有8个
byte Byte，short Short，int Integer, long Long, float Float，double Double，char Character， boolean Boolean

怎么得到这些类型对应取值范围（整数、小数）

byte b1 = 100; //基本类型没有.操作符的
Byte b2 = 100; //包装类型，支持.操作符，支持额外方法，这些方法jdk

package cn.tedu.data;

//打印出所有基本类型的取值范围，4个整数，2个小数
public class TestScope {
	public static void main(String[] args) {
		System.out.println("byte范围："
				+ Byte.MIN_VALUE+"~"+Byte.MAX_VALUE);
		System.out.println("short范围："
				+ Short.MIN_VALUE+"~"+Short.MAX_VALUE);
		System.out.println("int范围："
				+ Integer.MIN_VALUE+"~"+Integer.MAX_VALUE);
		System.out.println("long范围："
				+Long.MIN_VALUE+"~"+Long.MAX_VALUE);
		
		System.out.println("float范围："
				+Float.MIN_VALUE+"~"+Float.MAX_VALUE);
		System.out.println("double范围："
				+Double.MIN_VALUE+"~"+Double.MAX_VALUE);
		
		//打印ASCII编码0（NUL）和127（del键）不可见字符
		System.out.println("char范围："
				+Character.MIN_VALUE+"~"+Character.MIN_VALUE);
		
		//布尔没有最大值和最小值，只有TRUE和FALSE
		System.out.println(Boolean.TRUE);
	}
}

执行结果：

byte范围：-128~127
short范围：-32768~32767
int范围：-2147483648~2147483647
long范围：-9223372036854775808~9223372036854775807
float范围：1.4E-45~3.4028235E38
double范围：4.9E-324~1.7976931348623157E308
char范围：

在java中万物皆对象，包装类型都是对象Object

	包装类型和对象Object有相关性？
	在java中所有的类都有一个父亲 Object类，在java中所有类都是直接或者间接的继承Object类
	它就享受到java对象的很多好处（额外方法）
	Byte ~ Object 

package cn.tedu.data;

//所有创建类可以明确声明继承哪个类，也可以不声明，不声明就继承Object
public class TestWrapper {
	public static void main(String[] args) {
		//获得Byte类（this）的父类（super）
		//Long b = 100L;
		//Double b = 100.0D;
		//Character b = 'a';
		Boolean b = true;
		System.out.println("当前类："+b.getClass());
		System.out.println("父类："+ b.getClass().getSuperclass());
		System.out.println("爷类："+ b.getClass().getSuperclass().getSuperclass());
		System.out.println("祖宗："+ b.getClass().getSuperclass().getSuperclass().getSuperclass());
		
		// java.lang.NullPointerException 空指针错误
	}
}

基本类型也好，包装类型也好

它们的缺点是只能存储一个类型的一个值。

		//Type mismatch: cannot convert from int to Boolean
		int i = 1000;
		//Type mismatch: cannot convert from String to int
		i = "tony"; //编译时会进行语法检查，强制看类型是否匹配
		

要存储多个值，数组

例子：科目，语文、数学、英语
String course1 = “语文”;
String course2 = “数学”;
String course3 = “英语”;

数组存取多个值
1）定义
2）初始化（设置）
a. 动态的初始化
b. 静态的初始化
3）获取数组，某个元素，下标

package cn.tedu.data;

//数组
public class TestArray {
	public static void main(String[] args) {
		//1. 定义
		//创建一个字符串数组对象，长度3，可以存3个元素
		//coures叫做instance 实例
		String[] coures = new String[4];
		//String coures[] = new String[3];
		
		//2.1 动态的初始化，给里面的元素来设置值，通过数组下标
		coures[0] = "语文";	//把下标为0的内容替换
		coures[1] = "数学";
		coures[2] = "英语";
		//coures[3] 这个值超过数组的范围，如果调用就报错
		//运行时  java.lang.ArrayIndexOutOfBoundsException
		// index索引，下标越界
		//System.out.println( coures[4] ); 
 		
		//2.2 静态的初始化
		
		//3. 获取数组元素，打印
		//每个人的电脑的内存使用不同，造成地址值是不同（正常）
		//[Ljava.lang.String;@182decdb 内存地址
		System.out.println( coures );
		//获取元素时，通过数组的下标进行访问
		System.out.println("数组的第一个元素："+ coures[0]);
		System.out.println("数组的第二个元素："+ coures[1]);
		System.out.println("数组的最后一个元素："+ coures[2]);
		
		System.out.println("数组的长度：" + coures.length);
		
		//下面的两种写法执行时间一致，这点时间差是可以忽略，推荐length-1，读代码清晰
		//写代码时有个习惯：尽量写活
		System.out.println("数组的最后一个元素："+ coures[3]);
		System.out.println("数组的最后一个元素："+ coures[coures.length-1]);
	}
}

package cn.tedu.data;

import java.util.*;  //eclipse提示，导包

/*
 * 得分：100,120,80,60,10
 * 1）求总分 total，遍历数组获取所有值，然后全部加起来
 * 2）求平均分 avg，总分/分个数 total/5
 * 3）求最高分 max，排序，正序后，最后元素
 * 4）求最低分 min，排序，正序后，第一个元素
 */

public class TestScores {
	public static void main(String[] args) {
		//定义，静态初始化数组
		int[] scores = {100,120,80,60,10};
		int total = scores[0]+scores[1]+scores[2]+scores[3]+scores[4];
		int avg = total/scores.length;
		
		//排序
		Arrays.sort(scores);
		int max = scores[scores.length-1]; 
		int min = scores[0];
		
		System.out.println( Arrays.toString(scores));
		System.out.println("总计值：" + total);
		System.out.println("平均值：" + avg);
		System.out.println("最大值：" + max);
		System.out.println("最小值：" + min);
	}
}

对象

基本类型、包装类型只能表达一个类型一个值
数组虽然能表达多个值，但是每个元素的类型必须一致，只能是一个类型

需求：人特性
1）姓名 String
2）性别 Boolean
3）年龄 Integer
4）地址 String

java提供万能抽象的方式，把生活中万物都可以抽象出来，就是Object对象
对象的结构非常复杂，它就运行单个值支持，数组支持，不同的类型支持

完成抽象的过程
1、定义
1）创建 Person类
2）类中有很多特征（属性，字段，成员变量-类名下，属于类）
原则：成员变量推荐使用包装类型
a. 姓名 String name;
b. 性别 Boolean sex;
c. 年龄 Integer age;
d. 地址 String address;
2、使用
类要使用创建对象实例：类名 实例名 = new 类名();
Person person = new Person();
初始化，通过点操作符，对象的操作方式
person.name = “陈晨”;
person.sex = true; //true男，false女
person.age = 18;
person.address = “北京”;
3、访问、打印
syso( person.name );

package cn.tedu.entity;

//实体类：人Person
public class Person {
	//特征，属性，成员变量（在类下面写的）
	//局部变量（在方法中声明的变量）
	//成员变量习惯使用包装类型来定义
	public String name;	//姓名
	public Boolean sex;	//性别
	public Integer age;	//年龄
	public String address; //地址
}

package cn.tedu.data;

//不在同一个包路径下，需要导包 import
import cn.tedu.entity.Person;

//测试类
public class TestPerson {
	public static void main(String[] args) {
		//1. 创建对象实例
		//类 实例 = new 类();
		Person p = new Person();
		
		//2. 属性初始化
		p.name = "陈晨";
		p.sex = true;
		p.age = 18;
		p.address = "北京";
		
		//3. 打印某个属性
		System.out.println(p);
		System.out.println( p.name );
		System.out.println( p.sex );
		System.out.println( p.age );
		System.out.println( p.address );
		
		//Duplicate local variable p 局部变量重名了
		Person p1 = new Person();
		p1.name = "王强";
		p1.sex = false;
		p1.age = 16;
		p1.address = "上海";
		
		System.out.println(p1);
		System.out.println(p1.name);
		System.out.println(p1.sex);
		System.out.println(p1.age);
		System.out.println(p1.address);
	}
}