自用的学习笔记，若有错误欢迎指出。

java关键字

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

以下的这些都是java的关键字，在命名的时候不能使用。

java关键字

java命名注意点

  • 所有的标识符都应该以字母(A-Z, a - z)、美元符$、或者下划线_开始。
  • 首字符之后可以是字母(A-Z, a - z)、美元符$、或者下划线_的任意字符组合。
  • 不能使用关键字作为变量名或者方法名。
  • 标识符是大小写敏感的。

变量命名规范[important]

  • 所有的变量、方法、类名要做到：简洁明了

  • 类成员变量：首字母小写和驼峰原则

  • 局部变量：首字母小写和驼峰原则

  • 常量：大写字母和下划线：MAX_VALUE

  • 类名：首字母大写和驼峰原则

  • 方法名：首字母小写和驼峰原则

  • 合法标识符举例：

    • age
    • $salary
    • _value
    • _1boy

  • 非法标识符举例：

    • 123abc
    • 207somker
    • -salary
    • #boy

数据类型

  • java是一门强类型语言

    • 要求变量的使用严格规定，所有的变量都必须先定义后使用。

  • java的数据类型分为两大类

    • 基本类型(primitive type)
      • 数值类型
        • 整数类型
          • byte: 占1个字节范围：-128~127
          • short：占2个字节范围：-32768~32767
          • int：占4个字节范围：-2147483648~2147483647
          • long：占8个字节范围：略
        • 浮点类型
          • float：占4个字节
          • double：占8个字节
        • 字符类型(char占8个字节)
      • Boolean类型(占1位其值只有true & false)
    • 引用类型(reference type)
      • 类
      • 接口
      • 数组

整数类型于浮点类型

  • 进制：
    • 二进制：0b
    • 十进制
    • 八进制：0
    • 十六进制：0x
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/*
* 整数类型扩展
*/
int i = 10;
int i2 = 010; //八进制
int i3 = 0x10; //十六进制

//输出结果为
System.out.print(i); // 10
System.out.print(i2); // 8
System.out.print(i3); // 16

/*
* 浮点类型扩展
*/
float f = 0.1f;
double d = 1.0 / 10;
System.out.print(f == d); // false
//浮点数精度溢出
//使用 BigDecimal 数学工具类来表示银行的业务。
float f1 = 21313131313131313f;
float f2 = f1 + 1;
System.out.print(f1 == f2); // true

字符类型扩展

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
/*
* 字符类型扩展
*/
char c1 = 'a';
char c2 = 'M';
char c3 = '中';
System.out.println(c1); // a
System.out.println((int)c2);// 77
System.out.println((int)c3);// 20013
/*
* char类型会涉及到Unicode编码: U0000 - UFFFF
* 2的16次方 2^16 = 65536
*/
char c4 = '\u0079';
System.out.println(c1); // y

/*
 转义字符
 \t : 制表符
 \n : 换行
 详见：https://www.cnblogs.com/yaochc/p/4574910.html
*/

类型转换

由于Java是强类型语言，所以当需要进行某些运算的时候，需要用到类型转换。

运算中，不同类型的数据优先转化为同一类型，然后进行运算。

1
2
//低 -------------------------------------------> 高
byte, short, char -> int -> long -> float -> double

注意点：

  1. 不能对布尔值进行转换
  2. 不能把对象类型转换为不相干的类型
  3. 在把高容量转换为低容量的时候，需要强制转换
  4. 在转换的时候，可能出现内存溢出或者精度问题的出现
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
//强制转换 (类型)变量名 高->低
int i = 128;
byte b = (int)i;
System.out.println(i);
System.out.println(b); //内存溢出

//自动转换 低->高
int num1 = 128;
double num2 = num1;
System.out.println(num2); //128.0

//强制转换造成的精度缺失
System.out.println((int)25.6); //25
System.out.println((int)-68.88); //-68

//操作比较大的数的时候，要注意溢出问题
//JDK7的新特性，数字直接可以用"_"下划线分割
int money = 1_000_000_000;
int year = 30;
int total = money * year;
long total2 = money * year; //由于默认是int类型，所以在数字转换以前就存在问题
long total3 = ((long)money) * year; //先把一个
System.out.println(total); //内存溢出
System.out.println(total2); //内存溢出
System.out.println(total3); //输出结果正确

什么是字节

  • 位(bit)：是计算机内部数据最小单位。例：1100 1100是一个八位二进制数。
  • 字节(byte)：是计算机中数据处理的基本单位，习惯上用大写B来表示。
  • 1B(byte，字节) = 8bit(位)
  • 字符：是指计算机中使用的字母、数字、字和符号。

变量

变量就是可以变化的量。

java一种强类型语言，每个变量都必须先声明其类型。

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

1
2
//数据类型 变量名 = 值; 可以使用逗号来隔开声明多个同类型变量
type varName [=value] [{,varName[=value]}];
  • 注意事项：
    • 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
    • 变量名必须是合法的标识符。
    • 变量声明是一条完整的语句，因此每一个声明都必须以分号;结束。

变量作用域

  • 类变量
  • 实例变量
  • 局部变量
1
2
3
4
5
6
7
8
public class Variable {
    static int allClicks = 0; //类变量
    String str = "HelloWorld!"; //实例变量
    
    public void method(){
        int i = 0; //局部变量
    }
}

实例变量：从属于对象，如果不初始化，其初始值为0
布尔值的默认值为：false
除了基本类型，其余的默认值为null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Demo1{
    //属性：变量
    
    //类变量
    static double salary = 2500;
    
    //实例变量：从属于对象，如果不初始化，其初始值为0
    //布尔值的默认值为：false
    //除了基本类型，其余的默认值为null
    String name;
    int age;
    
    public static void main(String[] args){
        //局部变量：必须声明和初始化值
        int i = 10;
        System.out.println(i); //输出结果：10
        
        //变量类型 变量名字 = new Demo1();
        Demo1 demo1 = new Demo1();
        System.out.println(demo1.age); //输出结果：0
        System.out.println(demo1.name); //输出结果：null
        
        //类变量 static
        System.out.println(salary); //输出结果：2500.0
    }
    
    //其他方法
    public void add(){
        
    }
}

常量

常量(Constant): 初始化(initialize)后不能再改变值，是不会变动的值。

所谓常量可以理解成一种特殊的变量，它的值被设定之后，在程序运行的过程中不允许被改变。

1
2
//final 常量名 = 值;
final double PI = 3.14;

常量名一般使用大写字符。

java运算符

点这里到: 菜鸟教程-java运算符

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java也提供了一套丰富的运算符来操纵变量。我们可以把运算符分成以下几组：

  • 算术运算符
  • 关系运算符
  • 位运算符
  • 逻辑运算符
  • 赋值运算符
  • 其他运算符
1
2
3
4
5
6
7
8
9
10
11
12
//二元运算符
long a = 123123123123L;
int b = 123;
short c = 10;
byte d = 6;
double e = 2.0;
        
System.out.println(a + b + c + d); //输出的值为long
System.out.println(b + c + d); //输出的值为int
System.out.println(c + d); //输出的值为int
System.out.println(a / b); //输出的值为long
System.out.println(c / e); //输出的值为double

自增自减：++ 、--

a++: 执行完这行代码之后，先赋值给b，然后再自增

++a: 执行这行代码之前，先自增，然后再给c赋值

1
2
3
4
5
6
7
8
9
10
11
//自增自减：`++` 、`--`
int a = 3;
int b = a++; 
System.out.println(a); // 4
System.out.println(b); // 3
int c = ++a; // c = 5, a = 5
int d = ++c + b + ++a + a++; // c = 6, b = 3, ++a = 6, a++ = 6
System.out.println(a); // 7 (a++ 自增)
System.out.println(b); // 3
System.out.println(c); // 6
System.out.println(d); // 21

幂运算

幂运算可以使用java的工具类Math来运行

1
2
double pow = Math.pow(2, 3); // 2的3次方
System.out.println(pow); // 8.0

逻辑运算符

  • &&: 逻辑与(and)运算
  • ||: 逻辑或(or)运算
  • !: 逻辑非(取反)运算
1
2
3
4
5
6
7
8
9
10
11
boolean a = true;
boolean b = false;
System.out.println(a && b); // false
System.out.println(a || b); // true
System.out.println(!(a && b)); // true

//短路运算
int c = 5;
boolean d = (c < 4) && (c++ < 4);
System.out.println(d); // false
System.out.println(c); // 5

位运算

点这里到：菜鸟教程-位运算

从现代计算机中所有的数据二进制的形式存储在设备中。即 0、1 两种状态，计算机对二进制数据进行的运算(+、-、*、/)都是叫位运算，即将符号位共同参与运算的运算。

符号 描述 运算规则
& 与 两个位都为1时，结果才为1
| 或 两个位都为0是，结果才为0
^ 异或 两个位相同为0，相异为1
~ 取反 0变1，1变0
<< 左移 各二进位全部左移若干位，高位丢弃，低位补0
>> 右移 各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移） 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
A = 0011 1100
B = 0000 1101

# A & B -> A与B
A & B = 0000 1100

# A | B -> A或B
A | B = 0011 1101

# A ^ B -> A异或B
A ^ B = 0011 0010

# ~A -> 取反A
~A = 1100 0011

思考：在计算机运算2 * 8中，用什么方式效率最高？

  • 采用位运算是最快的。采用<<左移来实现。

字符串连接符

在+的两边只要出现了String，就会把其他的字符都变成String类型。

1
2
3
4
int a = 20;
int b = 30;
System.out.println(a + b + ""); // 输出结果为：50
System.out.println("" + a + b); // 输出结果为：2030

三元运算符

x ? y : z这就是一个三元运算符。运行方式为：如果x == ture ，那么结果就为y，否则结果就为z。

1
2
3
int score = 80;
String grades = score < 60 ? "不及格" : "及格";
System.out.println(grades); //输出结果为：及格

后记

在对照着视频把老师的知识点用博客这样的方式记录下来，这样不仅加深了这些知识的理解，同时也能更好的帮助我随时查阅。积少成多、聚沙成塔，只要坚持下来就没有什么搞不定的。

之后，我也会继续学习java，继续更新博客。分享知识、结交朋友，感谢你的观看！

参考链接

B站：狂神说java

菜鸟教程：java运算符

菜鸟教程：位运算

封面图来源：https://www.pixiv.net/artworks/89874712