基本程序设计

最新推荐文章于 2022-03-27 19:48:02 发布

weixin_45091028

最新推荐文章于 2022-03-27 19:48:02 发布

阅读量119

点赞数

文章标签： java 基本数据类型

本文链接：https://blog.csdn.net/weixin_45091028/article/details/104225004

版权

一、基本数据与计算

1、关键字

Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对

Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。一些被Java语言赋予了特殊含义的单词，不能随意使用，具体点说就是一些被Java语言赋予了特殊含义的单词，不能随意使用。

2、标识符

其实就是我们程序员在写代码的过程中自定义的一些名称。

例如：

变量名，类名，函数名，接口名...

PS：主函数的main其实也是标识符只不过是被写死了。

1、标识符的组成规则

java中标识符的组成：由52个字母A-Z ，a-z ，数字0-9 ，下划线_ ，美元符$ 组成

注意：不能以数字开头，不能是关键字，不能有空格

为了提高标识符的阅读性，尽量起名字的有意义，一般都是用英文单词表示，拼音就算了。

定义常量名：基本数据类型的常量名全部大写，自定义数据类型的常量名可以大小写混写。

2、标识符的组成规范

小驼峰式命名法

如果一个标识符是由多个单词组成的一个词,那么除了第一个单词首字母小写外，其他单词首字母大写

例如：myName 、yourBoy

主要应用在哪些地方：变量名函数名

2.大驼峰式命名法

如果一个标识符是由多个单词组成的，那么所有单词的首字母大写

例如：MyName YourBoy

主要应用在哪些地方：类接口

3.全大写命名法

如果一个标识符是由多个单词组成的，那么每一个单词都要大写，单词与单词之间用_连接

例如：MAX_VALUE DEFAULT_SIZE

主要应用在哪些地方：定义常量

3、注释

为什么要有注释：代码写的过多的情况下，程序员容易忘记，注释的存在意义就是为了提示程序员

注释本身不属于代码范畴的，注释不会进字节码文件

分类

1.单行注释

//直到换行为止都是注释的内容

2.多行注释

/* 注释内容 */

3.文档注释

/** 注释内容 */

文档注释

我们可以通过文档注释去制作程序说明书（网页文档）

javadoc.exe 工具

javadoc Demo01_01.java（类前面+public）

PS：切记 单行里面可以套多行多行里面可以套单行多行中不能套多行；

四、常量与进制

常量：本身是一些数据数据本身也不能够被改变，常量值又称为字面常量，它是通过数据直接表示的，因此有很多种数据类型，像整型和字符串型等。下面一一介绍这些常量值。

1.整数

二进制整数 0b开头

八进制整数 0开头

十进制整数默认啥也不开头

十六进制整数 0x开头

进制互转

二进制转十进制

十进制换二进制

二进制转八进制二进制转十六进制

八进制转十进制

2456八进制转十进制 = 2*8*8*8 + 4*8*8 + 5*8 +6 = 1326

十六进制转十进制

负数的二进制

取反+1

2.浮点数

一般小数 3.14 科学计数小数 3.89e3

3.字符

由一个数字、字母、符号被单引号包含的数据

计算机如何储存字符：

4.字符串

由一个或多个数字、字母、符号被双引号包含的数据使我们最常用的一种常量类型

5.布尔

它只有两个值 true false 表示的是真和假这两个概念 true false 其实是关键字的一种表示确切的某个值

6.空

null 关键字

五、变量与数据类型

变量：本身可以改变的数据；

变量的本质

1.变量主要是用于存储一些计算当中产生的一些临时性数据

2.变量本质就是在内存当中某一个进程里的一个临时存储区域

3.每一个变量空间在创建的时候都会被随机的分配地址（真实的物理内存地址）

4.变量空间中的数据在变化的过程中必须保持是可兼容的（至少是同一类型）

5.如果直接在代码中用变量的物理地址去访问空间中的数据的话有可能访问不到的

6.为了避免地址的不确定性，引入了变量名这个概念由变量名-地址表来保证变量名和变量之间的关系（底层实现）

7.其实，上述当中变量空间的地址其实就是你们在C语言当中学的指针

8.常量数据一定是在变量空间当中吗？不是，所有的常量都在常量池当中，变量空间当中存的就是常量在常量池中的地址！

数据类型

目的1，为了限制当前变量当中所存储的数据（变量当中的数据必须是可兼容的）

目的2，为了限制当前变量空间的大小

数据类型的分类

基本数据类型：

整数：

byte（1字节 -2^7~2^7 - 1 -128~127）

short（2字节 -2^15~2^15 - 1 -32768~32767）

int（ 4字节 -2^31~2^31 - 1） PS：整数常量默认是int类型

long（8字节 -2^63 ~ 2^63 - 1）

之所以分为四类，原因是主要看我们数字的取值范围

class Test01{
    public static void main(String[] args){
        byte b1=100;
        /*
        00000000 00000000 00000000 01100100?
                                   01100100
        4两的碗 里面放了不到1量的饭
        装到1两的碗里，能放下
        因为整数常量100的有效数据可以直接放入byte里面
        所以计算机将常量100之前的所有空的字节 阉割了
        向下自动类型转换int->byte 从大字节到小字节
        */
        System.out.println(b1);


        //不兼容的类型: 从int转换到byte可能会有损失
        byte b2=(byte)300;
        /*
        00000000 00000000 00000001 00101100
                                   00101100
        4两的碗 里面放了1两多的饭
        装到1两的碗里，放不下
        先去尝试着去向下自动类型转换
        如果你想强行的将300放到byte中-强制类型转换
        强转一定是从大到小的！
        */
        System.out.println(b2);

        byte b3=100;
        byte b4=100;
        //不兼容的类型: 从int转换到byte可能会有损失
        byte b5=(byte)(b3+b4);
        // 00000000 00000000 00000000 11001000
        //                            11001000
        //11001000 -1 
        //11000111 取反 
        //00111000 56  -56
        //对于整数之间进行加法运算的时候 得到的值是int值
        //byte b6=b3+300;
        /*
        对于b5而言 它的后面跟着的是两个变量
        b5不能确定 b3 b4变量的值 
        */
        System.out.println(b5);

        short s1=3;
        short s2=7;
        //报错 原因同上 除非强转
        short s3=(short)(s1+s2);
        System.out.println(s3);

        int i1=Integer.MAX_VALUE;//int类型的最大值
        System.out.println("int的最大值="+i1);
        //2147483647
        int i2=1;
        //此处为什么没有报错？左边右边都是int 无转换
        int i3=i1+i2;
        //整型溢出
        /*?01111111 11111111 11111111 11111111?
        0 10000000 00000000 00000000 00000000 
          10000000 00000000 00000000 00000000 
          -1
          01111111 11111111 11111111 11111111?
          取反
          10000000 00000000 00000000 00000000
        */
        System.out.println(i3);

        long l1=300;
        long l2=300;
        long l3=l1+l2;
        System.out.println(l3);
        // 过大的整数: 123456789123123
        // 整数常量默认int 此时已经超了int的值了
        // 整数常量后面+ l或者L -> long常量
        // 再大就超出了long的范围了
        // 所以对于超级大的数字 long不够用了
        // 如何解决呢？BigInteger BigDecimal两个去解决
        long l4=123456789123123123123123123123123L;
        System.out.println(l4);
    }
}

浮点数：

float 4字节

double 8字节

PS：浮点型常量默认是double类型

class Test02{
    public static void main(String[] args){
        float f=3.14F;
        //从double转换到float可能会有损失
        //float类型的常量后面+F
        System.out.println(f);
        double d=10;
        System.out.println(d);
        double d1=3.14;
        double d2=3.14;
        double d3=d1+d2;
        System.out.println(d3);
        /*
        byte->short->int->long->float->double
        在整数/浮点数变量之间进行运算的时候
        谁是最大的 那么结果就是谁
        小字节+大字节=大字节
        */
        System.out.println(3+390L+3.14F+9.0);
    }
}

字符：

char 2字节 0~65535 (指的就是字符的编号)

class Test03{
    public static void main(String[] args){
        /*
        将一个字符编号给字符变量
        那么在打印这字符变量的时候 
        先去码表中找到编号相对应的字符
        然后再打印
        */
        char c1=97;
        System.out.println(c1);
        
        /*
        将一个字符常量给字符变量的时候
        那么在打印这个字符变量时 直接打印
        无论如何赋值 一旦打印的是字符变量 结果一定是字符
        */
        char c2='A';
        System.out.println(c2);

        /*
        必须要记住的几个字符编号
        'a' 97
        'A' 65
        '0' 48
        */
        char c3='a';
        //字符变量在参与运算时 是以编号身份参加
        System.out.println(c3+1);//98 c3后一个字符的编码
        System.out.println(c3-1);//98 c3前一个字符的编码
        //如何查看'我'这个字符的编码呢？
        System.out.println('我'+0);
        //'我'后面的字符是啥？
        System.out.println((char)('我'+1));
        System.out.println((char)('我'+2));
        //如何判断一个字符是小写字母嘞？97~97+25
        //大写字母？65~65+25
        //数字？48~48+9
        System.out.println((char)8888888);
        //Unicode码表 \\u 指定编码集Unicode
        System.out.println('\u0033');
        //为什么有时候显示是 '?'
        //我们一般用GBK码表或Unicode码表编程
        //但是我们的CMD控制台用的是微软的码表 ANSI
        //相同位置的字符 前两个表中有 ANSI中就不一定有了
        //但是 不管是哪个码表 前面的内容基本是一致的
        boolean b1=true;
        boolean b2=false;
        String s1="哈哈";
        String s2="啦啦";
    }
}

布尔:

在Java当中并没有给boolean一个明确的大小，主要和底层虚拟机相关(如果boolean是一个变量的话 1字节如果boolean是一个数组的话每个空间是4个字节)

引用数据类型

字符串:

String 也不存在具体的大小，它的大小是根据字符串的内容而决定的

目前而言，可以像用基本类型一样去使用String类型数据(String其实是java中自带的一个类)

null

数组

对象；

如何定义变量

数据类型变量名=常量；

数据类型变量;

变量=常量；

六、运算符

算数运算符：

+ 加法运算

如果+号的两边都是数字的话，那么这个+表示的数学上的加法

如果+号的两边，只有有一个字符串，那么这个+表示的是字符串连接符

- 减法运算

* 乘法运算

/ 除法运算

如果两边都是整数结果就是整数（整除）

如果两边至少存在一个小数，结果就是小数

% 取余运算

相当于是整除运算，但是得到的结果是余数

++ 自加运算

前++ ++i i本身直接+1再参与运算

后++ i++ i先参与运算再本身+1

-- 自减运算

跟加法一个道理

赋值运算符

+= -= *= /= %= =

比较运算符

逻辑运算符

位运算符

指的就是二进制之间的运算

& | ^ >> <<

class Test05{
    public static void main(String[] args){
        /* 
        i++
        1.先开辟一个临时存储区
        2.将i的值复制到存储区
        3.i自身+1
        4.临时存储区的值等待被调用(参与运算，输出，赋值)
        */
        int i=3;
        i++;
        System.out.println(i);  //4
        System.out.println(i++);//4
        int j=i++;
        System.out.println(j);  //5
        System.out.println(i);  //6
        i=i++;
        System.out.println(i);  //6
        i=i++;
        System.out.println(i);  //6
        
        i=1;
        j= i++ + ++i + ++i + i++;
        // 1     3     4    4
        System.out.println(j); 
        System.out.println(i); 
        int a=3;
        a=a+3;
        a+=3;
        a=a+1;
        a+=1;
        ++a;
        a++;
        short s=3;
        //不兼容的类型: 从int转换到short可能会有损失
        //s=s+3;
        s+=3;
        System.out.println(s);
        a=1;
        System.out.println(a++==1);
        
        int m=7;
        int n=11;
        System.out.println(m&n);    //3
        /*
            0111
            1011
           &0011 3
        */
        System.out.println(m|n);    //15
        /*
            0111
            1011
           |1111 15
        */
        System.out.println(m^n);    //12
        /*异或：不同为真 相同为假
            0111
            1011
           ^1100 12
        */
        System.out.println(m>>2);   //1
        /*
            0111
              01 11
        */
        System.out.println(m<<2);   //28
        /*
            0111
          011100
        */
        System.out.println(0b10010101>>3);
        //10010
        System.out.println(0b10010101<<3);
        //10010101000
        //x>>y x/2^y
        //x<<y x*2^y  
    }
}

三目运算符

一言以蔽之变量=布尔表达式 ? 值1 : 值2;

布尔表达式的意思是，计算的结果必须是boolean类型

如果布尔表达式的结果是true,则将值1赋予变量

如果布尔表达式的结果是false，则将值2赋予变量

它在一定程度上简化了if语句的功能

int a=5;

int b=6;

int min=a>b?b:a;

weixin_45091028

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基本程序设计

一、基本数据与计算1、关键字Java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对Java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。一些被Java语言赋予了特殊含义的单词，不能随意使用，具体点说就是一些被Java语言赋予了特殊含义的单词，不能随意使用...
复制链接

扫一扫