Java基础语法

编程笔记 Java

注释

平时我们编写代码，在代码量比较少的时候，我们还可以看懂自己写了啥，但是当项目结构一旦复杂起来，我们就需要用到注释了。

注释并不会被执行，是给我们写代码的人看的。

书写注释是一个非常好的习惯！

Java中的注释有三种

单行注释（Line Comment）

// 这是一个单行注释

多行注释（Block Comment）

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

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

/*
 * 这是一个强迫症写的多行注释
 */

文档注释（Document）

/**
 * @Description 这是个带一些功能的文档注释
 * @Author 锁寒
 */

Java文档注释教程

标识符

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

命名规则

关于 Java 标识符，有以下几点需要注意：

所有的标识符都应该以字母（A-Z 或者 a-z）,美元符（$）、或者下划线（_）开始。
首字符之后可以是字母（A-Z 或者 a-z）,美元符（$）、下划线（_）或数字的任何字符组合。
关键字不能用作标识符。
标识符是大小写敏感的。
合法标识符举例：age、$salary、_value、__1_value。
非法标识符举例：123abc、-salary。
变量名最好是有意义的名字，这样更方便理解并提高阅读性。

关键字

关键字	含义
abstract	表明类或者成员方法具有抽象属性
assert	断言，用来进行程序调试
boolean	基本数据类型之一，声明布尔类型的关键字
break	提前跳出一个块
byte	基本数据类型之一，字节类型
case	用在switch语句之中，表示其中的一个分支
catch	用在异常处理中，用来捕捉异常
char	基本数据类型之一，字符类型
class	声明一个类
const	保留关键字，没有具体含义
continue	回到一个块的开始处
default	默认，例如，用在switch语句中，表明一个默认的分支。Java8 中也作用于声明接口函数的默认实现
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算术规范
super	表明当前对象的父类型的引用或者父类型的构造方法
switch	分支语句结构的引导词
synchronized	表明一段代码需要同步执行
this	指向当前实例对象的引用
throw	抛出一个异常
throws	声明在当前定义的成员方法中所有需要抛出的异常
transient	声明不用序列化的成员域
try	尝试一个可能抛出异常的程序块
void	声明当前成员方法没有返回值
volatile	表明两个或者多个变量必须同步地发生变化
while	用在循环结构中

Java关键字

特殊直接量	含义
false	布尔值的假
null	空值
true	布尔值的真

特殊直接量

数据类型

Java是一种强类型语言

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

弱类型语言

不太要求变量的使用严格符合规定，可以随意变更

Java的数据类型分为两大类

基本类型（primitive type）
引用类型（reference type）

以下材料来自菜鸟教程

基本类型

Java语言提供了八种基本类型。六种数字类型（四个整数型，两个浮点型），一种字符类型，还有一种布尔型。

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数
最小值是 -128（-2^7）
最大值是 127（2^7-1）
默认值是 0
byte 类型用在大型数组中节约空间，主要代替整数，因为 byte 变量占用的空间只有 int 类型的四分之一
例子：byte a = 100，byte b = -50。

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）
最大值是 32767（2^15 - 1）
Short 数据类型也可以像 byte 那样节省空间。一个short变量是int型变量所占空间的二分之一
默认值是 0
例子：short s = 1000，short r = -20000

int：

int 数据类型是32位、有符号的以二进制补码表示的整数
最小值是 -2,147,483,648（-2^31）
最大值是 2,147,483,647（2^31 - 1）
一般地整型变量默认为 int 类型
默认值是 0
例子：int a = 100000, int b = -200000。

long：

long 数据类型是 64 位、有符号的以二进制补码表示的整数
最小值是 -9,223,372,036,854,775,808（-2^63）
最大值是 9,223,372,036,854,775,807（2^63 -1）
这种类型主要使用在需要比较大整数的系统上
默认值是 0L
例子： long a = 100000L，long b = -200000L。
"L"理论上不分大小写，但是若写成"l"容易与数字"1"混淆，不容易分辩。所以最好大写。

float：

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数
float 在储存大型浮点数组的时候可节省内存空间
默认值是 0.0f
浮点数不能用来表示精确的值，如货币
例子：float f1 = 234.5f;

double：

double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数
浮点数的默认类型为 double 类型
double类型同样不能表示精确的值，如货币
默认值是 0.0d
例子：double d1 = 7D ; double d2 = 7.; double d3 = 8.0; double d4 = 8.D; double d5 = 12.9867; 7 是一个 int 字面量，而 7D，7. 和 8.0 是 double 字面量。

boolean：

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
这种类型只作为一种标志来记录 true/false 情况；
默认值是 false；
例子：boolean one = true;

char：

char 类型是一个单一的 16 位 Unicode 字符
最小值是 \u0000（十进制等效值为 0）
最大值是 \uffff（即为 65535）
char 数据类型可以储存任何字符
例子：char letter = 'A';

引用类型

在Java中，引用类型的变量非常类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量。这些变量在声明时被指定为一个特定的类型，比如 Employee、Puppy 等。变量一旦声明后，类型就不能被改变了。
对象、数组、类和接口都是引用数据类型。
所有引用类型的默认值都是null。
一个引用变量可以用来引用任何与之兼容的类型。
例子：Site site = new Site("Frostlock");

整数拓展

二进制：0b开头

十进制：正常写

八进制：0开头

十六进制：0x开头

浮点数拓展

有float、double。

浮点运算会有精度问题，这个问题可能会导致出现严重问题。

浮点数会有误差，整体是离散的，有的时候接近但是不等于。

最好不要用浮点数进行比较。

如需要进行实数比较，可以使用BigDecimal类。

字符拓展

所有的字符本质还是数字。

char a = "A";
System.out.println((int)a); // (int)为强制类型转换

以上代码会输出56.

编码Unicode：占用2字节，会有0-65536个，当然现在可以更多。具体可以查看Unicode表。

其他编码：可以自己搜下。

转义字符：一种特殊的字符，会转换成特殊的不好打出的字符，如：\n换行、\t制表符。具体可以在网上搜索。

字符串：懒得写了，以后补充。

布尔值拓展

用来表示真、假。

boolean flag = true;
if (flag == true) {} //比较繁琐
if (flag) {} //相对简洁
// 以上两个if表达效果相同

什么是字节

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

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

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

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

类型转换

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

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

强制转换

可以由高转低。

最简单的强制类型转换如下：

int i = 128;
byte b = (byte)i; // 强制转换i的类型为byte
// 注意以上会有个问题，当i转换为byte的时候会出现内存溢出，b的值会出错。

自动转换

当由低转高的时候不需要额外操作，系统会自己转换。

int i = 128;
long l = i;
System.out.println(l);
// 会输出128，没有任何报错。

注意点

不能对布尔值进行转换。
不能把对象转换为不相干的类型。
在把高容量转换为低容量时要强制转换。
转换的时候可能会出现内存溢出。
自动转换时并不会先自动转换运算时的类型，如果运算时溢出结果同样错误，推荐在运算时先强制转换。

Tip：自从JDK7以后用户可以通过下划线“_”来分割数字方便阅读。如：100_000_000

变量

变量是什么：就是可以变化的量。

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

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

type varName [=value] [{, varName[=value]}];
// 数据类型 变量名 = 值; 可以使用逗号来生命多个同类型变量。

变量作用域

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

类变量（静态变量）

类变量也称为静态变量，在类中以 static 关键字声明，但必须在方法之外。
无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。
静态变量除了被声明为常量外很少使用，静态变量是指声明为 public/private，final 和 static 类型的变量。静态变量初始化后不可改变。
静态变量储存在静态存储区。经常被声明为常量，很少单独使用 static 声明变量。
静态变量在第一次被访问时创建，在程序结束时销毁。
与实例变量具有相似的可见性。但为了对类的使用者可见，大多数静态变量声明为 public 类型。
默认值和实例变量相似。数值型变量默认值是 0，布尔型默认值是 false，引用类型默认值是 null。变量的值可以在声明的时候指定，也可以在构造方法中指定。此外，静态变量还可以在静态语句块中初始化。
静态变量可以通过：ClassName.VariableName的方式访问。
类变量被声明为 public static final 类型时，类变量名称一般建议使用大写字母。如果静态变量不是 public 和 final 类型，其命名方式与实例变量以及局部变量的命名方式一致。

实例变量

实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObjectReference.VariableName。

Java 局部变量

局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。

常量

常量（Constant）：在Java语言中,用关键字final来定义一个常量。常量一旦被初始化后不能再更改。

在定义常量时，需要注意如下内容：

在定义常量时就需要对该常量进行初始化。
final 关键字不仅可以用来修饰基本数据类型的常量，还可以用来修饰对象的引用或者方法。
为了与变量区别，常量取名一般都用大写字符。

Java 语言使用 final 关键字来定义一个常量，其语法如下所示：

final dataType variableName = value;

// 常量演示
public class HelloWorld {
    // 静态常量
    public static final double PI = 3.14;
    // 声明成员常量
    final int y = 10;
    public static void main(String[] args) {
        // 声明局部常量
        final double x = 3.3;
    }
}

命名规范

所有变量、方法、类名：见名知意。
类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词意外，后面的单词字母大写。
局部变量：同上
常量：大写字母和下划线
类名：单词首字母大写
方法名：和类成员变量相同

运算符

Java语言支持如下运算符

算术运算符：+、-、*、/、%、++、--
赋值运算符：=
关系运算符：>、<、>=、<=、==、!=、instanceof
逻辑运算符：&&（与）、||（或）、!（非）
位运算符：&、|、^、~、>>、<<、>>>（无符号右移，挺不常见）
条件运算符：?:
扩展赋值运算符：+=、-=、*=、/=

算术运算实例

public class Operator {
   public static void main(String[] args) {
      int a = 10;
      int b = 20;
      int c = 25;
      int d = 25;
      System.out.println("a + b = " + (a + b) );
      System.out.println("a - b = " + (a - b) );
      System.out.println("a * b = " + (a * b) );
      System.out.println("b / a = " + (b / a) );
      System.out.println("b % a = " + (b % a) );
      System.out.println("c % a = " + (c % a) );
      System.out.println("a++   = " +  (a++) );
      System.out.println("a--   = " +  (a--) );
      // 查看  d++ 与 ++d 的不同
      System.out.println("d++   = " +  (d++) );
      System.out.println("++d   = " +  (++d) );
   }
}
/*
   输出结果
   a + b = 30
   a - b = -10
   a * b = 200
   b / a = 2
   b % a = 0
   c % a = 5
   a++   = 10
   a--   = 11
   d++   = 25
   ++d   = 27
*/

关系运算实例

public class Operator {
   public static void main(String[] args) {
      int a = 10;
      int b = 20;
      System.out.println("a == b = " + (a == b) );
      System.out.println("a != b = " + (a != b) );
      System.out.println("a > b = " + (a > b) );
      System.out.println("a < b = " + (a < b) );
      System.out.println("b >= a = " + (b >= a) );
      System.out.println("b <= a = " + (b <= a) );
   }
}
/*
   以上实例编译运行结果如下：
   a == b = false
   a != b = true
   a > b = false
   a < b = true
   b >= a = true
   b <= a = false
*/

位运算符实例

public class Operator {
   public static void main(String[] args) {
      int a = 60; /* 60 = 0011 1100 */ 
      int b = 13; /* 13 = 0000 1101 */
      int c = 0;
      c = a & b;       /* 12 = 0000 1100 */
      System.out.println("a & b = " + c );
 
      c = a | b;       /* 61 = 0011 1101 */
      System.out.println("a | b = " + c );
 
      c = a ^ b;       /* 49 = 0011 0001 */
      System.out.println("a ^ b = " + c );
 
      c = ~a;          /*-61 = 1100 0011 */
      System.out.println("~a = " + c );
 
      c = a << 2;     /* 240 = 1111 0000 */
      System.out.println("a << 2 = " + c );
 
      c = a >> 2;     /* 15 = 1111 */
      System.out.println("a >> 2  = " + c );
  
      c = a >>> 2;     /* 15 = 0000 1111 */
      System.out.println("a >>> 2 = " + c );
   }
} 

/*
   以上实例编译运行结果如下：
   a & b = 12
   a | b = 61
   a ^ b = 49
   ~a = -61
   a << 2 = 240
   a >> 2  = 15
   a >>> 2 = 15
*/

逻辑运算实例

public class Operator {
   public static void main(String[] args) {
      boolean a = true;
      boolean b = false;
      System.out.println("a && b = " + (a&&b));
      System.out.println("a || b = " + (a||b) );
      System.out.println("!(a && b) = " + !(a && b));
   }
}

/*
   以上实例编译运行结果如下：
   a && b = false
   a || b = true
   !(a && b) = true
*/

赋值运算实例

public class Operator {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = 0;
        c = a + b;
        System.out.println("c = a + b = " + c );
        c += a ;
        System.out.println("c += a  = " + c );
        c -= a ;
        System.out.println("c -= a = " + c );
        c *= a ;
        System.out.println("c *= a = " + c );
        a = 10;
        c = 15;
        c /= a ;
        System.out.println("c /= a = " + c );
        a = 10;
        c = 15;
        c %= a ;
        System.out.println("c %= a  = " + c );
        c <<= 2 ;
        System.out.println("c <<= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c >>= 2 ;
        System.out.println("c >>= 2 = " + c );
        c &= a ;
        System.out.println("c &= a  = " + c );
        c ^= a ;
        System.out.println("c ^= a   = " + c );
        c |= a ;
        System.out.println("c |= a   = " + c );
    }
}

/*
   以上实例编译运行结果如下：
   c = a + b = 30
   c += a  = 40
   c -= a = 30
   c *= a = 300
   c /= a = 1
   c %= a  = 5
   c <<= 2 = 20
   c >>= 2 = 5
   c >>= 2 = 1
   c &= a  = 0
   c ^= a   = 10
   c |= a   = 10
*/

条件运算（三元运算符）符实例

public class Operator {
    public static void main(String[] args){
       int a , b;
       a = 10;
       // 如果 a 等于 1 成立，则设置 b 为 20，否则为 30
       b = (a == 1) ? 20 : 30;
       System.out.println( "Value of b is : " +  b );
 
       // 如果 a 等于 10 成立，则设置 b 为 20，否则为 30
       b = (a == 10) ? 20 : 30;
       System.out.println( "Value of b is : " + b );
    }
}

/*
   以上实例编译运行结果如下：
   Value of b is : 30
   Value of b is : 20
*/

自增自减运算符

自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算。

实例：

public class selfAddMinus{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        int b = 5;
        int x = 2*++a;
        int y = 2*b++;
        System.out.println("自增运算符前缀运算后a="+a+",x="+x);
        System.out.println("自增运算符后缀运算后b="+b+",y="+y);
    }
}

/*
    自增运算符前缀运算后a=6，x=12
    自增运算符后缀运算后b=6，y=10
*/

短路逻辑运算符

当使用与逻辑运算符时，在两个操作数都为true时，结果才为true，但是当得到第一个操作为false时，其结果就必定是false，这时候就不会再判断第二个操作了。

实例：

public class LuoJi{
    public static void main(String[] args){
        int a = 5;//定义一个变量；
        boolean b = (a<4)&&(a++<10);
        System.out.println("使用短路逻辑运算符的结果为"+b);
        System.out.println("a的结果为"+a);
    }
}

/*
    使用短路逻辑运算符的结果为false
    a的结果为5
*/

包机制

包的作用

1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

package pkg1[．pkg2[．pkg3…]];

一般利用公司的域名作为包名。

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

推荐搜索阿里巴巴开发手册。

创建包

创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。

包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。

如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。

import 关键字

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

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

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

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

注意：

类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。

JavaDoc

详情请查看：Java文档注释教程

可以通过 -encoding UTF-8 -charset UTF-8 来显示加载中文。

如果觉得文章对你有用，请随意赞赏

Java

Java基础语法

https://frostlock.cn/archives/javaji-chu-yu-fa

作者

EDNC_锁寒大帝

发布于

2022-08-22

更新于

2024-10-27

许可协议

CC BY 4.0

Java基础语法

注释

标识符

命名规则

关键字

数据类型

基本类型

引用类型

整数拓展

浮点数拓展

字符拓展

布尔值拓展

什么是字节

类型转换

强制转换

自动转换

注意点

变量

变量作用域

类变量（静态变量）

实例变量

Java 局部变量

常量

命名规范

运算符

Java语言支持如下运算符

算术运算实例

关系运算实例

位运算符实例

逻辑运算实例

赋值运算实例

条件运算（三元运算符）符实例

自增自减运算符

短路逻辑运算符

包机制

包的作用

创建包

import 关键字

JavaDoc

作者

发布于

更新于

许可协议

评论