Java SE ——关键字标识符注释常量与进制变量数据类型运算符

阿巴阿巴404

于 2021-08-12 11:50:22 发布

阅读量166

点赞数

本文链接：https://blog.csdn.net/m0_53331933/article/details/119638412

版权

基本数据与运算
1.关键字/保留字
关键字（Key Word）：是指被高级编程语言赋予特殊含义的一些单词，关键字一般都是由小写字母组成。好比是汉语当中的一些专有名词：北京，天安门，兵马俑。不能乱用。

保留字（Reserve Word）：即它们在Java现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在Java中没有特殊含义，以后版本也不打算使用，但在其它语言中有特殊含义，不宜在Java中定义为变量名称等，因为容易混淆。

注意：关键字和保留字均不能用作变量名、方法名、类名、包名和参数。

保留字：goto、const 还有（null、true、false）

关键字：

1.访问修饰符：public、protected、private

作用：用来修饰类（接口、抽象类）、方法、属性、构造方法、常量、主函数

2.类、接口、抽象类：

class、interface、abstract——定义
extends——继承类
implements——实现接口
new——新建一个对象
super——调用父类方法
this——指代当前对象
instanceof——通过返回一个布尔值来指出，这个对象是否是这个特定类或者是它的子类的一个实例

3.数据类型：

void——没有返回值
byte、short、int、long——整型数据
float、double——浮点型数据
char——字符型数据
boolean——判断型数据
enum——枚举
null、true、false——值类型（是保留字）

4.线程：

synchronized——线程同步（修饰方法、代码块，方法、代码块的同步）

volatile——线程同步（修饰属性，属性的同步）

5.异常：

throw——抛出方法代码中的异常给方法自身。使用位置：方法中间
throws——抛出方法中的异常给调用者。使用位置：方法外部
try——捕获{}中代码是否有发生异常
catch——处理try捕获的异常
finally——不管有没有异常发生都会执行的代码块

6.返回： return

7.循环、条件：if、else、switch、case、break、default、continue、while、do、for

8.包： package、import

9.瞬时的： transient

10.断言：assert

11.调用底层代码（C\C++）：native

12.不可变的——final：

修饰属性、常量、局部变量、参数——作用：数据是不可改变的
修饰类——作用：修饰的类不能被继承
修饰普通方法——作用：修饰的方法不能被重写
13.静态的——static：

修饰属性、常量
修饰内部类
修饰普通方法
作用：所有使用static关键字修饰的内容会最先执行。static修饰的内容在内存中只有唯一的一份（存储在静态内存空间中）。

14.格式规范——strictfp：修饰类、接口或方法。

2.标识符
标识符指的是我们在程序中对变量、函数、类、接口、常量所定义的名称，也就是说这些名称是我们自定义的。

标识符必须满足以下组成规则：

标识符可以由数字、字母、下划线 _ 、美元符 $ 组成
标识符不能以数字开头，当然下划线和美元符其实是可以开头的，但不推荐
标识符不能是关键字
标识符也不能是Java内置类的名称
标识符可以为任意长度，但必须是一个连续的词
标识符严格区分大小写

标识符是为那些抽象的数据进行的自定义起名，为了方便程序的阅读和理解，起名尽量要有含义，不要通篇都是a b c d e f g…。在一些特殊的情况下（循环里特殊数学符号），可以使用i j k m n 之类的。

标识符命名的规范：

大驼峰式：主要针对类名，接口名。所有单词的首字母大写
小驼峰是：主要针对于变量名，函数名。除了第一个单词之外，其他单词首字母大写
常量规范：所有单词字母大写，单词与单词之间用下划线分隔
包名规范：所有单词字母小写，单词与单词之间用句号 . 分隔

myAge 变量名 
getMax() 函数名 
MyMoney 类名 接口名 
MAX_VALUE 常量名 
com.oupeng.java 包名

3 .注释
注释是用于注解和说明程序的一些程序中的内置文本信息的，但这些内置文本不属于代码的范畴。所以在对含有注释的源代码进行编译时，所生成的字节码中不含有注释。注释给人看的！

注释主要有三种：

单行注释 //注释内容直到换行为止
多行注释 /*注释内容内部可以进行换行 */
文档注释 /** 注释内容内部可以进行换行 */ ：文档注释可以被编译器识别，并生成相应的程序说明书。对某一个类进行文档生成时，该类必须是public型

/** 这是一个演示类 名字叫Sample 
@author HENG 
@version 1.0 
*/
public class Sample { 
    /** 
    这是一个主函数，是程序的入口 @param args 在运行主函数是 所传入的一些指令的 @return 该主函数       
    没有返回值
    */
    public static void main(String[] args) { 
 
    } 
}

C:\Users\YONG\Desktop\JavaDay02>javadoc Demo02.java

4. 常量与进制
常量就是指在程序中直接出现的一些数据，也叫字面量

常量都有哪些：

整数常量
小数常量
字符常量：由一个字母、数字、符号被单引号( ‘’ )标识的数据
字符串常量：由若干个字母、数字、符号被双引号( “” )标识的数据
布尔类型常量
null常量

public class Sample { 
    public static void main(String[] args) { 
        //整数常量 
        System.out.println(10); //十进制整数 
        System.out.println(0b1001); //二进制整数 打印出来是十进制 
        System.out.println(0123); //八进制整数 
        System.out.println(0xAF3); //十六进制整数 
        //小数常量 
        System.out.println(3.14); 
        System.out.println(5.234e3); 
        System.out.println(1.2e-3); 
        //字符常量
        System.out.println('a'); 
        //System.out.println('ab'); ERROR 
        System.out.println('9'); 
        //System.out.println('12'); ERROR         
        System.out.println('我'); 
        System.out.println(' '); 
        //System.out.println(''); ERROR 
        //System.out.println('''); ERROR System.out.println('\''); //打印 ' 
        System.out.println('\n'); //打印 换行 
        System.out.println('\t'); //打印 缩进 
        //字符串常量 
        System.out.println("abcd"); 
        System.out.println("a"); 
        System.out.println(""); //字符串空串 vs null真空 
        System.out.println("\""); 
        //布尔常量 
        System.out.println(true);
        System.out.println(false); 
    } 
}

二进制转十进制

十进制	二进制数
0	0
1	1
2	10
3	11
4	100
5	101
6	110
7	111
8	1000

规律就是：1 1 1 1 1 1 1 1 - 128 64 32 16 8 4 2 1

10010101 十进制是 128 + 16 + 4 + 1 = 149

十进制149 = 9 * 100 + 4 * 101 + 1 * 102

二进制1011 = 1 * 20 + 1 * 21 + 0 * 22 + 1 * 23 = 1 + 2 + 0 + 8 = 11

一个二进制位称之为是一个比特 bit；八个比特称之为一个字节 byte；字节是计算机当中的最小计数单元。

1 byte = 8 bit
1 kb = 1024 byte
1 mk = 1024 kb
1 gb = 1024 mb
1 tb = 1024 gb

十进制转二进制

53 ÷ 2 = 26 ~ 1
26 ÷ 2 = 13 ~ 0
13 ÷ 2 = 6 ~ 1
6 ÷ 2 = 3 ~ 0
3 ÷ 2 = 1 ~ 1
1 ÷ 2 = 0 ~ 1
余数从下到上 110101 = 1 + 4 + 16 + 32 = 53

二进制转八进制

10010101 => 010-010-101 => 0225 = 5 * 80 + 2 * 81 + 2 * 82 =5 + 16 + 128 = 149

二进制转十六进制

10010101 => 1001-0101 => 0x95 = 5 * 160 + 9 ^ 161 = 5 + 144 = 149

二进制转六进制

10010101 => 149

149 ÷ 6 = 24 ~ 5
24 ÷ 6 = 4 ~ 0
4 ÷ 6 = 0 ~ 4
所以六进制为405 => 5 * 60 + 0 * 61 + 4 * 62 = 5 + 0 + 144 = 149

负数的二进制

-29的二进制将正数部分的二进制先取反再加1 即为负数的二进制

00011101 =>取反 11100010 =>加1 11100011

5. 变量
指的是变化的量

变量的本质就是在内存中程序所处的进程中的一个临时存储区域
该区域的存储值有限制的
该区域值的变化必须是同类型的或向下兼容的
该区域有其自身的物理内存地址-指针
该区域中存储值的限制和数据的变化类型由数据类型来决定

该区域中其空间的分配和空间的物理内存地址由计算机底层来决定

回顾一下指针
在这里插入图片描述

#include<stdio.h> 
void main() { 
    int a = 3; //创建一个普通的整型变量 存3这个常量 
    int* b; //创建一个一重指针变量 存的是a变量的地址 
    b = &a; 
    int** c; //创建一个二重指针变量 存的是b变量的地址 
    c = &b; 
    printf("a的地址：%d\n",&a); //打印a的地址 0x123 
    printf("a的内容：%d\n",a); //打印a空间的内容 3 
    printf("b的地址：%d\n",&b); //0x456 
    printf("b的内容：%d\n",b); //0x123 
    printf("拿着b的内容去找变量a：%d\n",*b); //3 
    printf("c的地址：%d\n",&c); //0x789 
    printf("拿着c的内容去找变量b：%d\n",*c); //0x123 
    printf("拿着c的内容去找变量b，拿着b的内容去找变量a：%d\n",**c); //3 
    //printf("%d\n",*a); 
    printf("%d\n",*&*c); //0x123 
    printf("%d\n",&*&**&c); //0x456 
}

结果如下：

a的地址：6422300
a的内容：3
b的地址：6422296
b的内容：6422300
拿着b的内容去找变量a：3
c的地址：6422292
拿着c的内容去找变量b：6422300
拿着c的内容去找变量b，拿着b的内容去找变量a：3
6422300
6422296

6 .数据类型
在Java当中，数据类型主要分为两大类：

基本数据类型：在变量的空间中存储数据
1.整型

byte 1字节 2^8 256 -128~127 -2^7 ~ 2^7 - 1
short 2字节 2^16 65536 -32768~32767 -2^15 ~ 2^15 - 1
int 4字节
long 8字节
2.浮点型

float 4字节
double 8字节
3.字符型

char 2字节
4.布尔型

boolean 不确定

在常量中，整型常量默认int类型，小数常量默认是double类型

布尔类型，如果是单一变量的话，在JVM中true被认为是1 false被认为是0 所以是4字节存

如果是布尔类型数组的话，在JVM中true和false被认为是byte类型 1字节

5.引用数据类型：数据是在堆内存中存储，变量仅仅存放的是数据在堆内存中的地址

字符串
数组
对象

在Java中，但凡存储在堆内存中的数据，统称为对象

2.7 运算符
算术运算符

算术运算符	含义	备注
+	加法	1+2=3 如果加号左右有字符串则加号为连接符
-	减法	3-2=1
*	乘法	3*2=6
/	除法	3/2=1 3.0/2=1.5 如果除号两边都是整数结果为整数；有小数结果为小数
%	取余	9%5=4
a++	后置自增	a自身加一，使用原来的值
++a	前置自增	a 自身加一，使用加之后的值
a–	后置自减	a 自身减一，使用原来的值
–a	前置自减	a 自身减一，使用加之后的值

public class Sample { 
    public static void main(String[] args) { 
        /*
        a++ 
        1.先开辟临时存储区 将a的值赋值进去 
        2.a自身加一 
        3.临时存储区的值等待被调用 输出 赋值 参与运算 
        */
        int i = 0; i++; 
        System.out.println(i++); //1    
        System.out.println(i); //2 
        int j = i++; 
        System.out.println(i); //3 
        System.out.println(j); //2 
        i = i++; 
        System.out.println(i); //3 
        i = i++; 
        System.out.println(i); //3 
        int a = 1; 
        System.out.println(a++ + ++a + a++ + a++ + ++a); 
        //                  1     3     3     4     6    
    } 
}

比较运算符

运算的结果为布尔类型

大于
< 小于
= 大于等于
<= 小于等于
!= 不等于
逻辑运算符
& 单与
| 单或
^ 异或
! 非
&& 双与
|| 双或
public class Sample {
public static void main(String[] args) {
int x = 0;
int y = 0;
System.out.println(x++ > 0 & y++ > 0);
System.out.println(x);
System.out.println(y);

    x = 0; 
    y = 0; 
    System.out.println(x++ > 0 && y++ > 0); 
    System.out.println(x); 
    System.out.println(y); 
    //&& 如果左边为假 则右边不用执行 
    //|| 如果左边为真 则右边不用执行 

    //相同为假 不同为真 
    System.out.println(true ^ true); 
    System.out.println(true ^ false); 
    System.out.println(false ^ false); 
    System.out.println(false ^ true); 
}

}
位运算符

& 位与
| 位或
^ 位异或
右移
< 左移

public class Sample { 
    public static void main(String[] args) { 
        int x = 7; 
        int y = 12; 
        System.out.println(x & y); 
        /*
        0111 
        1100 & 
        0100 4 
        */
        System.out.println(x | y); 
        /*
        0111 
        1100 | 
        1111 15 
        */
        System.out.println(x ^ y); 
        /*
        0111 
        1100 ^ 
        1011 11 
        */
        System.out.println(x << 3); 
        /*
        0111 
        0111000 
        x * 2^3 
        */
        System.out.println(56 >> 2); 
        /*
        111000 
        1110 
        56 / 2^2 
        */ 
    } 
}

三目运算符

数据类型变量名 = 布尔表达式?值1:值2;
int number = 10 % 2 == 0? 10 : 2;

补充：变量的交换问题

int a = 3;
int b = 7;

方法一（插入一个参数）：

 int c = a;  
 a = b;  
 b = c; 
 System.out.println(a); 
 System.out.println(b);

方法二（运用算数运算）：

  a = a + b; 
  b = a - b;  
  a = a - b; 
  System.out.println(a); 
  System.out.println(b);

方法三（利用异或）：

 a = a ^ b; 
 b = a ^ b;
 a = a ^ b;  
 System.out.println(a); 
 System.out.println(b);

8 见错误
未声明变量，未初始化变量而使用变量

public class Sample { 
    public static void main(String[] args) { 
        int a = 3; 
        int c = a + b; 
    } 
}
Sample.java:4: 错误: 找不到符号 
        int c = a + b;
                    ^ 
    符号: 变量 b 
    位置: 类 Sample 
1 个错误

public class Sample { 
    public static void main(String[] args) { 
        int a = 3; 
        int b; 
        int c = a + b; 
    } 
}
Sample.java:5: 错误: 可能尚未初始化变量b 
        int c = a + b;
                    ^ 
1 个错误

整型溢出问题

public class Sample { 
    public static void main(String[] args) { 
        int a = 3000000 * 3000000; 
        int b = 3000000 * 3000000; 
        int c = a + b; System.out.println(c);//-207937536 
    } 
}

取整错误

一个是小数的问题，小数主要去的是近似值想要得到一个0.5这个值的话有可能会得到0.4999999

一个是整数的问题，1/3 = 0.3333 * 3 = 0.99999 数学上1

超出预期的除法问题

/左右两边是整数，结果为整数，如果出现小数则结果为小数

额外冗余的输入对象

import java.util.Scanner; 
public class Sample { 
    public static void main(String[] args) { 
        Scanner scanner1 = new Scanner(System.in); 
        System.out.print("请输入整数："); 
        int num1 = scanner1.nextInt(); 
 
        //下面scanner2对象就是一个多余的 
        Scanner scanner2 = new Scanner(System.in); 
        System.out.print("请输入小数："); 
        double num2 = scanner2.nextDouble(); 
        /*
        Sample.java:3: 错误: 找不到符号 
        Scanner scanner = new Scanner(System.in); 
        ^
        符号: 类 Scanner 
        位置: 类 Sample 
        */ 
    } 
}

阿巴阿巴404

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java SE ——关键字标识符注释常量与进制变量数据类型运算符

基本数据与运算1.关键字/保留字关键字（Key Word）：是指被高级编程语言赋予特殊含义的一些单词，关键字一般都是由小写字母组成。好比是汉语当中的一些专有名词：北京，天安门，兵马俑。不能乱用。保留字（Reserve Word）：即它们在Java现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在Java中没有特殊含义，以后版本也不打算使用，但在其它语言中有特殊含义，不宜在Java中定义为变量名称等，因为容易混淆。注意：关键字和保留字均不能用作变量名、方法名、类名、包名和参数。
复制链接

扫一扫