Java基础学习笔记

一 注释

Java中的注释有三种：

• 单行注释：//
• 多行注释：/* */
• 文档注释：/** */

二 标识符

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

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

三 数据类型

什么是字节

• 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数

• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示

• 1B（byte,字节） = 8bit（位）

• 字符：是指计算机中使用的字母、数字、字和符号

• 1bit表示1位

• 1Byte表示一个字节 1B = 8b

• 1024B = 1KB

• 1024KB = 1M

• 1024M = 1G

强类型语言

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

Java的数据类型分为两大类

基本类型（primitive type）

基本类型	大小	最小值	最大值	包装类型
boolean	—	—	—	Boolean
char	16 bits	Unicode 0	Unicode 216 -1	Character
byte	8 bits	-128	+127	Byte
short	16 bits	- 215	+ 215 -1	Short
int	32 bits	- 231	+ 231 -1	Integer
long	64 bits	- 263	+ 263 -1	Long
float	32 bits	IEEE754	IEEE754	Float
double	64 bits	IEEE754	IEEE754	Double
void	—	—	—	Void

一 数值类型

1.整数类型

byte占1个字节范围：-128~127

short占2个字节范围：-32768~32767

int占4个字节范围：-2147483648~2147483647

long占8个字节范围：-9223372036854775808~9223372036854775807

2.浮点类型

float占4个字节

double占8个字节

在文本值的后面添加字符可以让编译器识别该文本值的类型。对于 Long 型数值，结尾使用大写 L 或小写 l 皆可（不推荐使用 l，因为容易与阿拉伯数值 1 混淆）。大写 F 或小写 f 表示 float 浮点数。大写 D 或小写 d 表示 double 双精度。

3.字符类型

char占2个字节

二 boolean类型

占1位其值只有true和false两个

引用类型（reference type）

类

接口

数组

类型转换

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

低 ------------------------------------------> 高
byte，short,char -> int -> long ->float -> double

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

强制类型转换：高 --> 低 （类型）变量名

自动类型转换：低 --> 高

注意：

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

四 变量

• 变量是什么：就是可以变化的量！

• Java是一种强类型语言，每个变量都必须声明其类型。

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

  type varName [=value] [{,varName[=value]}];
  //数据类型 变量名 = 值； 可以使用逗号隔开来声明多个同类型变量     
  

• 注意事项：

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

​ 变量名必须是合法的标识符。

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

变量初始化

• 类变量
• 实例变量: 从属于对象；类的每个基本类型数据成员保证都会有一个初始值。

public class InitialValues {
    boolean t;
    char c;
    byte b;
    short s;
    int i;
    long l;
    float f;
    double d;
    InitialValues reference;

    void printInitialValues() {
        System.out.println("Data type Initial value");
        System.out.println("boolean " + t);
        System.out.println("char[" + c + "]");
        System.out.println("byte " + b);
        System.out.println("short " + s);
        System.out.println("int " + i);
        System.out.println("long " + l);
        System.out.println("float " + f);
        System.out.println("double " + d);
        System.out.println("reference " + reference);
    }

    public static void main(String[] args) {
        new InitialValues().printInitialValues();
    }
}

输出：

Data type Initial value
boolean false
char[NUL]
byte 0
short 0
int 0
long 0
float 0.0
double 0.0
reference null

可见尽管数据成员的初值没有给出，但它们确实有初值（char 值为 0，所以显示为空白）。所以这样至少不会出现"未初始化变量"的风险了。

在类里定义一个对象引用时，如果不将其初始化，那么引用就会被赋值为 null。

• 局部变量：必须声明和初始化值

public class Variable {
	static int allClicks = 0;           // 类变量
	String str = "Hello world";			// 实例变量
	
	public void method() {
		int i = 0;                      // 局部变量
	}
}

常量

• 常量（Constant）:初始化（initialize）后不能再改变值！不会变动的值。
• 所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

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

• 常量值一般使用大写字符。

变量的命名规范

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary,除了第一个单词以外，后面的单词首字母大写
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man,GoodMan
• 方法名：首字母小写和驼峰原则：run(),runRun()

五 运算符

递增和递减

每种类型的运算符，都有两个版本可供选用；通常将其称为“前缀”和“后缀”。“前递增”表示 ++ 运算符位于变量或表达式的前面；而“后递增”表示 ++ 运算符位于变量的后面。类似地，“前递减”意味着 -- 运算符位于变量的前面；而“后递减”意味着 -- 运算符位于变量的后面。对于前递增和前递减（如 ++a 或 --a），会先执行递增/减运算，再返回值。而对于后递增和后递减（如 a++ 或 a--），会先返回值，再执行递增/减运算。代码示例：

public class AutoInc {
    public static void main(String[] args) {
        int i = 1;
        System.out.println("i: " + i);
        System.out.println("++i: " + ++i); // 前递增
        System.out.println("i++: " + i++); // 后递增
        System.out.println("i: " + i);
        System.out.println("--i: " + --i); // 前递减
        System.out.println("i--: " + i--); // 后递减
        System.out.println("i: " + i);
    }
}

输出结果：

i: 1
++i: 2
i++: 2
i: 3
--i: 2
i--: 2
i: 1

对于前缀形式，我们将在执行递增/减操作后获取值；使用后缀形式，我们将在执行递增/减操作之前获取值。它们是唯一具有“副作用”的运算符（除那些涉及赋值的以外） —— 它们修改了操作数的值。

逻辑运算符

逻辑运算符&& （AND）、||（OR）和 !（非）根据参数的逻辑关系生成布尔值 true 或 false。

import java.util.*;
public class Bool {
    public static void main(String[] args) {
        Random rand = new Random(47);
        int i = rand.nextInt(100);
        int j = rand.nextInt(100);
        System.out.println("i = " + i);
        System.out.println("j = " + j);
        System.out.println("i > j is " + (i > j));
        System.out.println("i < j is " + (i < j));
        System.out.println("i >= j is " + (i >= j));
        System.out.println("i <= j is " + (i <= j));
        System.out.println("i == j is " + (i == j));
        System.out.println("i != j is " + (i != j));
        // 将 int 作为布尔处理不是合法的 Java 写法
        //- System.out.println("i && j is " + (i && j));
        //- System.out.println("i || j is " + (i || j));
        //- System.out.println("!i is " + !i);
        System.out.println("(i < 10) && (j < 10) is "
        + ((i < 10) && (j < 10)) );
        System.out.println("(i < 10) || (j < 10) is "
        + ((i < 10) || (j < 10)) );
    }
}

输出结果：

i = 58
j = 55
i > j is true
i < j is false
i >= j is true
i <= j is false
i == j is false
i != j is true
(i < 10) && (j < 10) is false
(i < 10) || (j < 10) is false

短路

逻辑运算符支持一种称为“短路”（short-circuiting）的现象。整个表达式会在运算到可以明确结果时就停止并返回结果，这意味着该逻辑表达式的后半部分不会被执行到。代码示例：

public class ShortCircuit {

    static boolean test1(int val) {
        System.out.println("test1(" + val + ")");
        System.out.println("result: " + (val < 1));
        return val < 1;
    }

    static boolean test2(int val) {
        System.out.println("test2(" + val + ")");
        System.out.println("result: " + (val < 2));
        return val < 2;
    }

    static boolean test3(int val) {
        System.out.println("test3(" + val + ")");
        System.out.println("result: " + (val < 3));
        return val < 3;
    }

    public static void main(String[] args) {
        boolean b = test1(0) && test2(2) && test3(2);
        System.out.println("expression is " + b);
    }
}

输出结果：

test1(0)
result: true
test2(2)
result: false
expression is false

每个测试都对参数执行比较并返回 true 或 false。同时控制台也会在方法执行时打印他们的执行状态。 下面的表达式：

test1（0）&& test2（2）&& test3（2）

可能你的预期是程序会执行 3 个 test 方法并返回。我们来分析一下：第一个方法的结果返回 true，因此表达式会继续走下去。紧接着，第二个方法的返回结果是 false。这就代表这整个表达式的结果肯定为 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 0000            0
0000 0001            1
0000 0010            2
0000 0011            3
0000 0100            4
0000 1000            8
0001 0000            16
*/
System.out.println(2 << 3); // 16

字符串运算符

String +

一个空字符串 "" 跟着一个基本类型的数据。这样可以隐式地将其转换为字符串，以代替繁琐的显式调用方法。

int a = 10;
int b = 20;
System.out.println("" + a + b); // 1020
System.out.println(a + b + ""); // 30

三元运算符

布尔表达式 ? 值 1 : 值 2

若表达式计算为 true，则返回结果 值 1 ；如果表达式的计算为 false，则返回结果 值 2

六 包机制

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

package pkg[. pkg2[. pkg3...]];

• 一般利用公司域名倒置作为包名
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包，使用“import”语句可完成此功能

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

七 JavaDoc

• javadoc命令是用来生成自己API文档的
• 参数信息

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

遇到“ 'javadoc' 不是内部或外部命令，也不是可运行的程序 或批处理文件。”问题的解决方法。

当在cmd中键入java -version、javac都没有问题时，输入javadoc出现上面的提示时，只需将环境变量Path中的

.;%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin

修改为

%JAVA_HOME%\jre\bin
%JAVA_HOME%\bin

然后重启cmd窗口，执行javadoc，就ok了