重学JAVA之1基础语法

hello world

package com.example.test;

import java.lang.System;

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

package 是 表示包关键字，后面跟着包名。
com.example.test 是 包名， 每个点后是文件夹的下一级目录，最后就是最深的目录。
import 是 引入关键字，引入其他的包或者类。
java.lang.System  是 java.lang包名 + System类名。
public 是 修饰符
class 表示这是一个类
HelloWorld 是 类名
static 也是 修饰符
void 是 类型
main 是 jvm调用java的固定方法名
String 是 字符串类
args 是 方法名
System 是 类名
out 是 System的成员变量，PrintStream类的实例
println 是 PrintStream类的方法名
"Hello World" 是 字符串常量

类与对象

类是对现实中的东西的抽象模板。对象是一个抽象概念，根据这个类的构造方法实例化出一个在内存中的东西。

类：

public class User {
  private String name;
  
  // 无参构造方法
  public User() {
    
  }
  
  // 有参构造方法
  public User(String name) {
    this.name = name;
  }
  
  public String getName() {
    return name;
  }
}

对象：

public class Test {
    public static void main(String[] args) {
        // 实例化对象
      User user1 = new User();
      User user2 = new User("张三");
    }
}

修饰符

访问修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

访问修饰符为了控制代码的编写。不能一个很底层的类或者方法暴露到高级的层。

非访问修饰符

static

英文：静态的。在类的成员变量或者方法前加上static, 可以使用类名直接访问。

静态变量：

1	`private static int i = 0;`

静态方法:

1
2
3

private static void add(int a, int b) {
	return a + b;
}

final

英文：最终的。可加在变量、方法、类。用于变量之前表明变量值不可变。用于方法前表示方法的逻辑不可变（子类无法重写）。

用于类表示类不可被继承。

变量：

1	`final int value = 10;`

方法：

1
2
3

public final void changeName(){
  // 方法体
}

类：

1
2
3

public final class Test {
   // 类体
}

abstract

英文：抽象的。可加在类、方法。表示类或者方法是抽象出来的，没有具体实现。

1
2
3

abstract class Test{
   public abstract void test1(); //抽象方法
}

synchronized

英文：同步的；同步化的。可加在方法。同一时间只能被一个线程访问。

1
2
3

public synchronized void changeName(){
  // 方法体
}

transient

英文：短暂的。可加在变量上。在对象序列化的时候，被transient修饰后，JVM跳过该特定的变量。

1	`public transient int value = 10;`

volatile

英文：不稳定的。可加在变量上。volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

1	`public volatile int value = 10;`

native

英文：本地的。可加在方法上。native表示这不是一个java方法，而是其他语言写的，java给出了规范JNI。只要符合JNI就可以调用。jdk源码中有很多调用了JVM的本地方法。

比如Oject：

package java.lang;

public class Object {

    private static native void registerNatives();
    static {
        registerNatives();
    }

    public final native Class<?> getClass();

    public native int hashCode();

    public boolean equals(Object obj) {
        return (this == obj);
    }

    protected native Object clone() throws CloneNotSupportedException;

    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

    public final native void notify();

    public final void wait(long timeout, int nanos) throws InterruptedException {
        if (timeout < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (nanos < 0 || nanos > 999999) {
            throw new IllegalArgumentException(
                                "nanosecond timeout value out of range");
        }

        if (nanos > 0) {
            timeout++;
        }

        wait(timeout);
    }
  
    public final void wait() throws InterruptedException {
        wait(0);
    }

    protected void finalize() throws Throwable { }
}

八大基础类型及其包装类型

基础类型

byte：

byte 数据类型是8位、有符号的，以二进制补码表示的整数；
最小值是 -128（-2^7）；
最大值是 127（2^7-1）；
默认值是 0；

short：

short 数据类型是 16 位、有符号的以二进制补码表示的整数
最小值是 -32768（-2^15）；
最大值是 32767（2^15 - 1）；
默认值是 0；

int：

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

long：

long 数据类型是 64 位、有符号的以二进制补码表示的整数；
最小值是 -9,223,372,036,854,775,808（-2^63）；
最大值是 9,223,372,036,854,775,807（2^63 -1）；
默认值是 0L；

float：

float 数据类型是单精度、32位、符合IEEE 754标准的浮点数；
float 在储存大型浮点数组的时候可节省内存空间；
默认值是 0.0f；

double：

double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
浮点数的默认类型为 double 类型；
默认值是 0.0d；

boolean：

boolean数据类型表示一位的信息；
只有两个取值：true 和 false；
默认值是 false；

char：

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

包装类型

Byte 对应 byte

Short 对应 short

Integer 对应 int

Long 对应 long

Float 对应 float

Double 对应 double

Character 对应 char

对象类型，就可以使用方法。

运算符

算术运算符

操作符	描述	例子
+	加法 - 相加运算符两侧的值	A + B 等于 30
-	减法 - 左操作数减去右操作数	A – B 等于 -10
*	乘法 - 相乘操作符两侧的值	A * B等于200
/	除法 - 左操作数除以右操作数	B / A等于2
％	取余 - 左操作数除以右操作数的余数	B%A等于0
++	自增: 操作数的值增加1	B++ 或 ++B 等于 21
–	自减: 操作数的值减少1	B– 或 –B 等于 19

关键运算符

运算符	描述	例子
==	检查如果两个操作数的值是否相等，如果相等则条件为真。	（A == B）为假。
!=	检查如果两个操作数的值是否相等，如果值不相等则条件为真。	(A != B) 为真。
>	检查左操作数的值是否大于右操作数的值，如果是那么条件为真。	（A> B）为假。
<	检查左操作数的值是否小于右操作数的值，如果是那么条件为真。	（A <B）为真。
>=	检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。	（A> = B）为假。
<=	检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。	（A <= B）为真。

位运算符

操作符	描述	例子
＆	如果相对应位都是1，则结果为1，否则为0	（A＆B），得到12，即0000 1100
\|	如果相对应位都是 0，则结果为 0，否则为 1	（A \| B）得到61，即 0011 1101
^	如果相对应位值相同，则结果为0，否则为1	（A ^ B）得到49，即 0011 0001
〜	按位取反运算符翻转操作数的每一位，即0变成1，1变成0。	（〜A）得到-61，即1100 0011
<<	按位左移运算符。左操作数按位左移右操作数指定的位数。	A << 2得到240，即 1111 0000
>>	按位右移运算符。左操作数按位右移右操作数指定的位数。	A >> 2得到15即 1111
>>>	按位右移补零操作符。左操作数的值按右操作数指定的位数右移，移动得到的空位以零填充。	A>>>2得到15即0000 1111

逻辑运算符

操作符	描述	例子
&&	称为逻辑与运算符。当且仅当两个操作数都为真，条件才为真。	（A && B）为假。
\| \|	称为逻辑或操作符。如果任何两个操作数任何一个为真，条件为真。	（A \| \| B）为真。
！	称为逻辑非运算符。用来反转操作数的逻辑状态。如果条件为true，则逻辑非运算符将得到false。	！（A && B）为真。

赋值运算符

操作符	描述	例子
=	简单的赋值运算符，将右操作数的值赋给左侧操作数	C = A + B将把A + B得到的值赋给C
+ =	加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数	C + = A等价于C = C + A
- =	减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数	C - = A等价于C = C - A
* =	乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数	C * = A等价于C = C * A
/ =	除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数	C / = A，C 与 A 同类型时等价于 C = C / A
（％）=	取模和赋值操作符，它把左操作数和右操作数取模后赋值给左操作数	C％= A等价于C = C％A
<< =	左移位赋值运算符	C << = 2等价于C = C << 2
>> =	右移位赋值运算符	C >> = 2等价于C = C >> 2
＆=	按位与赋值运算符	C＆= 2等价于C = C＆2
^ =	按位异或赋值操作符	C ^ = 2等价于C = C ^ 2
\| =	按位或赋值操作符	C \| = 2等价于C = C \| 2

三目运算符

1	`variable x = (expression) ? value if true : value if false`

1	`b = (a == 1) ? 20 : 30;`

instanceof 运算符

1	`boolean result = name instanceof String;`

Java运算符优先级

下表中具有最高优先级的运算符在的表的最上面，最低优先级的在表的底部。

类别	操作符	关联性
后缀	() [] . (点操作符)	左到右
一元	expr++ expr–	从左到右
一元	++expr –expr + - ～！	从右到左
乘性	* /％	左到右
加性	+ -	左到右
移位	>> >>> <<	左到右
关系	> >= < <=	左到右
相等	== !=	左到右
按位与	＆	左到右
按位异或	^	左到右
按位或	\|	左到右
逻辑与	&&	左到右
逻辑或	\| \|	左到右
条件	？：	从右到左
赋值	= + = - = * = / =％= >> = << =＆= ^ = \| =	从右到左
逗号	，	左到右

三大程序结构

顺序

顺序就是按照代码的顺序执行。这里不讨论编译器优化问题，只是逻辑顺序。

选择

if else

if(布尔表达式)
{
   //如果布尔表达式为true将执行的语句
}

int x = 10;

if( x < 20 ){
  System.out.print("这是 if 语句");
}

if(布尔表达式){
   //如果布尔表达式的值为true
} else{
   //如果布尔表达式的值为false
}

if(布尔表达式 1){
   //如果布尔表达式 1的值为true执行代码
} else if(布尔表达式 2){
   //如果布尔表达式 2的值为true执行代码
} else if(布尔表达式 3){
   //如果布尔表达式 3的值为true执行代码
} else {
   //如果以上布尔表达式都不为true执行代码
}

swich case

switch(expression){
    case value :
       //语句
       break; //可选
    case value :
       //语句
       break; //可选
    //你可以有任意数量的case语句
    default : //可选
       //语句
}

char grade = 'C';

switch(grade)
{
  case 'A' :
    System.out.println("优秀"); 
    break;
  case 'B' :
  case 'C' :
    System.out.println("良好");
    break;
  case 'D' :
    System.out.println("及格");
    break;
  case 'F' :
    System.out.println("你需要再努力努力");
    break;
  default :
    System.out.println("未知等级");
}
System.out.println("你的等级是 " + grade);

循环

while

1
2
3

while( 布尔表达式 ) {
  //循环内容
}

int x = 10;
while( x < 20 ) {
  System.out.print("value of x : " + x );
  x++;
  System.out.print("\n");
}

for

1
2
3

for(初始化; 布尔表达式; 更新) {
    //代码语句
}

最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
然后，检测布尔表达式的值。如果为 true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
执行一次循环后，更新循环控制变量。
再次检测布尔表达式。循环执行上面的过程。

do while

1
2
3

do {
       //代码语句
}while(布尔表达式);

int x = 10;

do{
  System.out.print("value of x : " + x );
  x++;
  System.out.print("\n");
}while( x < 20 );

异常处理

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

try{
  // 程序代码
}catch(异常类型1 异常的变量名1){
  // 程序代码
}catch(异常类型2 异常的变量名2){
  // 程序代码
}finally{
  // 程序代码
}

try-with-resources

try (resource declaration) {
  // 使用的资源
} catch (ExceptionType e1) {
  // 异常块
}

规格文档查看

学习java，还是看官网比较好。

去搜索引擎或者chatgpt 搜索 Java语言规范、Java虚拟机规范、Java标准库规范

Java SE Technical Documentation java技术文档。

Specifications 规格

jdk api文档：

https://docs.oracle.com/en/java/javase/21/docs/api/index.html

java语言及虚拟机规范：

https://docs.oracle.com/javase/specs/index.html

总结

看完这些之后，就可以做一些打印类的程序。也可以查看JDK相当源码了。

面试题

一些基础的面试题。

final finally 相关面试题。

synchronized 面试题。

volatile 面试题。

java

#java

重学JAVA之1基础语法

http://hanqichuan.com/2023/12/04/java/重学JAVA之1基础语法/

作者

韩启川

发布于

2023年12月4日

许可协议

spring_cloud_feign服务之间token传递上一篇

mysql主从复制搭建下一篇