[JavaSE] 01 基础语法

由于作者以前学过C语言和C++的一些基本语法，所以学习Java时打算快速跟着视频刷一遍基本语法，再去仔细地阅读书籍去复习、巩固和提高。本篇博客就是看视频时做的一些简单笔记。

入门

JDK、JRE、JVM

JDK：Java Development Kit
JRE：Java Runtime Environment
JVM：Java Virtual Machine

第一个程序——HelloWorld

class HelloChina{
	public static void main(String[] args){
		System.out.println("HelloWorld!");
	}
}

1. 将JAVA代码编写到扩展名为.java的文件中
2. 通过javac命令对该java文件进行编译
3. 通过java命令对生成的class文件进行运行

  源文件           字节码文件

字节码文件的文件名是类名

javac HelloWorld.java //编译
java HelloChina //运行

IDE 集成开发环境

IDEA下载链接

---

基础语法

注释

Java中的注释类型：

• 单行注释  //这是个单行注释
• 多行注释  /* 这是个多行注释*/
• 文档注释（Java特有）

单行注释和多行注释的作用：对程序进行解释说明，增强可读性；可以调试所写的代码。
注释了的内容不参与编译。编译后生成的字节码文件中不包含注释掉的信息。

多行注释不可用嵌套使用

标识符

关键字

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

标识符

类名、变量名以及方法名都被称为标识符。

• 所有的标识符都应该以字母、美元符（$）或者下划线（_）开始
• 首字母之后可以是字母、美元符、下划线或者数字的任意组合
• 不能使用关键字作为变量名或方法名
• 标识符是大小写敏感的
• 合法标识符举例：age,$salary,_value,_1_value
  -非法标识符举例：123abc,-salary,#abc

数据类型

Java是强类型语言，要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用。
Java的数据类型分为两大类：基本类型和引用类型

基本数据类型（primitive type）

整数类型

• byte   占1个字节（8位）
• short  占2个字节（16位）
• int    占4个字节（32位）
• long   占8个字节（64位)

浮点类型

• float    占4个字节（32位）
• double   占8个字节（64位）

字符类型
char     占2个字节（16位）

boolean类型：占1位 其值只有true和false两个

引用类型（reference type）

类、接口、数组

一些扩展

进制

public class Hello {
    public static void main(String[] args) {
        //System.out.println("Hello,World!");
        int a=10;//十进制
        int b=010;//八进制
        int c=0x10;//十六进制
        System.out.println(a);	//10
        System.out.println(b);	//8
        System.out.println(c);	//16
    }
}

浮点数的一些问题

public class Float_problem {
    public static void main(String[] args) {
        float f=0.1f;
        double d=1.0/10;
        System.out.println(f==d);	//false
        System.out.println(f);		//0.1
        System.out.println(d);		//0.1
        
		float d1=23131312312312313f;
        double d2=d1+1;
        System.out.println(d1==d2); //true
        System.out.println(d1);		//2.3131313E16
        System.out.println(d2);		//2.3131313024270336E16
        //下面这个例子在CSAPP中也被使用过
		double a1=(1e20+(-1e20))+3.14;
        double a2=1e20+(-1e20+3.14);
        System.out.println(a1);		//3.14
        System.out.println(a2);		//0.0
    }
}

我们可以看到浮点数运算存在一些问题，这是因为我们用有限的位表示无限的数，但这些问题还是超出了我们的预期。
所以我们最好避免使用浮点数进行比较。

如果我们需要表示一些银行业务，那我们最好使用BigDecimal的数学工具类来进行。

字符和编码

public class Encoding {
    public static void main(String[] args) {
        char c1='a';
        char c2='A';
        System.out.println(c1);	//a
        System.out.println(c2);	//A
        //强制类型转换
        System.out.println((int)c1);    //97
        System.out.println((int)c2);	//65
        char c3='中';
        System.out.println(c3);			//中
        System.out.println((int)c3);	//20013
    }
}

我们看到一个字符可以用数字来表示，其背后涉及到了编码的相关知识。

在IDEA的左上角，File->Settings->File Encodings里可以设置编码的有关操作。

转义字符

\t：制表符
\n：换行

类型转换

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

强制转换

public class Change {
    public static void main(String[] args) {
        byte a=15;
        int b=(int)a;
        System.out.println(a);	//15
        System.out.println(b);	//15
		//下面是一个溢出的例子
        int c=128;
        byte d=(byte)c;
        System.out.println(c);	//128
        System.out.println(d);	//-128
    }
}

从高到低需要强制类型转换。

自动转换

public class Change {
    public static void main(String[] args) {
        byte a=15;
        int b=a;
        System.out.println(a);	//15
        System.out.println(b);	//15

        int c=128;
        double d=c;
        System.out.println(c);	//128
        System.out.println(d);	//128.0
    }
}

从低到高不需要加任何东西就能完成自动转换。
注意点：

1. 不能对布尔值进行转换
2. 不能把对象类型转换成不相干的类型
3. 在把高容量转换成低容量的时候需要强制转换
4. 转换的时候可能存在内存溢出，或者精度丢失等问题

//精度丢失
System.out.println((int)23.7);	//23
System.out.println((int)-45.89f);//-45

//操作比较大的数时，要注意溢出问题
//JDK7的特性，数字之间可以用下划线分割
public class Num1 {
    public static void main(String[] args) {
        int money=10_0000_0000;
        int years=20;
        int total=money*years;
        System.out.println(total);	//-1474836480
        long total2=money*years;	//默认是int，转换前已经出问题了
        System.out.println(total2);	//-1474836480
        long total3=(long)money*(long)years;
        System.out.println(total3);	//20000000000
        long total4=(long)money*years;
        System.out.println(total4);	//20000000000
    }
}

变量

Java是一种强类型语言，每个变量都必须声明其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和 作用域
注意事项：

• 每个变量都有类型，类型可以是基本类型，也可以是引用类型
• 变量名必须是合法的标识符
• 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

变量的几个类型

Java的变量类型有：

• 类变量：独立于方法之外的变量，用 static 修饰
• 实例变量：独立于方法之外的变量，不过没有 static 修饰
• 局部变量：类的方法中的变量

public class Demo {
    //类变量
    static double salary=2500;
    //实例变量
    String str="Hello,world!";
    public static void main(String[] args) {
        //局部变量
        int i=10;
        System.out.println(i);	//10

        Demo demo=new Demo();
        System.out.println(demo.str);	//Hello,world!

        System.out.println(salary); 	//2500.0
    }
}

详情请参考菜鸟教程

常量

常量：初始化后不能再改变的值。
常量的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值;
final double PI=3.14;

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

public class Demo {
	//修饰符不存在先后顺序
    static final double PI=3.14;
    final static double E=2.7;
    public static void main(String[] args) {
        System.out.println(PI);	//3.14
        System.out.println(E);	//2.7
    }
}

变量的命名规范

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和小驼峰原则 monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线 MAX_VALUE
• 类名：首字母大写和大驼峰原则 Man,GoodMan
• 方法名：首字母小写和小驼峰原则 run(),runRun()

运算符

这部分和C语言没差多少，懒得敲了，直接丢链接

一些细节

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

如果有long/double，操作后就是long/double类型。
如果没有long，结果都为int类型。

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

Java中幂运算借助Math类实现

public class Demo {
    public static void main(String[] args) {
        int a=10;
        int b=20;
        System.out.println(a+b);	//30
        System.out.println(""+a+b);	//1020
        System.out.println(a+b+"");	//30
    }
}

在+运算符两侧，只要有一侧是String类型，就会把其他操作数都转换成String进行拼接。
在下面的图片中我们可以看到，虽然a+b+""的结果是30，但其类型还是String

包机制

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

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

一般利用公司域名倒置作为包名
www.baidu.com就是com.baidu.www

对src文件夹右键，New->Package，点击Package建立包

点击齿轮，找到Compact Middle Packages，将其取消勾选即可显示出三个文件夹

将任意一个java源文件拖拽至baidu文件夹下，源文件顶部将会出现

package com.baidu;

按住Ctrl+Alt后，鼠标单击String，可以进入String.java

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

import package1[.package2...].(classname|*);
//*会将包内的所有的类都导入进来

注意：import必须在package的下面

JavaDoc

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

参数信息

• @author 作者名
• @version 版本号
• @since 指明需要最早使用的jdk版本
• @param 参数名
• @return 返回值情况
• @throws 异常抛出情况

package com.baidu;

/**
 * @author z
 * @version 1.0
 * @since 1.8
 *
 */
public class Doc {
    String name;

    /**
     *
     * @param name
     * @return
     */
     
    /**
     *
     * @param name
     * @return
     * @throws Exception
     */
    public String test(String name) throws Exception{
        return name;
    }
}

命令行生成文档：

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

IDEA生成文档：
点击最上方Tools->Generate JavaDoc

点击ok后自动跳转下图页面