Java基本语法

！！！本文适合有 c 和 c++ 基础的，通过比较 c++ 和 java 的不同，快速入门 java。！！！
这篇文章主要是介绍和 c++ 不同的地方，没说的知识点按照 c++ 写就行了。

零. 整体的结构

Java 是面向对象的程序。首先对于 Java 来说一个文件就是一个类, 而且类名必须和文件名一致，比如 Main 类，则文件名要叫做 Main.java，而 Person 类，文件名要叫做 Person.java。

它和 c++ 首先映入眼帘的不同就是不可以在类外定义函数，它所有的函数（包括主函数都要定义在类里面）。

1. 主函数

比如在一般只有一个文件的话 c++ 结构是这样的：

#include<iostream>
using namespace std;
int main(){
	//代码
    return 0;
}

但是 Java 的话 main 函数也要放在类里面：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        //代码
    }
}

注：public static void main(String[] args) {} 是主函数（或者叫程序入口）的唯一格式，不能写成其他形式。类的话命名随意。

2. 函数 / 方法

【1】在类外定义方法

c++ 中允许在类外定义方法，比如

#include<iostream>
using namespace std;
void print(){
	cout<<"666";
}
int main(){
	print();
	return 0;
}

在 Java 中应该这么写：

import java.util.Scanner;
public class Main {
    public static void speak(){
        //下面这句话是Java的控制台输出语句，相当于printf或者cout
        System.out.println("666");
    }
    public static void main(String[] args) {
        speak();
    }
}

注意因为 main 函数为静态方法，学过 c++ 都知道，静态方法属于类中的所有实例所共有，并且只能调用静态的变量和方法，所以 speak 函数必须是 static 才能被 main 函数调用，至于是要 public 还是 private 看你自己。

【2】在类内定义方法

当然 c++ 也可以在类内定义方法：

#include<iostream>
using namespace std;
class Person{
	public:
		void speak(){
			cout<<"666";
		}
};
int main(){
	Person person;
	person.speak();
	return 0;
}

改写成 Java 是这样的：

import java.util.Scanner;
public class Main {
    static class Person{
        public void speak(){
            System.out.println("666");
        }
    };
    public static void main(String[] args) {
        Person person=new Person();
        person.speak();
    }
}

因为 Java 中一个文件只能是一个类，所以 Person 类只能作为内部类存在于 Main 中，所以 Person 前面也要加上 static 关键字才能被同为静态方法的 main 函数调用。

3. 分文件编写

当然 Java 也可以像 c++ 那样分文件编写（因为下面是定义在同一个包内，所以不用引包）
我们可以重新创建一个文件 Person.java 来定义 Person 类。

public class Person{
    public void speak(){
        System.out.println("666");
    }
}

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
        Person person=new Person();
        person.speak();
    }
}

4. 包的概念

【1】包是什么

c++ 中没有包的概念。那么包是什么呢？

当程序足够大的时候，我们就要学会去管理我们代码。写程序的时候代码管理很重要。在 c++ 中，比如当零散的代码足够多时，我们就要用函数去分类包装这些代码，将一部分代码抽象成这个函数，另一部分代码抽象成另一个函数。当函数足够多时，我们要将方法分类，进一步抽象，一部分函数属于这个类，一部分函数当成那个类的方法，用类包装。

但是当类足够多，我们就要进一步分类，一部分类放在这个命名空间，一部分类放在那个命名空间。

包说白了就是文件夹，作用就类似于命名空间，用来对各个类进行分类管理，一部分包放在这个文件夹，另一部分包放在那个文件夹。

【2】案例：新建一个 Util 包，将 Person 类放在 Util 中

package util;
public class Person{
    public void speak(){
        System.out.println("666");
    }
}

import util.Person;
public class Main {
    public static void main(String[] args) {
        Person person=new Person();
        person.speak();
    }
}

【3】包名命名规则
上面只是个示例：比较正式的项目要采用以下的命名规则

公司域名反写 + 包的名字（要体现作用），需要全部英文小写，见名知意
例：com.flyingpig.entity com.flyingpig.util【其中 com.flyingpig 是域名】
简单说就是建立一个 com 文件夹，里面再建立一个 flyingpig 文件夹，然后里面就可以建立 entity 文件夹来存放实体类，建立 util 文件夹来存放工具类

在 com.flyingpig.entity 包下的 Student 类表示为 com.flyingpig.entity.Student ，这个叫做全类名和全限定名。

【3】我们看到 Person 类上面加了个 package，而 Main 类上面 import。
这是因为类放在包里要 package。
而引用放在别的包里的类需要引包。具体的引包规则如下：
（1）使用同一个包中的类时，不需要导包
（2）使用于 java.lang 包中的类时，不需要导包
（3）其他情况都需要导包
（3）如果同时使用两个包中的同名类，需要用同类名.

一. 注释（和 c 一样）

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

二. 字面量和变量类型

字面量 – 整型，小数，字符串，字符，布尔类型，空类型（null）

变量类型 – 四类八种

和 c++ 基本一致，不一样的是多了像 byte 之类类型，少了像 long double 之类的类型。

三. 输入输出

输出：System.out.println 方法

//输出字符串字面量
System.out.println("我可以输出任何变量哦");
//输出整型字面量
System.out.println(666);
//输出整型变量
int a=0;
System.out.println(a);
//注意long类型的数据值后面一般需要加个L或l作为后缀。
long n=9999999999L;
System.out.println(n);
//注意float类型的数据值后面一般需要加个F作为后缀。
float f=10.1F;
System.out.println(f);

输入：用 Scanner 类

//建立一个调用Scanner的有参构造建立一个Scanner对象
Scanner scanner=new Scanner(System.in);
///调用其中的方法进行输入，其中nextInt方法是用来输入整数的
int number=sc.nextInt();

四. 关系运算符

和 c++ 几乎一样，只有些许不同，这里列举几个不同点。
（1）% 也能用于小数运算
（2）bool 类型不能用于算数计算
（3）java 中对的数据类型转换检查严格

下面的代码在 c++ 中是可以的，但在 java 中就会报错。

1 2	`int a=1.1;`

五. 分支和循环语句

写法与 c++ 一模一样。

但是 Java 还提供了增强 for 和增强 Switch，可以简化书写。

1. 增强 for

【1】优点

Java 中的增强 for 循环（也称为 for-each 循环）相比于传统的 for 循环
优点：

简洁，不需要索引
安全性：防止越界（没有使用索引）和修改集合中的元素。
缺点：
无法获取当前元素的索引：增强 for 循环没有提供内置的索引访问机制，如果需要获取当前元素的索引，仍然需要使用传统 for 循环。
无法修改集合中的元素：增强 for 循环只能读取集合中的元素，无法修改元素的值或删除元素。

需要注意的是，增强 for 并不会提高程序的运行效率。在底层实现上，增强 for 循环其实还是通过迭代器或索引来遍历集合或数组的。

【2】增强 for 循环的语法

1
2
3

for (元素类型 元素变量 : 遍历对象) {
    // 循环体
}

其中，元素类型表示遍历对象中元素的类型，元素变量是用于接收每个元素值的变量名，遍历对象可以是数组或实现了 Iterable 接口的集合类（如 List、Set 等）。

下面是几个示例：

遍历数组：

int[] numbers = {1, 2, 3, 4, 5};
for (int number : numbers) {
    System.out.println(number);
}

遍历集合：

List<String> fruits = Arrays.asList("apple", "banana", "orange");
for (String fruit : fruits) {
    System.out.println(fruit);
}

遍历字符串：

String message = "Hello";
for (char ch : message.toCharArray()) {
    System.out.println(ch);
}

在以上示例中，每次迭代时，元素变量（如 number、fruit、ch）都会被赋值为遍历对象中的一个元素值，然后执行循环体内的代码。循环将按顺序遍历遍历对象中的每个元素，直到遍历完成。

2. 增强 switch

原来：

int dayOfWeek = 3;
String dayName;
 
switch (dayOfWeek) {
    case 1:
        dayName = "Monday";
        break;
    case 2:
        dayName = "Tuesday";
        break;
    case 3:
        dayName = "Wednesday";
        break;
    case 4:
        dayName = "Thursday";
        break;
    case 5:
        dayName = "Friday";
        break;
    case 6:
        dayName = "Saturday";
        break;
    case 7:
        dayName = "Sunday";
        break;
    default:
        dayName = "Invalid day";
        break;
}
 
System.out.println("The day is: " + dayName);

简化：

int dayOfWeek = 3;
String dayName=new String();
switch (dayOfWeek) {
    case 1 -> String dayName ="Monday";
    case 2 -> String dayName ="Tuesday";
    case 3 -> String dayName ="Wednesday";
    case 4 -> String dayName ="Thursday";
    case 5 -> String dayName ="Friday";
    case 6 -> String dayName ="Saturday";
    case 7 -> String dayName ="Sunday";
    default -> String dayName ="Invalid day";
};
System.out.println("The day is: " + dayName);

还可以进一步化简，将变量提取出来

int dayOfWeek = 3;
String dayName = switch (dayOfWeek) {
    case 1 -> "Monday";
    case 2 -> "Tuesday";
    case 3 -> "Wednesday";
    case 4 -> "Thursday";
    case 5 -> "Friday";
    case 6 -> "Saturday";
    case 7 -> "Sunday";
    default -> "Invalid day";
};
System.out.println("The day is: " + dayName);

六. 引用数据类型

基本数据类型【上面讲的四类八种】

数据值是存储在自己的空间中。
特点：赋值给其他变量，也是赋的是真实的值。

引用数据类型 – 就是 java 中表示对象的数据类型。
数据值是存储在其他空间中，自己空间中存储的是地址值。类似于 c++ 的指针。同样的储存变量，同样的可以改变地址。
特点：赋值给其他变量，赋的地址值。

【1】因为 java 和 c++ 不同的是，java 创建对象都是在堆区 new 出来的，所以都使用引用数据类型来操作对象。

例如：
在 c++ 中可以

1 2	`Person person;`

但是创建的话 java 中必须用 new 来创建对象：

1 2	`Person person=new Person();`

这里的 Person 与 c++ 的 Person 不一样，它代表引用，就像下面 c++ 的 Person*。

1 2	`Person* person=new Person();`

【2】调用方法的时候 java 自动解引用，下面的第一个是 java，第二个是 c++:

1 2	`person.speak();`

1 2	`*person.speak();`

【3】赋值的时候 java 和 c++ 一样也是直接赋值地址：

1 2	`person=person1;`

【4】Java 中的引用相比于 c++ 更加方便安全，因为它不用手动释放空间。

总结来说 java 的引用就类似于 c++ 的指针安全化，写法上的话相当于 c++ 的引用。
补充一点，Java 中的链表就是通过引用数据类型实现的。

七. 数组

在 java 中，数组是一种对象。
创建数组

public static void main(String[] args) {
    //int数组的类型名叫做int[],所以一般是这样写的
    int[] array1=new int[3];
    //但是如c++之类的语言一般习惯用int array2[]这种格式，所以也可以这么写
    int array2[]=new int[3];
    //当然了，赋值的话还可以用数组专门用于赋值的初始化列表
    int[] array3=new int[]{11,22,33};
    //也可以简化写成
    int[] array4={11,22};
}

使用的话和 c 几乎一样，但还是有不同。
（1）因为是变量，所以 java 里面的数组有属性 size 可以来获取数组的长度，如
array3.length。这个比较经常在循环中用到。
（2）还有数组越界，在 java 中不会纵容数组越界，一越界会抛出异常。

九. 方法

和 c，c++ 差不多，就像第零条所讲的，最大的不同就是所有方法，包括 main 方法都得在类里面定义。
还有值得一提的是 java 方法里面最终的结果要确定，例如 c++ 中可以这样：

#include<iostream>
using namespace std;
bool judge(int num){
	if(num>1)
		return 0;
} 
int main(){
	bool result=judge(1);
	cout<<result;
}

大于 1 返回 0，可以不指定小于等于 1，当 num 小于或等于 1 时，它会返回默认值。

但是 java 这样的话会报错缺少 return 语句

static boolean judge(int num){
    if(num>1)
        return false;
}

而需要这样写：

static boolean judge(int num){
    if(num>1)
        return false;
    else 
        return true;
}

其他

final 关键字 – 类似于 c++ 的 const

语法：public final void 函数名

作用：简单说就是不可改变。
作用于变量，变量只能被赋值一次。
作用于方法，方法不能被重写。
作用于类，不能被继承。

后端开发 > Java基础

#后端开发 #Java基础

Java基本语法

https://flyingpig.fun/2023/09/13/Java基本语法/

作者

flyingpig

发布于

2023年9月13日

许可协议

汇编语言上一篇

redis入门下一篇