语言基础第二天

java小高

已于 2022-04-01 15:44:36 修改

阅读量345

点赞数 4

文章标签： java

于 2022-04-01 11:29:11 首次发布

本文链接：https://blog.csdn.net/weixin_58892350/article/details/123892972

版权

变量

计算机是离不开数据！也就意味着离不开变量

变量：就是来存数据的！我们可以使用变量往内存中存储数据！

1.变量的声明

声明：相当于在银行开个账户

int a;//声明一个int(整数) 的变量 变量名为a
int b,c,d;//声明了三个int(整数)的变量  变量名分别为 b  c   d
//int a; 编译错误：因为已经声明过了一个int 的变量 名字a   变量声明时，名字不能重复！

2.变量的初始化

初始化：给账户里面存钱

int a = 100;//声明一个int 的变量 名为a 并为 a这个变量里面存了100    声明+初始化
int b;//声明一个int 的变量 名为 b
b = 500;//为变量b 里面存了 500 
System.out.println(a);//100   打印输出 变量a 里面存的数据
System.out.println("a");//a  原样输出！

3.变量的使用

使用：使用账户里面的钱

在使用变量时,用到的变量的内容以最后一次赋值的数据为准！


(1)我们对变量的使用，其实就是使用变量里面存的内容！
int a = 5; //声明一个int 变量为a  并为 a这个变量里面存了 5
int b = a + 10;//声明一个int 变量为b  并为里面存了 a + 10计算的结果 15
System.out.println(a);//5
System.out.println(b);//15
b = 300;
System.out.println(b);//300
(2)我们在使用变量时，必须先声明和初始化！
System.out.println(m);

4.变量命名的规范

1.变量名不能以数字开头！可以包含数字、字母、_ 和 $

2.变量名是区分大小写的！！

3.变量名是不可以使用关键字(蓝色字体的)来进行命名！

4.变量名的命名要英文的见名知意！


     //变量的命名规则：
        //1.
//        int 1a; 编译错误：变量名称不能以数字开头！
        int a1;//可以！
        int _a;//可以！
        int $oo,_$,gfdg$_123;//可以！
        //2.变量严格区分大小写！
        int aa = 100;
        System.out.println("AA");//原样输出！
//        System.out.println(AA); 程序严格区分大小写！
        //3.变量名不能用关键字来进行命名
//        int class,static,void,public,int;

        //4.变量的命名要见名知意！！！
        int age = 18; //变量的命名要英文的见名知意！
        int nianling = 10;//不可以用拼音命名！！！
        int 年龄 = 18;//不可以用中文的见名知意！！！
        //变量命名 多个单词之间 遵循小驼峰命名法
        int myAge = 31;
        //类名遵循帕斯卡命名法：每个单词首字母都要大写！

数据类型决定了我们当前变量可存储的数据和范围。

数据类型分为两大类：基本数据类型和引用数据类型

基本数据类型有8种：byte ，short ，int 、long 和 float、 double 、char 、boolean

不常用：byte 后续IO相关知识才会用。

short 和 float 是为了吸引C语言程序员所保留设计的类型。

整数类型：

int:占4个字节

long:占8个字节

小数类型：

double:占8个字节

字符类型：

char:占2个字节

布尔类型：

boolean:占1个字节

内存单位换算：

GB(吉字节)

1GB = 1024MB

MB(兆字节)

1MB = 1024KB

KB(千字节)

1KB = 1024B

B(字节)

1b = 8bit(位)

整数类型：

int类型(4个字节) ，可存储 -21亿多 ~ 21亿多

1.整数的直接量,默认为int类型，直接量是不能够超过当前类型可存储的范围，否则会报错！

2.如果两个整数想除，结果是不会保留小数的！(是截断删除小数的内容，不会四舍五入)！

3.整数运算时，若超出当前类型可存储的范围，则会溢出(溢出不叫错误)，但是需要避免，因为溢出的数据没有实际参考价值。


//直接量
        int a = 100;//声明了一个int类型 变量名为a  并直接存了 100
//      int b = 2147483648;//编译错误：直接量超过int 可存储的最大范围

        int c = 5;
        int d = 2;
        System.out.println(c / d);//2  整数相除不会保留小数位

        int num = 2147483647;//存了int的最大值
        int result = num + 1;
        System.out.println(result);//-2147483648

        /**
         *      最大值+1  --------- (-2147483648)  最小值
         *      最大值+1+1 -------- (-2147483647)
         *      最大值+1+1+1 ------ (-2147483646)
         *
         * */
变量是存储数据的，但是内存大小由当前变量的类型来决定的！
int a = 5;
int b = 2147483647;

long类型(8个字节)，可存储的范围 -900万万亿 ~ 900万万亿

1. 长整数类型直接量需要在直接量后面加上后缀L(建议大写) 来表示。

2.长整数类型在参与运算时，建议在第一个数据后面加上L 代表其运算结果为long类型。


//        long l = 2147483648;// 编译错误： 整数的直接量默认int类型  此时超过了int类型最大范围
                //直接量 后缀L
        long l1= 214748364L;//长整数类型的直接量
                 //10亿
        long a = 1000000000 * 2 * 10L;
//        System.out.println(a);//200亿
                // 30亿在计算时已经超过了int的最大值 发生了溢出 那么 后续的数据则计算不准确
        long b = 1000000000 *3 *10L;
        System.out.println(b);//-12949672960

        long c = 1000000000L * 3L * 10L;
        System.out.println(c);//300亿

小数(浮点数)类型：

double(8个字节)，可以存很大很大很大......

1.浮点类型的直接量默认为 double类型。

2.我们也可以给浮点类型的直接量后缀加上大写D或d 来明确表示 double这个类型。

3. double 类型的数据进行运算时，可能存在误差。


//小数直接量 默认为double类型
        double a = 3.1415926;//声明一个double类型的变量 名为a  并赋值 3.1415926
        double b = 6.999D;//也可以直接量后缀加上大写D

        double c = 3.0;
        double d = 2.9;
        System.out.println(c - d);//0.10000000000000009 可能存在误差 无限接近0.1

        double c1 = 6.0;
        double c2 = 4.9;
        System.out.println(c1 - c2);//1.0999999999999996 存在误差  无限接近1.1

        double d2 = 6.0;
        double d3 = 1.9;
        System.out.println(d2 - d3);//4.1

布尔类型

boolean(1个字节)，要么是true(成立) 要么存的是false(不成立)。


boolean b1  = false ;
    System.out.println(b1);

char类型(2个字节)

char类型也叫做字符类型，什么是字符：数字、字母、符号、中文。
char类型只能存单个字符！ char c = 'A';

unicode:收录了全球的字符，统一字符码、万国码。Java中的char类型采用的那个子集（ASCII码表）。

1. 一个字符对应一个码：表象看到的是字符，实际是处理的那个对应的码(0~65535)区间。

2.字符类型的直接量，要用单引号存储，单引号里面只能存储单个字符至少存一个！

3.Java提供的特殊符号，想进行存储的话需要转义(转换原有的特殊含义)！

ASCII: 'a'=97 'A'=65 '0'=48

转义符: \

/**
 * 字符的使用演示类：
 * */
public class charDemo {
    public static void main(String[] args) {
        char a = '2';//声明一个char类型的变量 里面存的字符 2
//        char b = '12';// 编译错误: 字符只能存单个字符
        System.out.println(a);//字符 2
        System.out.println((int)a);// 字符2对应的码  --- 50
        char b = 50;//也可以直接存对应的码
        System.out.println(b);//打印就会显示码对应的字符
        char c = 2;//存的是码
        System.out.println(c);//打印的是c里面存的码对应的字符
        //--------------------------------
        char d = '\'';
        System.out.println(d);//'
        char d1 = '\\';
        System.out.println(d1);//  \
    }
}

基本类型由小到大依次为：

byte----short----int----long----float----double

char----

类型转换:

Java中类型转换分为两种

自动类型转换:

将小的类型放到大类型的过程，称之为自动类型转换(隐式转换)

强制类型转换:

将大的类型放到小类型的过程，称之为强制类型转换(显式转换)

强制转换有风险，有可能会发生溢出。

/**
 * 类型转换的演示类：
 * */
public class DataTypeDemo {

    public static void main(String[] args) {
        //自动转换： 将小的类型 往 大的类型赋值的过程
//        int a = 5;//没有发生自动类型转换
//        long b = a; //发生了自动类型转换
//        long c = 1000; //发生了自动类型转换
//        double d = c;//发生了自动类型转换s
        int e = 10;
        double d1 = e;//自动转换
        System.out.println(d1);//10.0
        //强制类型转换：
        long a = 1000000000l;//10亿
        int b  = (int)a;//强制转换的语法，在需要转换类型的变量前面加上小括号 小括号里面写上要转换的类型
       // System.out.println(b);

        long c = 3000000000l;//30亿
        int d = (int)c;//强制转换的语法   强制是有风险 需要避免溢出的问题
        System.out.println(d);//溢出的值

        double d2 =  3.1415926;
        int i = (int)d2;//double类型数据强制转换为整数的话  小数位直接截断删除
        System.out.println(i);//3

    }
}

规则：

1.整数直接量，可以直接赋值给 byte 、short 、char 但是不能超过当前类型可存储的范围。

2.byte、shor、char 类型如果在进行运算时，系统自动将其结果转换为int类型。

package 02
/**
 * 类型转换的演示类：
 */
public class DataTypeDemo {

    public static void main(String[] args) {
        //自动转换： 将小的类型 往 大的类型赋值的过程
//        int a = 5;//没有发生自动类型转换
//        long b = a; //发生了自动类型转换
//        long c = 1000; //发生了自动类型转换
//        double d = c;//发生了自动类型转换s
//        int e = 10;
//        double d1 = e;//自动转换
//        System.out.println(d1);//10.0
//        //强制类型转换：
//        long a = 1000000000l;//10亿
//        int b  = (int)a;//强制转换的语法，在需要转换类型的变量前面加上小括号 小括号里面写上要转换的类型
//       // System.out.println(b);
//
//        long c = 3000000000l;//30亿
//        int d = (int)c;//强制转换的语法   强制是有风险 需要避免溢出的问题
//        System.out.println(d);//溢出的值
//
//        double d2 =  3.1415926;
//        int i = (int)d2;//double类型数据强制转换为整数的话  小数位直接截断删除
//        System.out.println(i);//3

        //--规则----------------------------
        //byte 存储范围  -128 ~ 127

        byte b1 = 127;
        char c1 = 65535;
        char a = '2';//50
        char b = '2';//50
        int c = a+b; // a里面字符对应的码 + b里面字符对应的码
        System.out.println(c);//100
//        char c = (char)(a+b);//将a +b的结果强制转换为char类型
//        System.out.println(c);//d
//        System.out.println((int)c);//d对应的码---100
        char  c2 = '我';
        char  c3 = '你';
        System.out.println((int)c2);
        System.out.println((int)c3);
        System.out.println(c2 + c3);//可以直接放到输出语句中 输出 c2的码 + c3的码 结果
        //若两个不同的类型进行运算，系统则会将自动其结果转换为两个类型中最大的哪个类型
        byte b2 = 10;
        byte y = (byte)(b2+10);//byte + int   其结果类型为int
    }
}

java小高

关注

4
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
语言基础第二天

变量计算机是离不开数据！也就意味着离不开变量变量：就是来存数据的！我们可以使用变量往内存中存储数据！1.变量的声明声明：相当于在银行开个账户int a;//声明一个int(整数) 的变量变量名为aint b,c,d;//声明了三个int(整数)的变量变量名分别为 b c d//int a; 编译错误：因为已经声明过了一个int 的变量名字a 变量声明时，名字不能重复！2.变量的初始化初始化：给账户里面存钱int a = 100;//声明一个int..
复制链接

扫一扫