Java入门学习记录之基础语法

Java入门学习记录（二）

1 注释(comments)

在项目结构较复杂的前提下，为了方便代码的可阅读性，我们需要用到注释。

注释不会执行，只用来解释代码，提高代码的阅读性。

Java的注释分为三种，分别是

• 单行注释 使用//来注释，只能注释一行内容，IDEA中快捷键为Ctrl + /

  // 这是一个单行注释
  

• 多行注释 使用/* */来注释，注释多行内容，用在代码块的开头和结尾，IDEA中快捷键为Ctrl +Shift+ /

  /* 这是一个多行注释 */
  

• 文档注释（也称类注释）输入/** ,点击Enter，自动根据参数和返回值生成注释模板。在IDEA中的配置可以参考这位大佬的讲解——传送门

2 标识符和关键字

关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，布尔类型
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支
do	用在do-while循环结构中
double	基本数据类型之一，双精度浮点数类型
else	用在条件语句中，表明当条件不成立时的分支
enum	枚举
extends	表明一个类型是另一个类型的子类型，这里常见的类型有类和接口
final	用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变，用来定义常量
finally	用于处理异常情况，用来声明一个基本肯定会被执行到的语句块
float	基本数据类型之一，单精度浮点数类型
for	一种循环结构的引导词
goto	保留关键字，没有具体含义
if	条件语句的引导词
implements	表明一个类实现了给定的接口
import	表明要访问指定的类或包
instanceof	用来测试一个对象是否是指定类型的实例对象
int	基本数据类型之一，整数类型
interface	接口
long	基本数据类型之一，长整数类型
native	用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的
new	用来创建新实例对象
package	包
private	一种访问控制方式：私用模式
protected	一种访问控制方式：保护模式
public	一种访问控制方式：共用模式
return	从成员方法中返回数据
short	基本数据类型之一,短整数类型
static	表明具有静态属性
strictfp	用来声明FP_strict（单精度或双精度浮点数）表达式遵循[IEEE 754](https://baike.baidu.com/item/IEEE 754)算术规范 [1]
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

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

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

3 数据类型

强类型语言(Java, C++, ···)

要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

Java的数据类型分为两大类

• 基本类型 ( primitive type )

• 引用类型 ( reference type )

八大基本数据类型的示例如下

public class Demo {
	public static void main(String[] args) {
	// 八大基本数据类型
	
    // 整数
	int   num1 = 10;  // 最常用
	byte  num2 = 20;
    short num3 = 30;
	long  num4 = 30L; // Long类型要在数字后面加个L

	// 小数:浮点数
	float  num5 = 50.1F; // Lfloat类型要在数字后面加个F
	double num6 = 3.141592653589793238462643;

	// 字符
	char name ='A';
	// 字符串, String不是关键字, 类
	// String name = "User";

	//布尔值:是非
	boolean flag = true;
	// boolean flag = false;
	}
}

关于引用数据类型在之后的学习中再逐步说明

4 类型转换

• 由于Java是强类型语言，所以要进行有些运算时，需要类型转换
• 运算中，不同类型的数据先转换为相同的类型，然后再运算。

强制转换

如下代码，若byte b = (byte)i;写成byte b = i;则会发生错误，因为数据类型不同。下方为一个演示，因为byte类型最大为127，赋值128发生内存溢出导致输出-128，所以使用时也应当注意各数据类型所占空间大小。

public class Demo {
    public static void main(String[] args) {
        int  i = 128;
        byte b = (byte)i; // 内存溢出
        System.out.println(i); //  128
        System.out.println(b); // -128
    }
}

不能对布尔值转换

不能把对象类型转换为不相干类型

把高容量转换低容量时，强制转换

转换时需注意内存溢出和精度问题

再弄一个比较经典的例子

public class Demo {
    public static void main(String[] args) {
        int  a = 10_0000_0000; // 在JDK7之后数字之间可以使用_分割，看起来更直观
        byte b = 20; // 内存溢出
        in    total = a * b;   // -1474836480 产生内存溢出
        long total1 = a * b;   // 因为右侧先是int计算，在转换之前已经产生了内存溢出，仍然输出错误
        long total2 = a * ((long)b); // 先转换一个值，数据类型在计算中就会转换，正常
        System.out.println(tota);  // 错误结果
        System.out.println(total); // 错误结果
        System.out.println(tota2); // 正确结果
    }
}

5 变量、常量、作用域

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

type varName  [=value] [{, varName[=value]}];

每个变量都有类型，类型可以是基本类型，也可以是引用类型

变量名必须为合法标识符

变量声明是一条完整的语句，因此每一个声明都必须以分号结束

变量作用域

• 类变量 关键词static ，从属类
• 实例变量
• 局部变量

public class Variable {
    static int a = 0; // 类变量
    String str = "hello"; // 实例变量, 从属于对象，不初始化基本类型默认0，其他null
    public void method() {
        int i = 0; // 局部变量, 必须声明和初始化
    }
}

常量

初始化之后不会再改变的值，程序运行中不会改变

一般常量名为大写字符，使用关键字final

final 常量名 = 常量值

6 基本运算符

Java语言支持如下运算符

• 算术运算符: +, -, *, /, %, ++, –
• 赋值运算符: =
• 关系运算符: >, <, >=, <=, ==, != instanceof
• 逻辑运算符: &&, ||, !
• 位运算符: &, |, ^, ~, >>, <<, >>>
• 条件运算符: ?, :
• 扩展赋值运算符: +=, -=, *=, /=

public class Demo {
    public static void main(String[] args) {
    long  a = 123123123;
    int   b = 123;
    short c = 10;
    byte  d = 8;
    System.out.println(a+b+c+d); // Output is Long
    System.out.println(b+c+d); // Output is Int
    System.out.println(c+d); // Output is Int
    }
}

在操作数为整数运算时，有long类型结果会转换为long类型，没有的话为int类型，同理double类型也有这样的结果

自增自减运算符( ++, – )

有C语言基础的相信都不陌生，也就是a++相当于a = a + 1，主要区别在于

输出 a++ 的值仍然为a的值，本身虽然值不变，但在之后执行加一操作，而++a要先执行加一，则++a的输出值等于a+1，相当于一个先后赋值的问题

有个有趣的例子，如下

public class Demo {
    public static void main(String[] args) {
    int a = 3;
    int b = a++; // 这句话相当于先给b赋值，b = a, 之后再执行 +1
    System.out.println(a); // Output is 4
    int c = ++a; // 这句话相当于先执行 +1，之后再给 c 赋值
    System.out.println(a); // Output is 5
    System.out.println(b); // Output is 3
    System.out.println(c); // Output is 5
    }
}

逻辑运算符、位运算符

两个操作数相与，只要有一个为false，则结果为false，真与真为真；

两个操作数相或，只要有一个为true，则结果为true，假或假为假。

这里也有一个有趣的例子，嘿嘿

public class Demo {
    public static void main(String[] args) {
    int c = 5;
    boolean d = (c<4)&&(++c>4);   
    System.out.println(d); // Output is false
    System.out.println(c); // Output is 5 // c 的值不改变因为刚开始(c<4)已经为false，与运算后面											   就不再执行了
    }
}

关于位运算，还是例子更加直接

    /*
      A = 0011 1100
      B = 0000 1101 
    
    A&B = 0000 1100
    A|B = 0011 1101
    A^B = 0011 0001
     ~B = 1111 0010
     关于移位 >> <<
     在二进制中移位，如2 * 8 = 16
     0000 0010    2
     0001 0000   16
     System.out.println(2<<3); // 2左移3位
    */

7 包机制、JavaDoc

为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。

包语句的语法格式为：

package pkg1[. pkg2[. pkg3...]];

为了能够使用某一个包的成员，需要在Java程序中明确导入该包。使用import语句可完成此功能。

import package1[.package2...].(classname|*);

看到这里是不是有点似曾相识呢，有些类似python，包相当于一个文件夹，可以防止名称相同但功能不同的类的冲突。

• 在使用包内的类时，需要在前导入包

关于详细的包命名规范以及导入规则，可以参考一下《阿里巴巴Java开发手册》

JavaDoc

javadoc命令是用来生成自己API文档的

可以在cmd中使用此命令，对于在IDEA中生成，网上搜索即可，可以随便参考一下——传送门

javadoc -encoding UTF-8 -charset UTF-8 yourDocname.java

对于Java的学习，官方提供了一个超级强大详细的文档，参考Java官方的帮助文档

待学习更新··· 因为初学，希望看到的大佬对于其中错误指正一番哈，感谢！