java变量与数据类型
注释
注释并不会执行,是给我们写代码的人看的
- 单行注释://+注释内容,只能注释一行
- 多行注释:/* 注释内容*/,可以注释一段文字。
- 文档注释:/** 内容*/
字节
- 位(bit):是计算机内数据存储的最小单元,11001100是一个八位二级制的数。
- 字节(byte):是计算机中数据处理的基本单位,习惯上用B表示。
- 1B = 8 bit
- 字符:是计算机中使用的字母,数字,字和符号。
关键字
- 关键字概述
被java语言赋予特定含义的单词。 - 关键字特点
组成关键字的字母全部小写 - 关键字注意事项
goto和const作为保留字存在,目前并不适用。
关键字分类
- 用于定义数据类型的关键字
class,interface,byte,short,int,long,float,double,char,boolean,void
- 用于定义数据类型的关键字
true,false,null
- 用于定义流程控制的关键字
if,else,switch,case.default,while,do,for,break,continue,return
- 用于定义访问权限修饰符的关键字
private,protected,public
- 用于定义类,函数,变量修饰符的关键字
abstract,final,static,synchronized
- 用于定义类与类之间关系的关键字
extends,implements
- 用于定义建立实例及引用实例,判断实例的关键字
new,this,super,instanceof
- 用于异常处理的关键字
try,catch,finally,throw,throws
- 用于包的关键字
package,import
- 其他修饰符关键字
native,strictfp,transient,volatile,assert
标识符
- 概述
就是给类,接口,方法,变量等起名时使用的字符序列 - 组成规则
英文大小写字母
数字字符
$和_
- 注意事项
不能以数字开头
不能是java中的关键字
区分大小写
- 类和接口
大驼峰命名法 - 方法和变量
小驼峰命名法 - 常量
所有的字母都是大写,多个单词用_隔开
常量
- 字符型常量 用双引号括起来的内容
- 整数变量 所有整数
- 小数常量 所有小数
- 字符常量 用单括号括起来的内容
- 布尔变量 较为特有,只有true和false
- 空常量 null
进制
- 二进制
由0,1组成,以0b开头 - 八进制
由0,1,…7组成,以0开头 - 十进制
由0,1,…9组成,整数默认是十进制的 - 十六进制
以0,1,…9,a,b,c,d,e,f(大小写均可)。以0x开头
原码,反码,补码
- 原码
就是二进制顶点表示法,即最高位为符号位,“0”表示正,“1”表示负,其余位表示数值的大小 - 反码
正数的反码与其原码相同,负数的反码是对其原码逐位取反,但符号位除外。 - 补码
正数的补码与其原码相同,负数的补码在其反码的末位加1。
变量
int var = 12;
int var=18;//错误:已在方法main(string)中定义了变量var
int a;//变量的声明
System.out.println(a);//错误:可能尚未初始化变量
数据类型
java是强数据类型,对于每一种数据都定义了明确的具体数据类型,在内存中分配了不同大小的内存空间
类型 | 占用存储空间 | 表数范围 |
---|---|---|
byte | 1字节 | -128~127 |
short | 2字节 | -2^15~ 2 ^15-1 |
int | 4字节 | -2^31~2 ^ 31-1 |
long | 8字节 | -2^63 ~ 2 ^ 63 -1 |
float | 4字节 | -3.043E38~3.403E38 |
doubt | 8字节 | -1.798E308~1.798E308 |
char | 2字节 | 一个字符 |
boolean | 占一位 | 只有true和false |
*整数默认:int,小数默认:double
注意事项
- 作用域:变量定义在哪一级大括号里,哪个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名的变量。
- 初始化值:局部变量没有初始化值不能直接使用。
- 在一行上建议只定义一个变量,可以定义多个,但是不建议。
public static void main(String[] args){
byte b = 13;
//byte b1 = 129;//错误:不兼容的类型,从int转换到byte可能会有损失,
short a = 123;
int i = 999;
int i1 = 100_000_0000;
System.out.pritln(i1);//1000000000,数字之间可以用下划线分割
long l = 21474836461;//错误:过大的整数
float f = 123.0;//错误:不兼容的类型,从double类型到float可能会有损失
**如果定义float类型,必须在小数后面加f.如:float a = 123.0f**
**定义long类型的数据,如果定义的数据的范围小于int,则直接定义,如果定义的范围大于int型,则需要在其后面加上“l”**
byte byte1 = 12;
int int1 = 8;
System.out.pritln(byte1+int1)//20
byte byte2 = byte1 + int1;//错误:不兼容的类型,从int转换到byte可能会有损失
byte byte12=3,byte13=4,byte14;
//byte14 = byte12 + byte13;//错误,不兼容的类型,从int转化到byte可能会有精度损失
int money = 10_0000_0000;
int years = 20;
int total = money * years;
System.out.println(total);//结果为负数,计算的时候溢出
long total2 = money * years;
System.out.println(total2);//结果为负数,计算的时候溢出,money*year默认是int型,转换之前已经出问题了
long total3 = money * ((long)years);
System.out.println(total3);//200_0000_0000
byte14 = 3 + 4;
byte byte2 = (byte)(byte1+int1);//强制类型转换
}
浮点数扩展
最好完全避免使用浮点数进行比较
float f = 0.1f;
float f1 = 0.1f;
double d1 = 0.1;
double d = 1.0 / 10;
System.out.println(f == d);//false
System.out.println(f == d1);//false
System.out.println(f1 == f);//true
float f2 = 2313322334444f;
float f3 = f2 + 1;
System.out.println(f2 == f3);//true
进制转换
默认转换
- byte,short,char——int——long——float——doubt
是byte,short,char类型的数据做运算,首先会转换为int型。
byte,short,char类型和int类型做运算,会转换为int型。
int型和long型做运算会转换为long型。
long型和float型做运算,会转化为float型。
float型和doubt型做运算,会转换为doubt型。 - 在把高容器转换到低容器的时候,强制转换。转换的时候可能存在内存溢出,或者精度问题。
面试题
一,
- byte b1 = 3,b2 = 4,b;
- b = b1 + b2;
- b = 3+4;
- 那一句是编译失败的,为什么?
第二句是编译失败的,剩下的都正确。
二,
- byte by = 130;有没有问题,有问题如何解决?
- 答案是:-126
三,
/*
1,从左往右做运算
2,任何基本数据类型和字符串做运算后得到的都是字符串
3,byte,char,short不能直接做运算,必须先转化成int型
*/
System.out.println('a');//a
System.out.println('a'+1);//98
System.out.println("hello"+'a'+1);//helloa1
System.out.println('a'+1+"hello");//error:a1hello,ok:98hello1
System.out.println("5+5="+5+5);//error:5+5=10,ok:5+5=55
System.out.println(5+5+"=5+5");//10=5+5
数组:
数组概念:
- 数组是存储同一种数据类型多个元素的集合,也可以看成是一个容器。
- 数组既可以存储基本数据类型,也可以存储引用数组类型。
- 数组的定义格式:
格式1:数组类型[] 数组名。
格式2:数组类型 数组名[]
注意:这两种定义做完了,数组中是没有元素值的。
数组的初始化概述:
数组初始化概述:
- java中的数组必须先初始化然后才能使用。
- 所谓初始化:就是为数组中的数组元素分配内存空间,并为每个数组元素赋值。
数组的初始化方式:
- 动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。
- 静态初始化:初始化时指定每个数组元素的初始值,由系统决定数组长度。
数组的动态初始化:
- 动态初始化:初始化时只指定数组长度,由系统为数组分配初始值。
- 格式:数组类型[] 数组名 = new 数组类型[数组长度]
- 数组长度其实就是数组中的元素个数。
- 举例:
int[] arr = new int[3];
解释:定义了一个int类型的数组,这个数组中可以存放3个int类型的值。
二维数组定义格式:
格式1:
- 数据类型[][] 变量名 = new 数据类型[m][n]
- m表示这个二维数组有多少个以为数组。
- n表示每一个一维数组的元素个数。
- 举例:
int[][] arr = new int[3][2]
定义了一个二维数组arr
这个二维数组有3个一维数组,名称为:arr[0],arr[1],arr[2]
每个一维数组有2个元素,可以通过arr[m][n]来获取。
表示获取第m+1个一维数组的第n+1个元素。、格式2:
- 数据类型[][] 变量名 = new 数据类型[m][]
- m表示这个二维数组有多少个以为数组。
- 这一次没有直接给出一维数组的元素个数,可以动态的给出。
举例:
int[][] arr = new int[3][];
arr[0] = new int[2];
arr[1] = new int[3];
arr[2] = new int[1];格式3:
- 数据类型[][] 变量名 = new 数据类型[][]{{元素…},{元素…},{元素…}}
简化版格式:
数据类型[][] 变量名 = {{元素…},{元素…},{元素…}}
举例:
int[][] arr = {{1,2,3},{3,2,1},{3,0}}
public class Demo11 {
public static void main(String[] args) {
//动态初始化
int[] arr = new int[3];
System.out.println(arr);//[I@16b98e56
System.out.println(arr[0]);//0
arr[2] = 10;
System.out.println(arr[2]);//10
String[] arr1 = new String[2];
System.out.println(arr1);//[Ljava.lang.String;@7ef20235
System.out.println(arr1[1]);//0
//System.out.println(arr2[2]);//10,报错
//静态初始化
int[] arr3 = new int[]{1,2,3,4};
System.out.println(arr3[3]);
//获取数组的长度,数组名.length
System.out.println(arr3.length );//4
int[][] arr4 = new int[][]{{1,2},{2,3},{3,4}};
//arr4 = {{1,3},{1,5}};错误,如果想对数组进行重新赋值,必须使用new
//当新创建一个数组的时候可以如下“
int[][] arr5 = {{1,2,3},{2,3,4}};
}
}
Array:
打印数组元素 Arrays.toString(数组)
数组排序 Arrays.sort(a);
基本类型包装类:
概述:
- 将基本数据类型封装成对象的好处在于可以在对象中定义更多的功能方法操作该数据。
- 常用的操作之一:用于基本数据类型与字符串之间的转换。
- 基本类型和包装类的对比。
基本类型| 包装类
基本类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
float | Float |
double | Double |
char | Character |
boolean | Boolean |
//1,int 转包装类
int i = 100;
Integer integer1 = new Integer(i);
//2,包装类转换成int
int i2 = integer1.intValue();
//注意:jdk5以后可自动转换,自动拆装箱
Integer integer2 = i;
int i3 = integer1;
//包装中的常用方法
String str = "123";
//字符串转int
int i4 = Integer.parseInt(str);
System.out.println(i4 + 1);
//int转string
int i5 = 123;
String str2 = i5+"";
String string1 = Integer.toString(i5);
System.out.println(string1+1);
String str3 = "123.45";
System.out.println(i4 + 1);
Integer integer5 = Integer.valueOf(str);
System.out.println(integer5+1);
Integer类成员方法:
常用的基本进制转换:
public static String toBinaryString(int i)
public static String toOctalString(int i)
public static String toHexString(int i)十进制到其他进制:
public static String toString(int i,int radix)
其他进制到十进制:
public static int parseInt(String s,int radix)
character类概述及其构造方:
Character类概述:
Character类在对象中包装一个基本类型char的值
此外,该类提供了几种方法,以确定字符的类型(小写字母,数字,等等),并将字符从大写转换成小>写,反之亦然构造方法:
public Character(cahr value)
Character类成员方法:
public static boolean isUpperCase(char ch)
public static boolean isLowerCase(char ch)
public static boolean isDigit(char ch)
public static char toUpperCase(char ch)
public static char toLowerCase(char ch)
BigInteger类概述及其构造方法:
BigInteger类概述
可以让超过Integer范围内的数据进行运算
构造方法
public BigInteger(String val)
BigInteger类成员方法:
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger val)
public BigInteger divide(BigInteger val)
public BigInteger[ divideAndRemainder(BigInteger val)
BigDecimal类概述及其构造方法
由于在运算的时候 , float类型和double很容易丢失精度,演示案例。所以,为了能精确的表示、计>算浮点>数, Java提供了BigDecimal.
BigDecimal类概述
不可变的、任意精度的有符号十进制数。
构造方法
public BigDecimal(String val)
BigDecimal类成员方法:
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor)
public BigDecimal divide(BigDecimal divisorint scale, int roundingMode)
Date类概述及其方法:
Date类概述:
类Date表示特定的瞬间,精确到毫秒。
构造方法:
public Date()
public Date(long date)成员方法:
public long getTime()
public void setTime(long time)
public class Demo14 {
public static void main(String[] args) {
Date date = new Date();//获取时间,里面的时间代表运行到这行代码时的当前时间,精确到毫秒
System.out.println(date);
System.out.println(date.getTime());//代表从1970年1月1日00:00:00到date为止的毫秒数
System.out.println(System.currentTimeMillis());//从1970年00:00:00执行到本行代码所需要的时间
date.setTime(date.getTime()+20000);
System.out.println(date);
Date date1 = new Date(System.currentTimeMillis());
System.out.println(date1);
}
}
public class Demo15 {
public static void main(String[] args) throws ParseException {
Date date = new Date();
System.out.println(date);
//日期转字符串
SimpleDateFormat sdf = new SimpleDateFormat();
String dateStr = sdf.format(date);
System.out.println(dateStr);//2020/7/5 下午12:30
String pattern = "yyyy-MM-dd HH:mm:ss:SSS";
sdf = new SimpleDateFormat(pattern);
System.out.println(sdf.format(date));
//String类型转化成date类型
String dateStr1 = "2020/07/05 12:34:32:817";
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss:SSS");
Date date2 = sdf2.parse(dateStr1);
System.out.println(date2);
}
}