java学习笔记——java基本语法

---

标识符

1.在java语言中，对各种变量，方法和类等要素命名时所使用的字符序列就是标识符。这些标识符有jdk定义好的，也有我们自己开发时候需要定义的。

2.java中标识符由26个英文字符大小写，数字0-9，符号_ $。注意：数字不能开头。

3.java中是严格区分大小写4.在实际写程序的过程中定义标识符遵守“见名之意”.

标识符代码规范

• 类名和接口的规范： 在上面的约束的命名规范的情况下，首字符要大写。如果由多个单词构成每个单词的首字符都大写。 XxxYyy 如：PersonService

• 变量名和方法名： 在上面的约束的命名规范的情况下，我们遵守单词首字符不要大写，如果由多个单词构成，从第二个单词起首字符都大写。这叫驼峰模式。 xxxYyyZzz 如：personDao

• 包名 在上面的约束的命名规范的情况下，都小写。 xxx.yyy.zzz

• 常量 所有字符都大写，多个单词之间使用下划线来分隔。 XXX_YYY_ZZZ

关键字

Jdk定义的标识符就是关键字，我们不可以使用。所以我们定义标识符的时候一定要避开关键字。

java中的注释

注释就是给程序说明的作用，我们要养成写注释的良好习惯，增强代码的可读性。Jvm运行时注释不会被解析。Jvm会跳过注释。

• 单行注释语法：//，注释代码中的一行，建议大家放在要注释的代码的上面

• 多行注释：/* */,通常用于方法内的多行或者类的多行注释

• 文档注释：语法/** */,用于类的说明和方法的说明

//注释内容
    /*
        注释内容
        注释内容
    */
    /**文档注释*/
    /**
     * @author java
     * @version 1.0
     * */

变量和常量

• 程序运行过程

  1.开辟内存空间（创建jvm）

  2.加载数据

  3.CPU提取数据运行当数据加载到内存中时，我们按着运行期数据的是否变化把数据分成常量和变量

• 常量

  数据不发生变化的量。

  例如：

  ​ 整数常量：24小时，一周7天，一年12月

  ​ 小数：重力系数9.8， 圆周率，3.14

  ​ 字符串常量：“旺财”， “小强”

  ​ 字符常量：‘男’，‘a’

  ​ 布尔常量：true，false

  ​ 空常量：null

• 变量

  程序运行期间可以发成变化的数据

  变量的定义需要进行定义变量名字，而且还要定义变量的存储空间，而且还可以定义存储的数据类型。变量中的数据能发生变化。

  常量的定义需要进行定义常量名字，而且还要定义常量的存储空间，而且还可以定义存储的数据类型。常量中的数据不能发生变化。

数据类型

java是强类型语言，在定义变量前需要声明数据类型。在java中主要分为两种数据类型：基本数据类型和引用数据类型。

• 基本数据类型

  根据不同的数据类型可以划分内存的存储的空间大小，不同的类型就是数据类型，一共8种基本数据类型
  
  
  ​ 八位二进制位组成一个字节

  ​ 一个字节表示的范围 -128 到 127

  • 整数类型
    
    ​ 数值类型中最常用的类型就是int，其次是long

  • 小数类型（浮点类型）
    

  • 字符数据类型char 2字节，采用Unicode码 如：‘a‘

  • 布尔数据类型boolean 只有 true false 两个值

• 引用数据类型

  java中的引用数据类型主要包含类、接口和数组等

  String类型是引用数据类型，它是java提供的一个类

变量定义

语法：数据类型 变量名 = 值;我们对变量的操作：取值和存值。

变量的定义位置：定义在方法中或者语句块中。

int age = 5;
double height = 172.5;

变量的一定要赋初始值，否则使用该变量的时候会报错的。

变量名不能重复变量的作用范围：只在当前的大括号内有效（包括子括号），大括号外的所有程序不能使用该变量，所以这种变量也称为局部变量。

基本数据类型的默认值

这八种数据类型是有默认值的。这个默认值如果在变量中不能使用的，必须是在类的属性中使用，因为类的属性可以不赋初始化值。

基本数据类型的转换

• 自动类型转换

基本数据类型在计算的时候都会向数值范围大的方向转换

byte—>short/char–>int ---->long–>float—>double

1.所有的byte类型和short类型和char值运算的时候都会提供成int类型，int最大值2147483647。

2.如果计算中一个操作数据类型是long，另一个数的空间小于等于long，那么结果就是long

3.如果计算中一个操作数据类型是float，另一个数的空间小于等于float，那么结果就是float

4.如果计算中一个操作数据类型是double，另一个数的空间小于等于double，那么结果就是double

• 强制类型转换

  当大容量类型的变量向小容量的类型去转换需要强制转换。语法：（目标类型）值

  byte b1 = 3，b2=4, b;
  b = b1 + b2;//报错，因为byte类型计算完毕后会自动提升为int类型。
  b= 4+3;//不会报错，因为int类型的常量相加只要没有达到byte的上限就可以。
  

  //变量命名、自动类型转换
  class Demo{	
  	public static void main(String[] args){
  		//定义一个字节类型		
  		byte b = 1;
  		//基本数据类型在计算的时候， 数值常量默认是int
  		int b1 = b + 1;		
  		short b2 = 12;
  		//byte, short , int, char, 四种类型只要是发生计算都会自动的把结果提升成int类型
  		int b3 = b + b2;
  		
  		//定义一个char类型,  字符和int类型可以自动的转换
  		char c = 'a';
  		//int i2 = c;
  		int i1 = c + 1;
  		
  		System.out.println(i1);
  		
  		//如果两个int类型计算会不会自动的提升类型呢
  		int x = 2147483647;
  		int y = 12;
  		//int long float, double 自身来计算的时候没有类型的提升，如果超出范围了就会出现精度的损失
  		int z = x + y;
  		System.out.println(z);
  				
  		//int long float, double 不同的类型来计算的时候没有类型的会向大的表数范围提升、		
  		float  f = 1.3f;
  		//int类型和float类型计算转换成float
  		float  f1 = f + y;
  		//小数的常量的默认值是double
  		double d = f + 1.3;
  		// 12.5f是表示float类型的常量， 小的表数范围的常量或者变量可以自动的向大的表数范围的类型转换
  		double d1 = 12.5f;		
  		double d2 = y;	
  		short s = 5;
  		//大的表数范围的值不能自动的赋值小的表数范围的变量
  		s = s + 5;
  	}
  }
  

  //强制转换
  class Demo{	
  	public static void main(String[] args){
  		int i = 999;
  		//数值类型的转换的前提是精度不会损失
  		byte b = (byte)i;
  		System.out.println(b);
  		
  		//定义long类型
  		long l = 10000;
  		int j = (int)l;
  		System.out.println(j);
  		    //小数类型的强转
  		float f = 199.5f;
  		//转换成int, 小数转换成整数，就是把小数去掉
  		short i1 = (short)f;
  		
  		System.out.println(i1);
  		
  		//double向float转换
  		double d = 10.4;
  		float f1 = (float)d;
  		System.out.println(f1);
  		
  		//字符 的转换
  		char c = 'a';
  		int x = c;
  		System.out.println(x);
  		
  		int y = 98;
  		char c1 = (char)y;
  		System.out.println(c1);
  	}
  }
  

运算符

运算符就是告诉程序执行特定的运算操作的符号。java中提供了6类运算符。分别是算术运算符、 赋值运算符、关系运算符、逻辑运算符、位运算符和条件运算符。

• 算数运算符

  四则运算：+，-，*，/；取余：%

//定义两个整数类型变量
		int a = 10;
		int b = 3;
		//+，-，*，/ %
		int c = a + b;
		System.out.println("a + b = "+ c);
		
		int d = a - b;
		System.out.println("a - b = "+ d);
		
		int e = a * b;
		System.out.println("a * b = "+ e);
		//int直接做除法是整除
		int f = a / b;
		System.out.println("a / b = "+ f);
		
		float f1 = 10.0f;
		//由于f1是float类型b是int类型， 在做计算的时候类型做了提升
		float f2 = f1 / b;
		System.out.println("f1 / b = "+ f2);
		
		//取余数
		int g = a % b;
		System.out.println("a % b = "+g);

​ ++、–给数值变量自身加1或减一

i++：先进行表达式运算，再加一

++i：先加一，再进行表达式运算

		int a = 1;	
		int b = 2;
		//      1 * 3         +  1 * 3
		int c = (a++) * (++b) + (--a)*(b++);
	//运算的值  a++:1	++b:3	--a:1	b++:3
	//自己的值  a:2		b:3		a:1		b:4
		
		System.out.println("a = "+a); //1
		System.out.println("b = "+b); //4
		System.out.println("c = "+c); //6

• 赋值运算符

    =，+=，-=，*=，/=, %=
  

  =：将左边的数值赋给右边的变量+=：int x = 2；x+=3;相当于x=x+3

• 关系运算符（又称比较运算符）

    == 等于,!= 不等于,> 大于,>= 大于等于,< 小于,<= 小于等于
  

• 逻辑运算符

    &，|，&&, ||，！	
  

  应用场景：如果某个结果需要多个条件满足或者部分条件满足的判断时使用。

&: 用于连接多个表达式的判断，true&true=true，&两边的表达式都要参与计算。多个表达式在计算的时候&与（每一个表达式的计算结果都是true的情况下），整体结果是true

|:用于连接多个表达式的判断，false|false=false, &两边的表达式都要参与计算,多个表达式在计算的时候|或（每一个表达式的计算结果只要有一个表达式是true的情况下），整体结果是true

短路逻辑（效率高）

&&:用于连接多个表达式的判断, true&&true=true，如果第一个表达式能决定整个表达式的结果第二个表达式就不计算了。

||:用于连接多个表达式的判断, false||false=false，如果第一个表达式能决定整个表达式的结果第二个表达式就不计算了。

！：取反

• 条件运算符（又称三目运算符或三元运算符）

  是java中唯一一个需要三个操作数的运算符

  语法格式：条件？表达式1：表达式2

  首先进行条件的判断，如果结果为true，则返回表达式1的值，如果结果为false，返回表达式2的值。

int min;
min = 5<7?5:7;
System.out.println(min);//5	

• 位运算符（了解）

  在学习源码中，发现有大量使用位运算符，这样做的目的是为了节约内存开销和加快计算效率。

  位：二进制位简称“位”，是二进制记数系统中表示小于2的整数的符号，一般用1或 0表示，是具有相等概率的两种状态中的一种。二进制位的位数可表示一个机器字的字长，一个二进制位包含的信息量称为一比特。

  int类型占4个字节(byte);

  一个字节=8bit(位);

  一个int类型的数值占32bit(位)

  int i = 123;
  10进制123转为二进制后等于:1111011
  完整补位后:00000000 00000000 00000000 01111011

  二进制的最高位为符号位，1代表负数，0代表正数，其余位表示数的绝对值

  -123的原码:10000000 00000000 00000000 01111011

  反码:正数的反码和原码相同，负数的反码为原码除最高位外取反(0变1，1变0)。

  补码:正数的反码和原码相同，负数的补码为原码除最高位外取反+1。

  123的原码:00000000 00000000 00000000 01111011
  123的反码:00000000 00000000 00000000 01111011
  123的补码:00000000 00000000 00000000 01111011

  -123的原码:10000000 00000000 00000000 01111011
  -123的反码:11111111 11111111 11111111 10000100
  -123的补码:11111111 11111111 11111111 10000101

  负数的原码到反码是各位取反（这里说的取反就是0变1,1变0）符号位不变。 反码到补码直接+1；

  已知补码求解码
  最高位如果是1的话（负数），那么除了最高位之外的取反，然后加1得原码。

  最高位如果是0的话，不变，正数的补码就是他的原码。

  • &：按位与。当两位同时为1时才返回1。

  • |：按位或。只要有一位为1即可返回1。

  • ~：按位非。单目运算符，将操作数的每个位（包括符号位）全部取反。

  • ^：按位异或。当两位相同时返回0，不同时返回1。

  • <<：左移运算符。

  • '>>'右移运算符。

  • '>>>'无符号右移运算符

    位操作对补码进行操作

public static void main(String[] args) {
        //5的补码为：00000101
        //6的补码为：00000110
        //5&6       00000100
        //5|6       00000111
        //5^6       00000011
        //~5        11111010（补码）--> 10000101+1-->10000110(原码)
        System.out.println(5&6);//4
        System.out.println(5|6);//7
        System.out.println(5^6);//3
        System.out.println(~5);//-6
        //5的补码为：00000101
        //5<<2    0000010100   -->00010100 (20)
        //5>>3      00000000101-->00000000  (0)
        //5>>>1     000000101   -->00000010(2)
        System.out.println(5<<2);//20
        System.out.println(5>>3);//0
        System.out.println(5>>>1);//2

    }

运算符优先级

• 该表中优先级按照从高到低的顺序书写，也就是优先级为1的优先级最高，优先级14的优先级最低。

• 结合性是指运算符结合的顺序，通常都是从左到右。从右向左的运算符最典型的就是负号，例如3±4，则意义为3加-4，符号首先和运算符右侧的内容结合。

• 总体而言，优先级顺序为算术运算符>关系运算符>逻辑运算符

​