【Java基础教程】特别篇：一图总结Java基础语法~

待我称王封你为后i 2023-09-27 22:06 224阅读 0赞

#### Java基础语法 ####

*  1️⃣ 注释
 *  2️⃣ 关键字
 *  3️⃣ 标识符
 *  4️⃣ 基本数据类型
 *  5️⃣ 运算符
 *   *  5.1 赋值运算符
     *  5.2 算术运算符
     *  5.3 比较\\关系运算符
     *  5.4 逻辑运算符
     *  5.5 位运算符
     *  5.6 三目运算符
     *  5.7 运算优先级
 *  6️⃣ 流程控制
 *  7️⃣ 引用数据类型
 *  8️⃣ 类与对象
 *  ✔️ 一图总结

## 1️⃣ 注释 ##

注释是对代码的一种解释，通过注释来添加对代码的说明解释性信息，***注释不参与程序的编译和运行***。Java中的注释分为：单行注释、多行注释和文档注释。

下面举例说明三种注释的使用方式：

/**
    * 1、这是一个文档注释
    * @Author xiaoshan
    * @version v1.0
    * @Date 2023-05-26 
    * 我定义了一个HelloWorld类
    */
    public class HelloWorld(){
        
    	// 2、这是一个单行注释。我定义了一个字符串静态变量 “Hello World!”
    	public static String str = "Hello World!";
    	
    	/* 3、这是一个多行注释。
     	* 我定义了一个main方法，在方法中打印了字符串
     	*/
    	public static void main(String args[]){
        
    		System.out.println(str);
    	}
    }

运行结果如下图：

![f923c21cbc0a482e9b2f6215ed442882.png][]

图1 注释演示程序的运行结果

--------------------

## 2️⃣ 关键字 ##

***关键字是对Java编译器有特殊含义的字符串\\英文词汇，是编译器和程序员的一个约定***，程序员利用关键字来告诉编译器其声明的变量类型、类、方法特性等信息。

关键字不能用作变量名、方法名、类名、包名和参数。  
截至目前Java中约定的一共有50个关键字，包括结构定义、数据类型定义、流程控制、异常处理、修饰符等各个方向的应用。

本节主要介绍修饰符关键字：

*  ***private*** 权限修饰符，表示私有的，修饰内部类、方法和属性，只在本类中可见
 *  ***default*** 权限修饰符，表示默认的，修饰类、方法和属性，可以在本类及同包中其他类访问
 *  ***protected*** 权限修饰符，表示受保护，修饰类、方法和属性，可以在本类、子类及同包中其他类访问
 *  ***public*** 权限修饰符，表示公共的，修饰类、方法和属性，可以在任意类中访问
 *  ***abstract*** 表示抽象的，修饰类、方法。不能与static、private或final 同用
 *  ***final*** 表示最终的，修饰类、方法及属性。不能与abstract 同用
 *  ***static*** 表示静态的，修饰类、方法及属性。不能与abstract 同用
 *  ***native*** 修饰方法，表示该方法是用Java以外的语言实现的
 *  ***void*** 修饰方法，表示该方法不返回任何值
 *  ***transient*** 修饰属性，表示在类实例序列化时，该属性不参与序列化
 *  ***synchronized*** 用于方法或语句块，表示在多线程中是同步的线程安全的
 *  ***volatile*** 修饰属性，保证了并发操作的可见性、有序性

<table> 
 <thead> 
  <tr> 
   <th>关键字</th> 
   <th>含义</th> 
   <th>用法</th> 
   <th>特征</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>private</td> 
   <td>私有的</td> 
   <td>修饰内部类、方法和属性</td> 
   <td>权限修饰符，只在本类中可见</td> 
  </tr> 
  <tr> 
   <td>default</td> 
   <td>默认的</td> 
   <td>修饰类、方法和属性</td> 
   <td>权限修饰符，可以在本类及同包中其他类访问，可以省略</td> 
  </tr> 
  <tr> 
   <td>protected</td> 
   <td>受保护的</td> 
   <td>修饰类、方法和属性</td> 
   <td>权限修饰符，可以在本类、子类及同包中其他类访问</td> 
  </tr> 
  <tr> 
   <td>public</td> 
   <td>公共的</td> 
   <td>修饰类、方法和属性</td> 
   <td>权限修饰符，可以在任意类中访问</td> 
  </tr> 
  <tr> 
   <td>abstract</td> 
   <td>抽象的</td> 
   <td>修饰类、方法</td> 
   <td>不能与static、private或final 同用</td> 
  </tr> 
  <tr> 
   <td>final</td> 
   <td>最终的</td> 
   <td>修饰类、方法和属性</td> 
   <td>不能与abstract 同用</td> 
  </tr> 
  <tr> 
   <td>static</td> 
   <td>静态的</td> 
   <td>修饰类、方法和属性</td> 
   <td>不能与abstract 同用</td> 
  </tr> 
  <tr> 
   <td>native</td> 
   <td>-</td> 
   <td>修饰方法</td> 
   <td>表示该方法是用Java以外的语言实现的</td> 
  </tr> 
  <tr> 
   <td>void</td> 
   <td>空的</td> 
   <td>修饰方法</td> 
   <td>表示该方法不返回任何值</td> 
  </tr> 
  <tr> 
   <td>transient</td> 
   <td>-</td> 
   <td>修饰属性</td> 
   <td>表示在类实例序列化时，该属性不参与序列化</td> 
  </tr> 
  <tr> 
   <td>synchronized</td> 
   <td>同步的</td> 
   <td>用于方法或语句块</td> 
   <td>表示在多线程中是同步的\线程安全的</td> 
  </tr> 
  <tr> 
   <td>volatile</td> 
   <td>-</td> 
   <td>修饰属性</td> 
   <td>保证了并发操作的可见性、有序性</td> 
  </tr> 
 </tbody> 
</table>

下面使用伪代码说明各个修饰符关键字的使用方式：

//一、关键字 private
    public class MyPublicClass{
        
    	private class PrivateClass{
        ...}
    	private int i;
    	private void method(){
        ...}
    }
    
    //二、关键字 default
    default class MyDefaultClass{
        
    	default int a;
    	default void method(){
        ...}
    }
    //default 关键字可以省略，于是以下代码和上面的代码一样：
    class MyDefaultClass{
        
    	int a;
    	void method(){
        ...}
    }
    
    //三、关键字 protected
    protected class MyProtectedClass{
        
    	protected int i;
    	protected void method(){
        ...}
    }
    
    //四、关键字 public
    public class MyPublicClass{
        
    	public int i;
    	public void method(){
        ...}
    }
    
    //五、关键字 abstract. 抽象的
    //定义抽象类. 抽象类只能通过其子实现类来实例化，实现类需要覆写抽象父类的所有抽象方法
    public abstract class AbstractClass{
        
    	//定义抽象方法. 抽象方法只有方法定义而没有具体逻辑，具体实现逻辑是交由子类处理的
    	public abstract void abstractMethod();
    }
    
    //六、关键字 final. 最终的
    //定义最终类. 最终类无法被继承，即无法拥有子类
    public final class FinalClass{
        
    	//定义最终变量. 最终变量是一个常亮，不可改变其值
    	public final int i = 0;
    	//定义最终方法. 最终方法无法被重写
    	public final void finalMethod();
    }
    
    //七、关键字 static. 静态的
    //定义静态类
    public static class StaticClass{
        
    	//定义静态变量. 静态变量可以直接通过类名调用
    	public static int i = 0;
    	//定义静态方法. 静态方法可以直接通过类名调用
    	public static void staticMethod(){
        ...}
    }
    
    //八、关键字 native. 修饰方法，表示该方法是用Java以外的语言实现的。
    //用native关键字修饰的方法没有方法体。它会进入本地方法栈，通过调用JNI接口实现对其他语言代码和代码库的使用。
    native void nativeMethod();
    
    //九、关键字 void. 修饰方法，表示该方法不返回任何值。
    void method();
    
    //十、关键字 transient. 修饰字段，表示在类实例序列化时，该字段不参与序列化
    public class MyClass{
        
    	private transient String filed;
    }
    
    //十一、关键字 synchronized. 应用于方法或语句块，表示在多线程时是同步的、线程安全的，保证了并发操作的原子性
    //同步方法
    public class MyClass{
        
    	public synchronized void mySyncMethod(){
        ...}
    }
    //同步代码块	
    public class MyClass{
        
    	Object obj;
    	public void method(){
        
    		...
    		synchronized(obj){
        ...}
    }
    
    //十二、关键字 volatile. 修饰字段，保证了并发操作的可见性、有序性
    public class MyClass{
        
    	volatile int sharedValue;
    }

--------------------

## 3️⃣ 标识符 ##

标识符主要是指变量名的定义，标识符的定义需要满足Java的一些规范：

**· *由字母、数字、\_、$ 组成*  
· *不能以数字开头*  
· *不能是Java中的关键字*  
· 大小写区分  
· 命名应尽量具有意义  
· 类名定义：每个单词的首字母应大写  
· 方法名与变量名定义：首个单词的首字母小写，其后每个单词的首字母应大写  
· 常量名定义：每个字母应大写，单词之间可用\_连接  
· 包名定义：每个字母应小写**

下面举例说明正确及错误的变量名称，以及类、方法、常量、包名的正确定义：

//正确的变量名
    int a = 1;
    //× 错误的变量名：不能以数字开头
    int 1a = 1;
    //× 错误的变量名：不能是Java中的关键字
    int private = 1;
    //× 错误的变量名：包含规则以外的字符 #
    int a#b = 1;
    
    //正确的类名
    public class Student{
        ...}
    //正确的方法名
    public Student getStudent(){
        ...}
    //正确的变量名
    private int age;
    //正确的常量名
    private int AGE = 18;
    //正确的包名
    package com.xiaoshan.service;

--------------------

## 4️⃣ 基本数据类型 ##

***Java里一共有8个基础数据类型，分为四类八种（整数、浮点数、字符、布尔）***：

*  ***byte*** 整型里的字节型，1个字节，可存储\[-128,127\]范围以内的整数值
 *  ***short*** 整型里的短整型，2个字节，可存储\[-32768,32767\]范围以内的整数值
 *  ***int*** 整型里的整型，4个字节，可存储\[-2^31, 2^32-1\]范围以内的整数值
 *  ***long*** 整型里的长整型，8个字节，可存储\[-2^63, 2^64-1\]范围以内的整数值
 *  ***float*** 浮点型里的单精度型，4个字节，可存储\[-2^31, 2^32-1\]范围以内的浮点数值
 *  ***double*** 浮点型里的双精度型，8个字节，可存储\[-2^63, 2^64-1\]范围以内的浮点数值
 *  ***char*** 字符型，2个字节，可存储一个Unicode字符
 *  ***boolean*** 布尔型，1个字节，可存储true或false

<table> 
 <thead> 
  <tr> 
   <th>基本数据类型</th> 
   <th>说明</th> 
   <th>占用空间</th> 
   <th>取值范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>byte</td> 
   <td>字节型</td> 
   <td>1 byte</td> 
   <td>-128~127</td> 
  </tr> 
  <tr> 
   <td>short</td> 
   <td>短整型</td> 
   <td>2 byte</td> 
   <td>-32768~32767</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>整型</td> 
   <td>4 byte</td> 
   <td>-2^31~ 2^32-1</td> 
  </tr> 
  <tr> 
   <td>long</td> 
   <td>长整型</td> 
   <td>8 byte</td> 
   <td>-2^63~ 2^64-1</td> 
  </tr> 
  <tr> 
   <td>float</td> 
   <td>单精度浮点型</td> 
   <td>4 byte</td> 
   <td>-2^31~ 2^32-1</td> 
  </tr> 
  <tr> 
   <td>double</td> 
   <td>双精度浮点型</td> 
   <td>8 byte</td> 
   <td>-2^63 ~ 2^64-1</td> 
  </tr> 
  <tr> 
   <td>char</td> 
   <td>字符型</td> 
   <td>2 byte</td> 
   <td>一个Unicode字符</td> 
  </tr> 
  <tr> 
   <td>boolean</td> 
   <td>布尔型</td> 
   <td>1 byte</td> 
   <td>true或false</td> 
  </tr> 
 </tbody> 
</table>

下面举例说明各个基础数据类型的定义方式：

//1、整型
    //定义byte类型的变量
    byte b=1;
    //定义short类型变量
    short s=10;
    //定义int类型的变量
    int i=100;
    //定义long类型的变量，需要加后缀L或l
    long l=10000000L; 
    
    //2、浮点型
    //定义float类型的变量，需要加后缀F或f
    float f=3.14F; 
    //定义double类型变量
    double d=3.14;
    
    //3、布尔型
    //定义boolean类型变量
    boolean flag=true;
    
    //4、字符型
    //定义char类型变量
    char c='a';

--------------------

## 5️⃣ 运算符 ##

Java里提供了许多的运算符，这些运算符除了可以处理一般的数学运算之外，还可以做逻辑运算、位运算等。大致可以分类为：

*  ***赋值运算符***：=、+=、-=、\*=、/=、%=
 *  ***算术运算符***：+、-、\*、/、%、++、–
 *  ***关系运算符***：>、<、>=、<=、==、!=
 *  ***逻辑运算符***：&、&&、|、||、!
 *  ***位运算符***：&、|、~、^、<<、>>、>>>
 *  ***三目运算符***：？:
 *  ***括号运算符***：()

### 5.1 赋值运算符 ###

***赋值运算符表示一个动作，即将其右侧的值赋予给左侧的变量中（左侧只允许是变量，不能是表达式或其他形式）***，注意不要将赋值运算符与关系运算符“==”混淆。

下面举例说明各个赋值运算符的使用：

//1、赋值运算符
    public static void main(String args[]){
        
            // = 直接赋值
            int a=1, b=2;
            System.out.println("b=" + b + ", a=" + a);
            // += 先加a再赋值给b
            b += a;
            System.out.println("b += a 结果 b=:" + b);
            System.out.println("------------------------");
    
            System.out.println("b=" + b + ", a=" + a);
            // -= 先减再赋值
            b -= a;
            System.out.println("b -= a 结果 b=:" + b);
            System.out.println("------------------------");
    
            System.out.println("b=" + b + ", a=" + a);
            // *= 先乘再赋值
            b *= a;
            System.out.println("b *= a 结果 b=:" + b);
            System.out.println("------------------------");
    
            System.out.println("b=" + b + ", a=" + a);
            // /= 先除再赋值
            b /= a;
            System.out.println("b /= a 结果 b=:" + b);
            System.out.println("------------------------");
    
            System.out.println("b=" + b + ", a=" + a);
            // %= 先取余再赋值
            b %= a;
            System.out.println("b %= a 结果 b=:" + b);
        }

输出结果如图：

![6169d19de3994d0c8bf7a15eb8639d38.png][]

图2 赋值运算符演示程序的运行结果

### 5.2 算术运算符 ###

Java 语言中***算术运算符的功能是进行算术运算，除了经常使用的加（+）、减（-）、乘（\*）和除（\\）外，还有取模运算（％）***。加（+）、减（-）、乘（\*）、除（\\）和我们平常接触的数学运算具有相同的含义。

算术运算符都是双目运算符，即连接两个操作数的运算符。优先级上，\*、/、％ 具有相同运算级别，并高于 +、-（+、- 具有相同级别）。

下面举例说明各个算术运算符的使用：

public static void main(String args[]){
        
            int a=1,b=2;
            System.out.println("a="+ a + ", b=" + b);
            //2、算数运算符
            // + 相加
            int sum = a + b;
            System.out.println("a+b=" + sum);
            // - 相减
            int diff = b - a;
            System.out.println("b-a=" + diff);
            // * 相乘
            int multi = a * b;
            System.out.println("a*b=" + multi);
            // / 相除。注意：整数相除只能得到整数, 要得到带有小数的准确结果, 必须有小数参与运算
            int div = b / a;
            System.out.println("b/a=" + div);
            // % 取模或取余
            int mod = b % a;
            System.out.println("b%a=" + mod);
            // ++ 让变量自身的值 + 1操作. ++在前: 先自增, 再操作.++在后: 先操作, 再自增
            System.out.println("运算前a=" + a);
            int c = ++a;
            System.out.println("前置++，++a=" + c + ", 运算后a=" + a);
            int d = a++;
            System.out.println("后置++，a++=" + d + ", 运算后a=" + a);
            // -- 让变量自身的值 - 1操作. --在前: 先自减, 再操作.--在后: 先操作, 再自减
            int e = --a;
            System.out.println("前置--，--a=" + e + ", 运算后a=" + a);
            int f = a--;
            System.out.println("后置--，a--=" + f + ", 运算后a=" + a);
    }

输出结果如图：

![04ba1e1507b54e70b9c3345b2845833d.png][]

图3 算术运算符演示程序的运行结果

### 5.3 比较\\关系运算符 ###

***关系运算符（relational operators）也可以称为“比较运算符”，用于用来比较判断两个变量或常量的大小。关系运算符是二元运算符，运算结果是 boolean 型。当运算符对应的关系成立时，运算结果是 true，否则是 false。***

需要注意的是，> 大于、>= 大于或等于、< 小于、<= 小于或等于，这些运算符只支持左右两边操作数是数值类型。而 == 和 != 可以应用于基本数据类型和引用类型，当用于引用类型比较时，比较的是两个引用是否指向同一个对象，但当时实际开发过程多数情况下，是比较对象的内容是否相当，而非比较是否为同一个对象。

下面举例说明各个比较\\关系运算符的使用：

public static void main(String args[]){
        
            int a=2,b=1;
            System.out.println("a = " + a + ", b = " + b);
            //3、关系运算符
            // > 判断大于、< 判断小于、>= 大于等于、<= 小于等于、== 等于、!= 不等于
            //判断结果是布尔型值
            boolean flag = b > a;
            System.out.println("b>a? 结果：" + flag);
            flag = b < a;
            System.out.println("b<a? 结果：" + flag);
            flag = b >= a;
            System.out.println("b>=a? 结果：" + flag);
            flag = b <= a;
            System.out.println("b<=a? 结果：" + flag);
            flag = b == a;
            System.out.println("b==a? 结果：" + flag);
            flag = b != a;
            System.out.println("b!=a? 结果：" + flag);
    }

输出结果如图：

![28b96ba712b743689321a4094c544ebf.png][]

图4 关系运算符演示程序的运行结果

### 5.4 逻辑运算符 ###

***逻辑运算符把各个运算的关系表达式连接起来组成一个复杂的逻辑表达式，以判断程序中的表达式是否成立，判断的结果是 true 或 false***。  
逻辑运算符是对布尔型变量进行运算，其结果也是布尔型。

需要注意的是，短路与（&&）和短路或（||）能够采用最优化的计算方式，从而提高效率。在实际编程时，应该优先考虑使用短路与和短路或。

下面举例说明各个逻辑运算符的使用：

public static void main(String args[]){
        
            boolean flag1 = true, flag2 = false;
            System.out.println("flag1 = " + flag1 + ", flag2 = " + flag2);
            //4、逻辑运算符
            // & 与
            boolean flag = flag1 & flag2;
            System.out.println("flag1 & flag2 = " + flag);
            // | 或
            flag = flag1 | flag2;
            System.out.println("flag1 | flag2 = " + flag);
            // ! 非/取反
            flag = !flag1;
            System.out.println("!flag1 = " + flag);
            // && 短路与：从左往右依次判断，只要有一个为false则结果为false
            flag = flag1 && flag2 && true;
            System.out.println("flag1 && flag2 && true = " + flag);
            // || 短路或：从左往右依次判断，只要有一个为true则结果为true
            flag = flag1 || flag2 || false;
            System.out.println("flag1 || flag2 || false = " + flag);
    }

输出结果如图：

![f6d8ff3eb9eb41ba88d41e585b2d5021.png][]

图5 逻辑运算符演示程序的运行结果

### 5.5 位运算符 ###

Java 定义的位运算（bitwise operators）直接对整数类型的位进行操作，这些整数类型包括 long，int，short，char 和 byte。  
***位运算符主要用来对操作数二进制的位进行运算，按位运算表示按每个二进制位（bit）进行计算，其操作数和运算结果都是整型值***。

Java 语言中的位运算符分为位逻辑运算符和位移运算符两类：  
（1）位逻辑运算符包含 4 个：&（与）、|（或）、~（非）和 ^（异或）  
（2）位移运算符包含3个：<< 位左移、>> 位右移、>>> 无符号右移

<table> 
 <thead> 
  <tr> 
   <th>运算符</th> 
   <th>类别</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>位与（&amp;）</td> 
   <td>二元运算符</td> 
   <td>对应二进制位都为1时结果为1，否则为0</td> 
  </tr> 
  <tr> 
   <td>位或（|）</td> 
   <td>二元运算符</td> 
   <td>对应二进制位有一个为1时结果就为1，否则为0</td> 
  </tr> 
  <tr> 
   <td>位异或（^）</td> 
   <td>二元运算符</td> 
   <td>对应二进制位不同时结果为1，相同则为0</td> 
  </tr> 
  <tr> 
   <td>位取反（~）</td> 
   <td>一元运算符</td> 
   <td>对应二进制位取反</td> 
  </tr> 
  <tr> 
   <td>位左移（&lt;&lt;）</td> 
   <td>一元运算符</td> 
   <td>按位左移一定的位置。高位溢出，低位补符号位，符号位不变</td> 
  </tr> 
  <tr> 
   <td>位右移（&gt;&gt;）</td> 
   <td>一元运算符</td> 
   <td>按位右移一定的位置。高位补符号位，符号位不变，低位溢出</td> 
  </tr> 
  <tr> 
   <td>无符号右移（&gt;&gt;&gt;）</td> 
   <td>一元运算符</td> 
   <td>符号位（即最高位）保留，其它位置向右移动，高位补零，低位溢出</td> 
  </tr> 
 </tbody> 
</table>

特别需要注意的是，***在进行位运算的时候，都是先将二进制原码转成二进制补码再进行运算的***。其中需要了解的点主要有：  
\- 正数的原码，反码和补码都一样；  
\- 负数的反码：符号位保持不变，其他位取反；  
\- 负数的补码：反码 + 1；  
\- 最高位为符号位，0表示正数，1表示负数；  
\- 0的反码和补码都是0。

下面举例说明各个位运算符的使用：

public static void main(String args[]){
        
            //5、位运算符
            // 位运算是先将操作数转为二进制格式数，再进行运算
            byte a=2, b=1;
            System.out.println("a = " + a + ", b = " + b);
            // & 位与
            int c = a & b; //---->00000010 & 00000001 = 00000000
            System.out.println("a & b = " + c);
            // | 位或
            c = a | b; //---->00000010 | 00000001 = 00000011
            System.out.println("a | b = " + c);
            // ~ 位取反
            c = ~a; //----> ~00000010 = 11111101 符号位为1表示是负数，则再将符号位以外的位取反，再加1，即 10000010 + 1 = 10000011
            System.out.println("~a = " + c);
            // ^ 位异或
            c = a ^ b; //---->00000010 ^ 00000001 = 00000011
            System.out.println("a ^ b = " + c);
            // << 位左移
            c = a << 1; //---->00000010 << 1 = 00000100
            System.out.println("a << 1 = " + c);
            // >> 位右移
            c = a >> 1; //---->00000010 >> 1 = 00000001
            System.out.println("a >> 1 = " + c);
            // >>> 无符号右移
            c = a >>> 1; //---->00000010 >>> 1 = 00000001
            System.out.println("a >>> 1 = " + c);
    }

输出结果如图：

![3f0c8eb480f64aa0a2e0741140c52c40.png][]

图6 位运算符演示程序的运行结果

下面是运算过程分析：  
略

### 5.6 三目运算符 ###

Java 提供了一个特别的***三目运算符，常用于取代某个类型的 if-then-else 语句。条件运算符的符号表示为“ ? : ”，使用该运算符时需要有三个操作数，因此称其为三目运算符***。其语法结构为：  
result = <expression> ? <statement1> : <statement2>;

其中，expression 是一个布尔表达式。当 expression 为true时，执行 statement1， 否则就执行 statement2。

下面举例说明三目运算符的使用：

public static void main(String args[]){
        
            int a=5,b=2;
            //6、三目运算符
            // 表达式 ?  值1 : 值2. 根据一个判断条件, 达成二者选其一.
            //当表达式的结果是true时 值1就是运算结果, 是false时 值2就是运算结果
            int max = a > b ? a:b;
            System.out.println("max = " + max);
    }

输出结果如图：

![faed15bd56914ef7ac4274d9f31f2a09.png][]

图7 三目运算符演示程序的运行结果

### 5.7 运算优先级 ###

Java 语言中大部分运算符是从左向右结合的，只有单目运算符、赋值运算符和三目运算符例外，其中，单目运算符、赋值运算符和三目运算符是从右向左结合的，也就是从右向左运算。

Java 语言中运算符的优先级共分为 14 级，其中 1 级最高，14 级最低。在同一个表达式中运算符优先级高的先执行。下表列出了所有的运算符的优先级以及结合性。

<table> 
 <thead> 
  <tr> 
   <th>优先级</th> 
   <th>运算符</th> 
   <th>结合性</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>()、[]、{}</td> 
   <td>–&gt;(从左向右)</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>!、+、-、~、++、–</td> 
   <td>&lt;–(从右向左)</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>*、/、%</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>+、-</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>«、»、&gt;&gt;&gt;</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>&lt;、&lt;=、&gt;、&gt;=、instanceof</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>==、!=</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>&amp;</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>^</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>|</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>&amp;&amp;</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>||</td> 
   <td>–&gt;</td> 
  </tr> 
  <tr> 
   <td>13</td> 
   <td>? :</td> 
   <td>&lt;–</td> 
  </tr> 
  <tr> 
   <td>14</td> 
   <td>=、+=、-=、*=、/=、&amp;=、|=、^=、~=、«=、»=、&gt;&gt;&gt;=</td> 
   <td>&lt;–</td> 
  </tr> 
 </tbody> 
</table>

使用优先级为 1 的小括号可以改变其他运算符的优先级，即如果需要将具有较低优先级的运算符先运算，则可以使用小括号将该运算符和操作符括起来。

--------------------

## 6️⃣ 流程控制 ##

一般来说程序的结构包含了顺序结构、选择结构、循环结构3种。  
顺序结构中，程序自上而下逐行执行；选择（分支）结构是根据判断条件的布尔值结果，来选择执行不同的代码逻辑分支；循环结构是根据判断条件的结果，决定循环体内的程序逻辑的重复执行次数。

*  ***顺序结构***
 *  ***分支结构：if-else、switch-case***
 *  ***循环结构：while、for、do-while***

下面使用伪代码说明流程控制语句的使用：

//1、分支结构
    //if-else ：当哪一个分支的判断条件为true，就会执行对应的语句体
    if(判断条件1){
        
    	语句体1;
    }else if(判断条件2){
        
        语句体2;
    }
    ...
    else {
        
    	语句体n;
    }
    //switch-case ：对表达式的值做选择判断，当case语句后的值满足则执行对应的语句体
    switch ( 表达式 ) {
        
    	case 值1 ：
    		语句体1 ;
    		break ;
    	case 值2 ：
    		语句体2 ;
    		break ;
    	...
    	default ：
    		语句体 n;
    		break ;
    }
    
    //2、循环结构
    /**
    * for循环：明确循环次数的时候,使用for循环.格式：
    * for(初始化语句; 判断条件; 条件控制语句){
    *	循环体语句;
    * }
    * 初始化语句: 定义变量. 
    * 判断条件: 控制循环是否需要继续的条件. 
    * 循环体语句: 循环逻辑. 
    * 条件控制语句 : 改变控制循环的变量
    */
    for(int i = 1; i <= 5; i++){
        
    	System.out.println(i);
    }
    
    /**
    * while循环：不明确循环的次数,使用while循环.格式：
    * 初始化语句;
    * while(判断条件){
    *	循环体语句;
    *	条件控制语句;
    * }
    */
    int i = 1;
    while(i <= 5){
        
        System.out.println(i);
        i++;
    }
    
    /**
    * do-while循环：无论判断条件是否满足, 都至少执行一次循环体.格式：
    * 初始化语句;
    * do {
    *	循环体语句;
    *	条件控制语句;
    * }while(判断条件)
    */
    int i = 1;
    do{
        
    	System.out.println(i);
        i++;
    }while(i <= 5);

此外，流程控制中还有两个控制循环跳转或结束的关键字：**break和continue**。  
break: 结束\\终止。用在switch语句和循环语句中，终止当前循环语句;  
continue: 用在循环语句中，跳过某一次循环体的执行, 继续下一次。

--------------------

## 7️⃣ 引用数据类型 ##

Java的数据类型可以划分为基本数据类型、引用数据类型。前面已经介绍了基础类型，这里介绍引用类型。引用数据类型在操作时必须要进行内存的开辟，分配内存空间。

*  ***字符串：String str = “xxx”;***
 *  ***对象：Object obj = new Object();***
 *  ***数组：Object\[ \] array = new Object\[length\];***

下面举例说明三种引用类型的使用：

//1、字符串定义
    String str = "hello world";
    
    //2、数组定义
    //静态初始化方式:
    int[] arr = {
        1,2,3,4,5};
    //动态初始化方式:
    int[] arr = new int[5];
    
    //3、对象创建
    // 对象的创建依赖于一个具体类
    Student student = new Student();

--------------------

## 8️⃣ 类与对象 ##

Java是一门面向对象编程的开发语言，主要思想就是类与对象。类是一组相关属性和行为的集合，可以将类理解为是对象的设计图，根据类才能创建出一个具体的对象。

不仅如此，Java还提供了继承这一特性作为类与类之间的连接关系，提供了接口作为对某一抽象行为的封装，提供了实现接口这一方式作为类延伸某个接口功能的方式。

主要有以下关键字实现定义：

*  ***class***：用于声明一个类
 *  ***interface***：用于声明一个接口
 *  ***enum***：用于声明一个枚举类
 *  ***extends*** ：用于表示类之间的继承关系
 *  ***implements***：用于表示类与接口之间的实现关系
 *  ***new***：用于创建一个类的实例对象
 *  ***instanceof***：用于确定对象所属的类
 *  ***this***：引用当前类的实例
 *  ***super***：引用父类的实例
 *  ***package***：指定在Java源文件中声明的类所在包路径
 *  ***import***：导入一个包中的某个或所有类
 *  ***return***：从方法中返回数据

下面使用伪代码说明类、方法、接口的完整定义格式：

//1、类定义格式
    [private| default| protected| public] [abstract] [final] [static] class 类名 extends 父类名 implements 接口名{
        
    	Filed...
    	Method...
    }
    //2、方法定义格式
    [private| default| protected| public] [abstract] [final] [static] 返回值类型 方法名(参数列表){
        
    	...
    	[return 返回值;]
    }
    //3、接口定义格式
    [public] interface 接口名 extends 接口名{
        
    	...
    }

--------------------

## ✔️ 一图总结 ##

![e4b9767c4f9e4961becd1165b9fcd8c4.png][]

图8 一图总结Java基础语法

--------------------

参考链接：  
[java关键字-百度百科][java_-]

![在这里插入图片描述][b6101e8476ab4c2dac908e03e6dddd2b.gif_pic_center]

[f923c21cbc0a482e9b2f6215ed442882.png]: https://img-blog.csdnimg.cn/f923c21cbc0a482e9b2f6215ed442882.png
[6169d19de3994d0c8bf7a15eb8639d38.png]: https://img-blog.csdnimg.cn/6169d19de3994d0c8bf7a15eb8639d38.png
[04ba1e1507b54e70b9c3345b2845833d.png]: https://img-blog.csdnimg.cn/04ba1e1507b54e70b9c3345b2845833d.png
[28b96ba712b743689321a4094c544ebf.png]: https://img-blog.csdnimg.cn/28b96ba712b743689321a4094c544ebf.png
[f6d8ff3eb9eb41ba88d41e585b2d5021.png]: https://img-blog.csdnimg.cn/f6d8ff3eb9eb41ba88d41e585b2d5021.png
[3f0c8eb480f64aa0a2e0741140c52c40.png]: https://img-blog.csdnimg.cn/3f0c8eb480f64aa0a2e0741140c52c40.png
[faed15bd56914ef7ac4274d9f31f2a09.png]: https://img-blog.csdnimg.cn/faed15bd56914ef7ac4274d9f31f2a09.png
[e4b9767c4f9e4961becd1165b9fcd8c4.png]: https://img-blog.csdnimg.cn/e4b9767c4f9e4961becd1165b9fcd8c4.png
[java_-]: https://baike.baidu.com/item/java%E5%85%B3%E9%94%AE%E5%AD%97/5808816#3_43
[b6101e8476ab4c2dac908e03e6dddd2b.gif_pic_center]: https://img-blog.csdnimg.cn/b6101e8476ab4c2dac908e03e6dddd2b.gif#pic_center