java变量与数据类型

最新推荐文章于 2023-07-26 10:58:35 发布

浮默

最新推荐文章于 2023-07-26 10:58:35 发布

阅读量368

点赞数

分类专栏： java相关知识文章标签： java

本文链接：https://blog.csdn.net/hzh2222/article/details/106809597

版权

java相关知识专栏收录该内容

2 篇文章 0 订阅

订阅专栏

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);

    }
}

浮默

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java变量与数据类型

java变量与数据类型关键字关键字概述被java语言赋予特定含义的单词。关键字特点组成关键字的字母全部小写关键字注意事项goto和const作为保留字存在，目前并不适用。关键字分类用于定义数据类型的关键字class,interface,byte,short,int,long,float,double,char,boolean,void用于定义数据类型的关键字true，false，null用于定义流程控制的关键字if,else,switch,case.de
复制链接

扫一扫