基本语言元素

  • 基本语法：Java大小写敏感类名：首字母大写
  • 方法名：首字母小写后面首字母大写
  • 原文件名和类名相同：test1.class和public calss test1
  • 主方法入口：public static void main(String[] args){}
  • 标识符:类名、变量名以及方法名...
  • 注释:
  • 关键字（49个）

1.访问修饰符关键字:public（所有）,private（当前）,protected（父子）

 2.类、方法和变量修饰符关键字:

abstract,class,extends,final,implements,interface,native,new,static,strictfp,synchronized,transient,volatile

3.流程控制关键字:

break,continue,case,default,do,else,for,if,Instanceof(确定对象是否是一个类、子类或接口的实例),return,switch,while

4.错误处理关键字:catch,finally,throw,throws,try,assert

5.包控制关键字:import,package

6.基本数据类型关键字:boolean,byte,char,short,int,long,float,double

7.变量关键字:super,this

8.空返回类型关键字:void

9.未使用的保留字:goto,const

  • 常量/变量/基本数据类型

数据类型(8种):

1.数字类型(6种):

整数类型(4种):byte(字节型,1个字节,8位,-2^7~2^(7-1)),short(短整型,2字节,16位,15),int(整型,4字节,32位,31,默认),long(长整型,8字节,64位,63,后面加L)

java eachart 元素 java基本元素_java eachart 元素

浮点数类型(2种):float(单精度,32位,1.4e-45~3.4e+38,后面加F),double(双精度,64位,4.9e-324~1.7e+308,默认)

java eachart 元素 java基本元素_java eachart 元素_02

2.字符类型:char(存储单个字符)

3.特殊:布尔(boolean:true/false)

------数据类型转换：

1.低->高:int i = 1;long l = i;2.整数自动转换成浮点，有误差;3.字符串可以转换成整数/长整型:char c = 'a';int /long i/l = c;

4.强制类型转换:(type)value：

int i1 = 127;
byte b1 = (byte) i1;
System.out.println("b1="+b1);
//输出:b1=127
int i1 = 128;
byte b2 = (byte) i2;
System.out.println("b2="+b2);
//输出:b2=-128
//128超出byte取值范围,溢出。
double d = 128.111;
int i  = (int) d;
System.out.println(i);
//输出:d=128
//浮点->整数,小数后的数会被抛弃

 

  • 运算符

java eachart 元素 java基本元素_System_03

1.算数运算符

 

2.自增自减运算符：a++;相当于a=a+1;

int i = 1; 
int j = 2;
int k = i++ + ++j + i++；// 2 + 4 + (2+1) = 6
int a = 0;  
        int b = 0;  
          
        int a1 = 5 + (a++);  
        int b1 = 5 + (++b);  
          
        System.out.println("a="+a + ",b="+b);  
        System.out.println("a1="+a1 + ",b1="+b1); 
//a=1,b=1;
//a1=5,b1=6

我们简单总结来说，自增自减运算符的使用可以分为两种情况：

  • 如果我们仅仅是对一个变量自身进行单纯的自增自减运算，使用“前缀”和“后缀”前两种方式达到的效果实际上是相同的。
  • 但是如果在将自增自减运算和表达式结合使用的话，二者就有了一定的不同。通常来说，我们会这样归纳其不同之处：当自增自减运算符作为前缀结合表达式使用时，会先执行变量的自增自减运算，再执行表达式；而如果作为后缀，则将先执行表达式，然后再进行自增自减运算。

例如现有一个值等于1的整形变量num。那么，以表达式int a = num++;和int a = ++num为例，其在内存中的运算过程实际上是：

  • 当使用“num++”的方式时：在整个运算过程最初，JVM会将num的初始值“1”取到，然后在内存中开辟一块区域作为“预存区”，并将“1”存储到该区域内。而紧接着，就会对num进行自增运算得到新的值“2”。所以，在这个时候num在内存中的值实际上已经由“1”变成了“2”。当完成这个运算过程后，JVM则会在“预存区”中将事先存放的num初始值“1”取出，参与整个表达式的运算，将“1”赋值给变量a，所以这时得到的“a”的值为1。
  • 而当使用“++num”的方式时，JVM则会直接将num的初始值“1”取到，进行自增运算。然后将自增运算后得到的值“2”，参与到整个表达式运算当中，将该值赋值给变量“a”。所以，通过这种方式，变量“a”的值为2。

3.、关系（比较）运算符

boolean result = false;

...

4.位运算符

 

private static void bitOperatorDemo(){  
        System.out.println("5与8进行按位与运算的结果是:"+(5&8));  
        System.out.println("5与8进行按位或运算的结果是:"+(5|8));  
        System.out.println("5与8进行按位异或运算的结果是:"+(5^8));  
        System.out.println("5进行按位取反运算的结果是:"+ (~5));  
    } 
/*
0
13
13
-6
*/
  • 1.与运算：0101和1000按照与运算的运算原理，得到的运算结果为：0000，也就是十进制当中的0
  • 附：与运算的特性：两个数相与，只要有一个数为0，那么结果就为0。
  • 2.或运算：0101和1000按照或运算的运算原理，得到的运算结果为：1101，转换为十进制的值也就是：13
  • 3.异或运算：0101和1000按照异或运算的运算原理，得到的运算结果为：1101，同样也就是十进制的13.
  • 附：对于异或运算的应用，值得一提的是，异或运算有一个特性：一个数异或运算同一个数两次，得到的结果还是这个数。
  • 就以0101和1000为例，0101异或1000运算一次的结果是1101,1101再与1000进行异或运算，得到的结果为0101.也就是说0101^1000^1000 = 5^8^8 =5。
  • 这实际上也是一种最基础的加密解密的应用方式，例如你的数据为5，与8进行异或后，得到的结果是13，13再与8进行异或运算后，得到的结果为5。
  • 这个过程中，5是原始数据，13是加密后的数据，而8则是密匙。
  • 4.取反运算：这是值得一提的运算方式，0101按位取反得到1010，你可能会想，这不就是十进制当中的10吗？会什么取反运算后变成了-6呢。
  • 这是因为在Java中的，int型的数据在内存中实际长度32位，也就是说5在Java内存中的完整表现形式为：
  • 0000 0000 - 0000 0000 - 0000 0000 - 0000 0101，所以在取反运算后，其值变为了：
  • 1111 1111 - 1111 1111 - 1111 1111 - 1111 1010。而该二进制数正对应于十进制当中的-6.

 5.移位运算符

  • 左移运算符“<<”：将操作数的比特位向左移动指定位数，移位后右边空缺的位用0填补。
  • 右移运算符“>>”：将操作数的比特位向右移动指定位数，移动后用于表示符号的最高位按原有的符号位填补，也就是说如果原本符号位为0，则移动后填补0，为1则补1
  • 无符号右移运算符">>>"：与">>"的移位运算规则相同，不同之处在于：无论原有最高位为1还是0，填补时都补0(也就是说无论正数还是负数，移位后都将变为正数)

6.逻辑运算符

 7.三元运算符

private static void demo(int a){  
        int num = 0;  
        if(a>0){  
            num =1;  
        }else{  
            num =2;  
        }  
    } 
//三元运算符简化为:
private static void demo(int a) {  
    int num = a > 0 ? 1 : 2;  
}
  • 代码块:{;}