Java基础（一）——基本的数据类型

Java

JavaSE 标准版
JavaEE 企业版
JavaMe 微型版
Java特点：

	简洁高效
	面向对象
	跨平台
	安全性
	并发机制

JRE：Java运行环境
JDK：Java开发工具（包含JRE）
API：应用程序接口
http://www.oracle.com/technetwork/java/javase/downloads/index.html（API下载）

JRE：JVM + Java核心类库

JDK：JRE + Java开发工具包

基础

关键字：

	被Java赋予特殊含义的单词

标识符：

	字母，数字，下划线，$美元符号组成
	不能数字开头
	不能是关键字

命名规则：

		类名首字母大写，驼峰命名规范
		方法名首字母小写，其他单词首字母大写
		类名与当前文件名一致
		一个java文件只能有一个public类,且public的类名必须与文件名相一致

注释：

	单行注释  //
	多行注释  /*
				注释内容
					*/
	文档注释 /**
					内容
					*/			
		文档注释配合 javadoc 工具软件来获取注释内容

/**多行注释
 * @author Hu
 */

//单行注释

数据类型

Java基本数据类型：4类8种
1.逻辑型boolean

	true （真）  / false （假）
	1个字节（8位二进制）,默认值为false

2.文本型char

char：2个字节（16 位二进制）,是整数类型,用单引号括起来的 1 个字符（可以是一个中文字符）
char型变量是用来存储Unicode编码的字符,unicode编码字符集中包含了汉字
默认值为空
转义字符：
		 \n  换行
		  \r  回车 
  		  \t 	Tab 字符
    	  \" 表示双引号字符
    	  \\ 表示一个\    
两字符 char 中间用“+”连接,内部先把字符转成 int 类型,再进行加法运算,char 本质就是个数！
二进制显示的时候经过“处理”显示为字符。
unicode码及其对应的值
48-57	整数0-9
65-90	大写字母A-Z
97-122	小写字母a-z

3.整数型(byte、short、int、long)

byte：8 位（一个字节），用于表示最小数据单位，如文件中数据，取值范围是-128~127    
short：16 位（两个字节），很少用，取值范围是--32768 ~ 32767    
int：32 位（四个字节）、最常用，取值范围是--2^31-1~2^31  （21 亿）    
long：64 位（八个字节）、次常用    
注意事项：    int i=5; // 5 叫直接量（或字面量），即 直接写出的常数。 
   整数字面量默认都为 int 类型，所以数值大小超过int范围时需要在数值后加L表示为long类型   

4.浮点型(float、double)

 float：32 位（四个字节）,后缀 F 或 f,默认值0
 double：64 位（八个字节）,最常用,后缀 D 或 d,默认值0
 注意事项：      
 浮点数字面量默认都为 double 类型,所以在定义的 float 型数据后面加F 或 f；
 double 类型可不写后缀,但在小数计算中一定要写 D 或 X.X    
 float  的精度没有 double 高,有效位数（尾数）短。    
 浮点数是不精确的,不能对浮点数进行精确比较。	

数据类型的默认值

	byte,short,int,long ——0
	float,double—— 0.0
	char ——'\u0000'
	boolean ——false
	引用类型—— null

Java的引用数据类型：

	数组,接口,类

Java数据类型在内存中的存储：

1）基本数据类型的存储原理:所有的简单数据类型不存在“引用”的概念，
基本数据类型都是直接存储在内存中的内存栈上的,数据本身的值就是存储在栈空间里面，
而Java语言里面八种数据类型都是这种存储模型;

2）引用类型的存储原理:引用类型继承于Object类（也是引用类型）
都是按照Java里面存储对象的内存模型来进行数据存储的，
使用Java内存堆和内存栈来进行这种类型的数据存储，
简单地讲，“引用”是存储在有序的内存栈上的,而对象本身的值存储在内存堆上的;

类型转换

范围小的数据类型值可以直接转换为范围大的数据类型值(自动类型转换)
数据类型的范围：
byte<short<int<long<float<double

public class Test {

	public static void main(String[] args) {
		long l = 1222l; //数值型默认为int(在int范围内),long类型需要在数值后加上l或者L
		float f = l;	//自动类型转换	long ——> float
		//范围大的类型名   变量名 = 范围小的类型值
		double d = 1000; //int ——> double
		System.out.println(f);//1222.0	
		System.out.println(d);//1000.0
	}
}

范围大的数据类型类型值转为范围小的数据类型值需要强制类型转换

public class Test {

	public static void main(String[] args) {
		double d = 3.14;
		int i = (int)d;//强制类型转换，会丢失精度，没有特殊要求不要转换
		System.out.println(i);//3
	}

类型判断

instanceof 关键字
变量 instanceof  类型名, 返回true或者false

		Object str = "Java";
        if (str instanceof String) {//判断"Java"是不是String类型
            String s = (String)str;//类型强转
            System.out.println(s.length());//输出字符串的长度
        }

JDK14

		Object str = "Java 14 真香";
        if (str instanceof String s) {
            System.out.println(s.length());
        }
        //如果编译错误,需要在项目配置中手动设置一下语言的版本
        //编译期底层代码:
        //str instanceof String && (s = (String)str) == (String)str

变量

变量创建三要素
	1.变量类型
	2.变量名称
	3.变量内容
	方法体内部定义的变量为局部变量，必须赋值才能使用，有作用范围，不允许重复定义

int a = 10

运算符

+  加
-  减
* 	乘
/	除 ，除法得到的商是整数
%	取余数
++	自加一
- -	自减一
-=		减等
+=	加等
*=	乘等
/=		除等
%=	取余等

int类型运算后仍旧是int类型
int类型与double类型运算后得到是double类型

public class Test {
	//类型运算与i++
	public static void main(String[] args) {
		System.out.println(19 / 5);	// 3 
		//int类型相除得到的仍旧是int类型
		//值是商的整数部分，不管商是3.9还是3.1，结果都是3
		System.out.println(19 % 5);	//4	 取余数 
		int a = 4;
		int b = a ++;	//a的值赋值给b后,a的值自加1  
		System.out.println(a); // 5
		System.out.println(b); // 4	
		int i = 4;
		i = i ++;
		//从内存中取i的值(i = 4),将4赋值给变量i,此时变量i=4
		//然后4自加1变成5后返回内存中替换i的值,i++操作结束
		//i=4(i=4++)继续执行,将值写入内存中,之前i++操作结束后i=5,将4的值覆盖5的值
		//以上操作完成后i还是等于4
		i = i ++;
		System.out.println(i);//4

	}
}

public class Test {
	//++i
	public static void main(String[] args) {
		int a = 4;
		int b = ++a ; //a的值先加1后将结果赋值给b
		System.out.println(a); // 5
		System.out.println(b); // 5	
	}
}

//int类型的运算
public static void main(String[] args) {
		int a = 10;
		a += 2;
		System.out.println(a);//12
		a -= 1;
		System.out.println(a);//11
		a /= 3;//除法 得到int类型的商
		System.out.println(a);//3
		a %=2 ;//取余 得到int类型的余数
		System.out.println(a);//1
	}

深刻理解i++ 和 ++i 转载：https://blog.csdn.net/jiandabang/article/details/103650040

		int i = 0;
		for (int j = 0; j < 50; j++) {
			i = i++; // i=0 的值覆盖了i=1 的值
		}
		System.out.println(i); // 0

比较运算符

== 		对于基本类型,比较的是值是否相当
		对于引用类型,比较的是内存地址
			object类有一个equals方法，默认比较内存地址
			所有object的子类没有重写equals方法，比较的就是内存地址
			重写了就是比较内容的值
			string，Date等都重写了equals方法，比较的是值
!=		不等号
<
<=
>
>=

逻辑运算符

&	与	true & treu = true 两边都是真，结果才是真
|	或	true | fasle= true 两边有一个是真，结果是真
^ 异或	true ^ treu = fasle	两边相同为fasle，不同为true
!	非	！true = false	 真为假 ，  假为真
&&	短路与	false&&true = false 如果左边为fasle，右边的条件就不会执行直接给出false
||	短路或		true || fasle= true 如果左边为true，右边的条件就不会执行直接给出true

三元运算符

boolean表达式 ? true执行体：false执行体

public static void main(String[] args) {
		String string = 1 > 2 ?"条件为真，输出此句" :"条件为假，输出此句";
		System.out.println(string );//条件为假，输出此句
		
	}

获取键盘输入

格式：

	1.导入Scanner类			import java.util.Scanner;
	2.创建Scanner对象		Scanner scan = new Scanner(System.in);
	
	3.调用方法				int num = scan.nextInt(); 获取一个从键盘输入的数字
	
							String s = scan.next();获取一个从键盘输入的字符串
							使用 hasNext判断是否还有输入的数据
							
							String s = scan.nextLine();获取一个从键盘输入的字符串
							使用 hasNextLine 判断是否还有输入的数据

	next() 与 nextLine() 区别:
		next()
			对输入有效字符之前遇到的空白,next() 方法会自动将其去掉
			只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符
			next() 不能得到带有空格的字符串
		nextLine()
			以Enter为结束符
			可以获得空白

scan.hasNextFloat() 判断输入的是否为Float类型
scan.nextFloat(); 获取输入的Float类型的值
scan.hasNextDouble() 判断输入的是否为Double类型
scan.nextDouble(); 获取输入的Double类型的值

import java.util.Scanner;//导入Scanner类	
public class Test {

	public static void main(String[] args) {
		Scanner can = new Scanner(System.in);//创建Scanner对象
		while (true){
			System.out.println("请输入一个数字:");
			if(can.hasNextInt()) {//调用方法前判断输入是否为int类型
				int num = can.nextInt();//调用方法获取输入的值
				if (num == 5) {
					System.out.println("恭喜，猜中了!");
					System.out.println("游戏结束了");
					break;
				}else {
					System.out.println("猜错了！");
					System.out.println("是否继续y/n");
					String s = can.next();
					if ("n".equalsIgnoreCase(s)) {//忽略大小写，判断内容是否相等
						System.out.println("游戏结束了");
						break;
					}
				}
			}else {
				System.out.println("输入有误！");
				break;
			}
			
		}
		
	}
}

随机数

	1、通过System.currentTimeMillis()来获取一个当前时间毫秒数的long型数字。

　　2、通过Math.random()返回一个大于等于0到小于1之间的double值(伪随机选择的数)。
　　获取闭区间的一段区域内的值:
　　获取随机整数[min,max]	(int)(最小值+Math.random()*(最大值-最小值+1))
　　获取随机整数[3,12]		(int)(3+Math.random()*10)

　　3、通过Random类来产生一个随机数,这个是专业的Random工具类,功能强大。
　　
	随机数很常用,在Java有三种产生方式,以Random随机数的使用最为复杂
	Random的功能涵盖了Math.random()的功能
	Random类对象有是否带参数之分,带参数的只要参数相同,多次运行,
	生成随机数的结果总是一样的,即使在不同机器上运行，结果也是一致的
	java中一般有两种常用的随机数,一个是Math中random()方法,一个是Random类
	所谓的随机数都是伪随机数,不是真正的随机,是通过算法实现的

import java.util.Random;
public class Ran {

	public static void main(String[] args) {
		Random random = new Random();
		//使用不带参数的Random()构造函数产生的随机数不会重复
		//带参数的Random(),只要参数相同,多次运行,生成随机数的结果总是一样
		//即使在不同机器上运行，结果也是一致的。
		/**
		 * 方法
		 * nextBoolean() 随机生成一个boolean值true/fasle
		 * nextDouble() 随机生成一个double值 [0.0,1.0)
		 * nextInt()	生成一个随机的int值，该值介于int的区间，也就是-2的31次方到2的31次方-1之间
		 * public int nextInt(int n)	
		 * 该方法的作用是生成一个随机的int值，该值介于[0,n)的区间，
		 * 也就是0到n之间的随机int值，包含0而不包含n 
		 */
		 //获取随机1到20的整数
		System.out.println(random.nextInt(20) + 1);//1到20的随机整数
		System.out.println(Math.random());	//0.0到1.0（不包括1.0）的随机数double类型
		System.out.println((int)(1 + Math.random()*20));
		/**Math.random()	0.0到1.0（不包括1.0）的随机数double类型
		 * 获取随机整数	(数据类型)(最小值+Math.random()*(最大值-最小值+1))
		 * 例如 :获取随机1到20的整数int
		 * 				(int)  ( 1 + Math.random()*(20 - 1 + 1))
		 * 
		 */
	}
}