java笔记注释标示符数据类型类型转换变量常量

最新推荐文章于 2019-07-23 19:47:28 发布

龙骨山的夜空

最新推荐文章于 2019-07-23 19:47:28 发布

阅读量211

点赞数

本文链接：https://blog.csdn.net/LGSDYK/article/details/96098998

版权

1.注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到一个注释用于解释说明程序，注释就类似于我们上学时候写的笔记，我们看着笔记就知道自己写的什么东西了，帮助我们调试程序。

注释并不会被执行，是给我们写代码的人看的，书写注释是一个非常好的习惯，在很多大公司都是强制要求各位去进行编写注释！

Java中的注释有三种：

单行注释：只能注释当前行，以//开始，直到行结束

//输出HelloWorld！

多行注释：注释一段文字，以/开始， /结束！

/*
    这是我们Java程序的主入口，
    main方法也是程序的主线程。
*/

文档注释：用于生产API文档，配合JavaDoc。

【注】文档注释现在只作为了解，学习JavaDoc时详细了解,目前知道有这样的注释就好。

/*
 * @Description HelloWorld类
 * @Author Diamond 狂神QQ:24736743
 **/

2.标示符

编写程序时，需要给组成程序的各个部分起个名字。如在之前的编写Hello程序练习中Hello是类名，也是我们的文件名，它前面的 public class是关键字，是研究Java的人已经定义好的有特殊作用的，每一个代码都有自己的意思和名字。

Java 所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。

Java中已经定义好的关键字

java中组成关键字的子母都是小写，高级文本编辑器中关键字都是有颜色变化的

java标示符要注意几点

所有的标示符以英文大小写子母或美元符$或下划线_开始
首字符之后由英文带小些子母、美元符、下划线、数字组成
不能以关键字作为变量名或方法名
标示符大小写敏感要区分
所有变量、方法、类名要见名知意，不要乱取
类名命名规则：一个单词，首字母大写；多个单词，每个单词首字母大写
方法或变量命名规则：一个单词，字母都小写；多个单词，第二个单词开始，首字母大写
常量命名规则：一个单词，字母全部大写；多个单词，字母全部大写，中间用_隔开

JAVA不采用通常语言使用的ASCII字符集，而是采用unicode这样的标准的国际字符集。因此，这里的字母的含义：可以表示英文、汉字等等。

各种字符集和编码详解https://www.cnblogs.com/happyday56/p/4135845.html

3.数据类型

A.强/弱类型语言，也被成为强/弱类型定义语言

java是一种强类型语言，要求变量的使用要严格符合规定，所有的变量要先定义后才能使用。强类型语言安全性高，不易出错。

弱类型语言也称为弱类型定义语言。与强类型定义相反。像vb，php等就属于弱类型语言·

B.数据类型

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

【注：引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！】

1.2E30=1.2*10^30 1.2E-30=1.2乘10^-30

float和long数据类型后面要加上大写的F或L

java语言整数类型默认为int型，浮点数默认为double型

位（bit）：是计算机 内部数据 储存的最小单位，11001100是一个八位二进制数。
    字节（byte）：是计算机中 数据处理 的基本单位，习惯上用大写 B 来表示,
        1B（byte,字节）= 8bit（位）
        Java中，为什么byte类型的取值范围为-128~127?
https://blog.csdn.net/qq_23418393/article/details/57421688
在学习Java基础语法的时候，初学者的我们可能都会有这么一个疑问为什么byte类型的取值范围为什么是[-128,127]而不是[-127,127]。0 1111111表示最大的数值：127，因为第一位是符号位，所以1 1111111应该是最小的数值：-127，不是这样才对？
________________________________________
在解释这个问题之前我们需要了解几个概念：机器数、真值、原码、反码、补码
机器数：
一个数在计算机中的二进制表示形式, 叫做这个数的机器数。机器数是带符号的，在计算机用一个数的最高位存放符号, 正数为0, 负数为1。
比如：十进制中的数 +3 ，计算机字长为8位，转换成二进制就是00000011。如果是 -3 ，就是 10000011 。那么，这里的 00000011 和 10000011 就是机器数。
真值： 
因为第一位是符号位，所以机器数的形式值就不等于真正的数值。例如上面的有符号数 10000011，其最高位1代表负，其真正数值是 -3 而不是形式值131（10000011转换成十进制等于131）。所以，为区别起见，将带符号位的机器数对应的真正数值称为机器数的真值。
例：0000 0001的真值 = +000 0001 = +1，1000 0001的真值 = –000 0001 = –1
原码： 
原码就是符号位加上真值的绝对值, 即用第一位表示符号, 其余位表示值. 比如如果是8位二进制:
[+1]原 = 0000 0001 
[-1]原 = 1000 0001 
第一位是符号位. 因为第一位是符号位, 所以8位二进制数的取值范围就是:[1111 1111 , 0111 1111] 
即[-127 , 127]。原码是人脑最容易理解和计算的表示方式.
反码： 
反码的表示方法是:正数的反码是其本身，负数的反码是在其原码的基础上, 符号位不变，其余各个位取反。
[+1] = [00000001]原 = [00000001]反 
[-1] = [10000001]原 = [11111110]反
可见如果一个反码表示的是负数, 人脑无法直观的看出来它的数值. 通常要将其转换成原码再计算.
补码： 
补码的表示方法是:
正数的补码就是其本身
负数的补码是在其原码的基础上, 符号位不变, 其余各位取反, 最后+1. (即在反码的基础上+1)
[+1] = [00000001]原 = [00000001]反 = [00000001]补 
[-1] = [10000001]原 = [11111110]反 = [11111111]补
对于负数, 补码表示方式也是人脑无法直观看出其数值的. 通常也需要转换成原码在计算其数值.
正数： 
正数的反码和补码都与原码相同 
负数： 
负数的反码、补码与原码不同，负数的反码：原码中除去符号位，其他的数值位取反，0变1，1变0。负数的补码：反码+1
例如：
 
解释：为什么byte类型的取值范围为-128~127？
现在我们知道了计算机可以有三种编码方式表示一个数. 对于正数因为三种编码方式的结果都相同:
　　[+1] = [00000001]原 = [00000001]反 = [00000001]补
　　所以不需要过多解释. 但是对于负数:
　　[-1] = [10000001]原 = [11111110]反 = [11111111]补
　　可见原码, 反码和补码是完全不同的. 既然原码才是被人脑直接识别并用于计算表示方式, 为何还会有反码和补码呢?
　　首先, 因为人脑可以知道第一位是符号位, 在计算的时候我们会根据符号位, 选择对真值区域的加减. (真值的概念在本文最开头). 但是对于计算机, 加减乘数已经是最基础的运算, 要设计的尽量简单. 计算机辨别”符号位”显然会让计算机的基础电路设计变得十分复杂! 于是人们想出了将符号位也参与运算的方法. 我们知道, 根据运算法则减去一个正数等于加上一个负数, 即: 1-1 = 1 + (-1) = 0 , 所以机器可以只有加法而没有减法, 这样计算机运算的设计就更简单了.
　　于是人们开始探索 将符号位参与运算, 并且只保留加法的方法. 首先来看原码:
　　计算十进制的表达式: 1-1=0
　　1 - 1 = 1 + (-1) = [00000001]原 + [10000001]原 = [10000010]原 = -2
　　如果用原码表示, 让符号位也参与计算, 显然对于减法来说, 结果是不正确的.这也就是为何计算机内部不使用原码表示一个数.
　　为了解决原码做减法的问题, 出现了反码:
　　计算十进制的表达式: 1-1=0
　　1 - 1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原= [0000 0001]反 + [1111 1110]反 = [1111 1111]反 = [1000 0000]原 = -0
　　发现用反码计算减法, 结果的真值部分是正确的. 而唯一的问题其实就出现在”0”这个特殊的数值上. 虽然人们理解上+0和-0是一样的, 但是0带符号是没有任何意义的. 而且会有[0000 0000]原和[1000 0000]原两个编码表示0.
　　于是补码的出现, 解决了0的符号以及两个编码的问题:
　　1-1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原 =[0000 0001]反 + [1111 1110]反= [0000 0001]补 + [1111 1111]补 = [0000 0000]补=[0000 0000]原
这样0用[0 000 0000]表示, 而以前出现问题的-0则不存在了.而且可以用[1000 0000]表示-128:
　　(-1) + (-127) = [1000 0001]原 + [1111 1111]原 = [1111 1111]补 + [1000 0001]补 = [1000 0000]补
　　-1-127的结果应该是-128, 在用补码运算的结果中, [1000 0000]补 就是-128. 但是注意因为实际上是使用以前的-0的补码来表示-128, 所以-128并没有原码和反码表示.(对-128的补码表示[1000 0000]补算出来的原码是[0000 0000]原, 这是不正确的)，使用补码, 不仅仅修复了0的符号以及存在两个编码的问题, 而且还能够多表示一个最低数. 这就是为什么8位二进制, 使用原码或反码表示的范围为[-127, +127], 而使用补码表示的范围为[-128, 127]。
因为机器使用补码, 所以对于编程中常用到的32位int类型, 可以表示范围是: [-231, 231-1] 因为第一位表示的是符号位.而使用补码表示时又可以多保存一个最小值。
参考博客： 
GOFighting 
byte类型数据范围分析


    字符：是指计算机中使用的字母、数字、字和符号
    
    ASCIIS码： 
        1个英文字母（不分大小写）= 1个字节的空间
        1个中文汉字 = 2个字节的空间
        1个ASCII码 = 一个字节
    UTF-8编码：
        1个英文字符 = 1个字节
        英文标点 = 1个字节
        1个中文（含繁体） = 3个字节
        中文标点 = 3个字节
    Unicode编码：
        1个英文字符 = 2个字节
        英文标点 = 2个字节
        1个中文（含繁体） = 2个字节
        中文标点 = 2个字节
        
    1bit表示1位，
    1Byte表示一个字节 1B=8b。
    1024B=1KB
    1024KB=1M
    1024M=1G.

Java语言的整型常数默认为int型，浮点数默认是Double

C.整形拓展

1.进制

[外链图片转存失败(img-Q3WM3P7K-1563238431924)(C:\Users\Administrator\Desktop\上课资料\正常进度上课班资料\20190526-JavaSE-课件\进制转换\进制的由来.bmp)]

不同进制的数据表现形式

二进制数据由1,0组成以0b开始
八进制数据由0…7组成以0开始
十进制数据由0…9组成整数默认就是十进制
十六进制数据由0…9,a , b, c, d ,e, f 以0x开始

2.进制转换

a.任意进制到十进制的转换

[外链图片转存失败(img-eYMGVXO6-1563238431926)(C:\Users\Administrator\Desktop\上课资料\正常进度上课班资料\20190526-JavaSE-课件\进制转换\任意进制到十进制的数据转换.bmp)]

b.十进制到任意进制的转换

[外链图片转存失败(img-sDskTxrJ-1563238431927)(C:\Users\Administrator\Desktop\上课资料\正常进度上课班资料\20190526-JavaSE-课件\进制转换\十进制数据到任意进制数据的转换.bmp)]

c.8421码快速转换

[外链图片转存失败(img-ctHECoIB-1563238431928)(C:\Users\Administrator\Desktop\上课资料\正常进度上课班资料\20190526-JavaSE-课件\进制转换\快速转换法.bmp)]

D.浮点型拓展

浮点类型的float和double的数据不适合在不容许存在误差的计算领域，如果需要进行不产生舍入误差的精确数字计算，需要使用BigDecimal类。

由于字长有限，浮点型能够精确表示的数是有限的，因而也是离散的。浮点数一般都存在误差，很多数值的结果只能是接近而不等于。

java.math下有两个类：BigInteger和Decimal,可以处理任意长度的数值，BigInteger实现了任意精度的整数运算，Decimal实现了任意精度的浮点运算。

float类型数字在内存中的存储方法：

float类型数字在计算机中用4个字节存储。遵循IEEE-754格式标准：
一个浮点数有2部分组成：底数m和指数e

底数部分使用二进制数来表示此浮点数的实际值
指数部分占用8bit的二进制数，可表示数值范围为0-255

但是指数可正可负，所以，IEEE规定，此处算出的次方必须减去127才是真正的指数。
所以，float类型的指数可从-126到128

底数部分实际是占用24bit的一个值，但是最高位始终为1，所以，最高位省去不存储，在存储中占23bit
科学计数法。

格式：
SEEE EEEE EMMM MMMM MMMM MMMM MMMM MMMM
S表示浮点数正负
E指数加上127后的值得二进制数据
M底数

举例：
17.625在内存中的存储

首先要把17.625换算成二进制：10001.101

整数部分，除以2，直到商为0，余数反转。
小数部分，乘以2，直到乘位0，进位顺序取。

在将10001.101右移，直到小数点前只剩1位：
1.0001101 * 2^4 因为右移动了四位

这个时候，我们的底数和指数就出来了
底数：因为小数点前必为1，所以IEEE规定只记录小数点后的就好。所以，此处的底数为：0001101
指数：实际为4，必须加上127(转出的时候，减去127)，所以为131。也就是10000011
符号部分是整数，所以是0
综上所述，17.625在内存中的存储格式是：
01000001 10001101 00000000 00000000

换算回去：自己做。

E.字符型拓展

单引号用来表示字符常量。例如’A’是一个字符，"A"是一个字符串。

char类型用来表示Unicode编码表中的字符，Unicode编码被设计用来处理各种语言的所有文字，它占用两个字节，可允许有2^16即65536个字符，通常用’u0000’到’uFFFF’之间的十六进制来表示（前缀为U表示Unicode）

代码演示

public static void main(String[] args) {
    char c1 = 'a';
    char c2 = '中';
    System.out.println(c1);
    System.out.println((int) c1);   //97
    System.out.println(c2);
    System.out.println((int) c2);   //20013
}

4.类型转换

在运算中，由于java语言的严谨性，需要用到类型转换

整数型、实型（常量）、字符型数据可以混合运算

不同类型数据运算时要先转化为同一类型，然后进行运算

类型转换规则

不能对boolean类型进行转化
不能把数据类型抓换为不相关的对象

自动类型转换是从低容量数据到高容量数据

低  ------------------------------------>  高

byte,short,char—> int —> long—> float —> double

【演示】

public class ZiDongLeiZhuan{
    public static void main(String[] args){
        char c1='a';//定义一个char类型
        int i1 = c1;//char自动类型转换为int
        System.out.println("char自动类型转换为int后的值等于"+i1);
        char c2 = 'A';//定义一个char类型
        int i2 = c2+1;//char 类型和 int 类型计算
        System.out.println("char类型和int计算后的值等于"+i2);
    }
}

浮点数到整数的转化是通过舍弃小数得到的，而不是四舍五入

4.在转换的数据类型是兼容的情况下，高容量数据转低容量数据需要进行强制数据转换，又被称为造型，用于显式地转换一个数值的类型。强制类型转换可能造成精度降低或数据溢出

【演示】

public static void main(String[] args) {
    double x  = 3.14;
    int nx = (int)x;   //值为3  精度损失

    char c = 'a';
    int d = c+1;
    System.out.println(d); //98
    System.out.println((char)d);  //b
}

public static void main(String[] args) {
    int x = 300;
    byte bx = (byte)x;    //值为44  数据溢出，变为不相干的数值
    System.out.println(bx);
}


public static void main(String[] args) {
    int money = 1000000000;  //10亿
    int years = 20;
    int total = money*years;   //返回的是负数
    long total1 = money*years;  //返回的仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生了数据丢失
    long total2 = money*((long)years);   //先将一个因子变成long，整个表达式发生提升。全部用long来计算。
    System.out.println(total);
    System.out.println(total1);
    System.out.println(total2);
}
/*
注意：整数运算

如果两个操作数有一个为Long, 则结果也为long

没有long时，结果为int。即使操作数全为shot,byte，结果也是int.

浮点运算

如果两个操作数有一个为double, 则结果为double.

只有两个操作数都是float, 则结果才为float.
*/

在实际开发和学习中，如果遇到特别长的数字，读懂它令人头疼！JDK7为我们提供了下划线分隔符，可以按照自己的习惯进行分割。

int b = 1_2234_5678;

我们很容易就知道这是1亿2234万5678啦！非常符合国人的习惯！

5.变量和常量

A.变量

变量就是可以变化的量，是我们在内存中开辟的一小块空间，变量名就是这个空间的名字，变量类型决定这块空间的大小，每个变量都必须声明其类型，只有在声明变量后才能为其分配存储空间。

java变量是程序中最基本的存储单位，其要素包括变量名、变量类型和作用域。

作用域就是大括号括起来的范围（不包括大括号里另一个大括号括起来的范围）。同一个作用域中只能定义一个同名变量，否则就会报错，但可以将原变量重新赋值。

我们在定义变量时可以不必赋值，但如果需要使用该变量则必须赋值，否则就会报错

【演示】

public class Test01 {
    public static void main(String[] args) {
        int a = 10;
        int a = 15;//错误！！同一个作用域只能有一个同名变量
        a = 16;  //但可以重新对该变量赋值
        int b;//可以不必赋值
        System.out.println(b);//错误！！  使用时必须赋值
    }
    int a = 46;//可以  非同一作用域
}
int a, b, c;         // 声明三个int型整数：a、 b、c
int d = 3, e = 4, f = 5; // 声明三个整数并赋予初值
byte z = 22;         // 声明并初始化 z
String s = "runoob";  // 声明并初始化字符串 s
double pi = 3.14159; // 声明了双精度浮点型变量 pi
char x = 'x';        // 声明变量 x 的值是字符 'x'。

变量根据作用域可以分为三种：

类变量（静态变量static variable）:独立于方法之外的变量，用static修饰
实例i变量（成员变量member variable）:独立于方法之外的变量，但没有static修饰
局部变量（local variable）:类的方法中的变量，生命周期从声明位置到"}"为止，局部变量没有默认值，必须初始化（赋初始值）才能使用

B.常量

常量（Constant）:初始化后不会再变动、不能再改变值的量。

java中分为字面值常量和自定义常量。

字面值常量：整数常量（所有整数）、浮点常量（所有浮点数据）、字符常量（被单引号括起来的单个字符）、字符串常量(被双引号括起来的单个或多个字符)、boolean常量（ture/false）、空常量(null)

在java中使用关键字final指示常量，表示该变量只能被赋值一次，赋值后就不能改变。

在一个类里多个方法中使用的常量是类常量，通常在main方法外定义，使用static final 设置类常量，如果被public修饰则其他类中的方法也可以使用。

通常使用大写字母命名，程序中的常量使用可以提高代码的可维护性，避免用户的不规范赋值导致程序出错。

常量优化机制：常量类型数据在运算时会先进行运算，如果运算结果在赋值数据类型范围内就不会报错

public class Test01 {
    public static void main(String[] args) {
        final int NUMBER = 15;
        byte a = 10;
        byte b = 15;
        byte c = a+b;//错误！！ 运算结果为整数，而整数默认int类型，数据类型等级比byte大
        byte c = 10+15;  //可以  运算结果在赋值数据类型范围内就不会报错
        System.out.println(b);//错误！！  使用时必须赋值
    }
}

类中的方法也可以使用。

通常使用大写字母命名，程序中的常量使用可以提高代码的可维护性，避免用户的不规范赋值导致程序出错。

常量优化机制：常量类型数据在运算时会先进行运算，如果运算结果在赋值数据类型范围内就不会报错

public class Test01 {
    public static void main(String[] args) {
        final int NUMBER = 15;
        byte a = 10;
        byte b = 15;
        byte c = a+b;//错误！！ 运算结果为整数，而整数默认int类型，数据类型等级比byte大
        byte c = 10+15;  //可以  运算结果在赋值数据类型范围内就不会报错
        System.out.println(b);//错误！！  使用时必须赋值
    }
}

龙骨山的夜空

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
java笔记注释标示符数据类型类型转换变量常量

1.注释平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写的，但是当项目结构一旦复杂起来，我们就需要用到一个注释用于解释说明程序，注释就类似于我们上学时候写的笔记，我们看着笔记就知道自己写的什么东西了，帮助我们调试程序。注释并不会被执行，是给我们写代码的人看的，书写注释是一个非常好的习惯，在很多大公司都是强制要求各位去进行编写注释！Java中的注释有三种：单行注释：只能注释当前行...
复制链接

扫一扫