java安装以及快速入门java基本语句

原创

长生不死大王

发布于 2025-04-28 20:12:39

23300

代码可运行

运行总次数：0

代码可运行

一：Java简介：

Java是一门面向对象的编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

java体系：

目前java主要分为以下三个体系，分别有着不用用途：

JavaSE(J2SE)(Java2 Platform Standard Edition，java平台标准版)
JavaEE(J2EE)(Java 2 Platform,Enterprise Edition，java平台企业版)
JavaME(J2ME)(Java 2 Platform Micro Edition，java平台微型版)。

本博客将以JavaSE出发，带领大家安装配置java环境

二：安装java及编译器

IntelliJ IDEA 是一款功能强大的集成开发环境（IDE），广泛用于 Java 开发，但也支持多种编程语言，如 Kotlin、Groovy 和 Scala。是目前国内使用最广泛的java编译器，并有着强大的快捷键功能，所以我们推荐使用初学者使用IDEA来作为开发的工具；

安装jdk

JDK（Java Development Kit）是Java开发工具包的缩写，它是用于开发Java应用程序的一套完整的软件开发工具。JDK是Java技术的核心部分，包括了Java运行环境（JRE）、Java工具（如javac、java、javap等）以及Java基础类库（例如rt.jar）。JDK允许开发者编写、编译、调试和运行Java应用程序。

目前企业更加青睐于以下几个稳定版本，这是因为企业对于项目jdk的稳定版相当看重，以下几个版本甲骨文公司是长期支持，推荐的版本：

· JDK 17（LTS，2021 年发布）：目前最稳定、广泛支持的长期支持（LTS）版本，适用于企业应用。

· JDK 21（LTS，2023 年发布）：引入了虚拟线程（Project Loom）、模式匹配等特性，适合未来发展，性能优化显著。

· JDK 11（LTS，2018 年发布）：部分企业仍在使用，但长期来看建议升级至 JDK 17 及以上。

· JDK 8（LTS，2014 年发布）：许多老旧项目仍在使用，但已逐步淘汰，新项目不建议使用。

下载时请选择自己适合的环境以及版本，这里以window环境下安装java21为例：

下载连接：https://download.oracle.com/java/21/latest/jdk-21_windows-x64_bin.exe点击即可下载

如果有需要其他版本的jdk可以访问官网来自行选择

Java Archive | Oracle

window版本

下载完成后进入安装页面：

依次点击下一步，选择合适的安装路径

进入文件目录，复制路径（当然也可以自己写，但是稳妥起见建议复制路径）：

在输入框输入“高级系统设置”

点击环境变量，在系统变量里面新增java路径

新增系统变量

双击path新增

即可完成java安装

安装编译器

访问官方网址：

IntelliJ IDEA – the IDE for Pro Java and Kotlin Development

点击下载

可以选择下载的版本

下载完成后进入安装

添加桌面快捷方式

开始安装

安装完成后选择地区并确认服务条款

下载完成后新建一个文件夹，用于存放java代码

创建并选择java_code文件夹

选择此窗口

新建一个类

新建一个类，就可以开始编写java代码了，接下来我们来验证一下

使用main和sout的快捷方式就可以直接快速验证了

代码：

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

其中：public是访问权限修饰符号，static是关键字，void 是返回类型 main是方法名，String[] 是string类 args是数组名

点击运行在控制台出现Hello,World,安装成功

三：java基本语法：

基本数据结构类型：

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

byte：

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

short：

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

int：

int 数据类型是32位、有符号的以二进制补码表示的整数；
最小值是 -2,147,483,648（-2^31）；
最大值是 2,147,483,647（2^31 - 1）；
一般地整型变量默认为 int 类型；
例子：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）；
这种类型主要使用在需要比较大整数的系统上；
例子： long a = 100000L，long b = -200000L。

float：

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

double：

double 数据类型是双精度、64 位、符合 IEEE 754 标准的浮点数；
浮点数的默认类型为 double 类型；
double类型同样不能表示精确的值，如货币；
例子： 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；
默认值是 false；
例子：boolean one = true。

char：

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

其中每个数据类型都有默认值：

int, short, long, byte 的默认值是0。
char 的默认值是 \u0000（空字符）。
float 的默认值是 0.0f。
double 的默认值是 0.0d。
boolean 的默认值是 false。

接下来我们来用例子展示我们的基本数据类型

public class hello {
    public static void main(String[] args) {
        int d = 2, e = 3, f = 4; // 声明三个整数并赋予初值
        String g = "hello";  // 声明并初始化字符串 s
        double pi = 3.1415926; // 声明了双精度浮点型变量 pi
        char h = 'h';        // 声明变量 h 的值是字符 'h'。

        System.out.println(d);//输出2
        System.out.println(e);//输出3
        System.out.println(f);//输出4
        System.out.println(pi);//输出3.1415926
        System.out.println(g);//输出hello
        System.out.println(h);//输出h
    }
}

注意：

如果一个变量在初始化时没有赋值，应在后续使用时赋值，否则不能直接使用

算术运算符：

+：加法 - 相加运算符两侧的值
-：减法 - 左操作数减去右操作数
*：乘法 - 相乘操作符两侧的值
/：除法 - 左操作数除以右操作数
%：取余 - 左操作数除以右操作数的余数
++：自增: 操作数的值增加
--：自减: 操作数的值减少1
=：简单的赋值运算符，将右操作数的值赋给左侧操作数
+=：加和赋值操作符，它把左操作数和右操作数相加赋值给左操作数
-=：减和赋值操作符，它把左操作数和右操作数相减赋值给左操作数
*=：乘和赋值操作符，它把左操作数和右操作数相乘赋值给左操作数
/=：除和赋值操作符，它把左操作数和右操作数相除赋值给左操作数
==：检查如果两个操作数的值是否相等，如果相等则条件为真。
!=：检查如果两个操作数的值是否相等，如果值不相等则条件为真。
>=：检查左操作数的值是否大于或等于右操作数的值，如果是那么条件为真。
<=：检查左操作数的值是否小于或等于右操作数的值，如果是那么条件为真。
>：检查左操作数的值是否大于右操作数的值，如果是那么条件为真。
<：检查左操作数的值是否小于右操作数的值，如果是那么条件为真。

案例：

public class hello {
    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)); // 输出结果：a + b = 30
        // 减法
        System.out.println("a - b = " + (a - b)); // 输出结果：a - b = -10
        // 乘法
        System.out.println("a * b = " + (a * b)); // 输出结果：a * b = 200
        // 除法
        System.out.println("b / a = " + (b / a)); // 输出结果：b / a = 2
        // 取模
        System.out.println("b % a = " + (b % a)); // 输出结果：b % a = 0
        // 取模
        System.out.println("c % a = " + (c % a)); // 输出结果：c % a = 5

        // 后置自增
        System.out.println("a++   = " + (a++)); // 输出结果：a++ = 10，a 的值变为 11
        // 后置自减
        System.out.println("a--   = " + (a--)); // 输出结果：a-- = 11，a 的值变为 10
        // 后置自增
        System.out.println("d++   = " + (d++)); // 输出结果：d++ = 25，d 的值变为 26
        // 前置自增
        System.out.println("++d   = " + (++d)); // 输出结果：++d = 27，d 的值变为 27

        // 等于
        System.out.println("a==b" + (a == b)); // 输出结果：a==bfalse
        // 不等于
        System.out.println("a!=b" + (a != b)); // 输出结果：a!=btrue
        // 大于
        System.out.println("a>b" + (a > b)); // 输出结果：a>bfalse
        // 小于
        System.out.println("a<b" + (a < b)); // 输出结果：a<btrue

        // 复合赋值运算：a -= b
        a -= b;
        System.out.println("a-=b" + a); // 输出结果：a-=b-10
        // 复合赋值运算：a += b
        a += b;
        System.out.println("a+=b" + a); // 输出结果：a+=b10
    }
}

Java循环：

循环可以使原本只能执行一次的程序语句可以执行多次,主要分为以下3种类型

while 循环
do…while 循环
for 循环

（1）while循环

while( 条件 ) {
  //循环内容
}

条件应为布尔类型即只能为true 或者 false 当条件为true时程序会一直执行下去

案例

public class hello {
    public static void main(String[] args) {
        int x = 1;
        while( x < 5 ) {
            System.out.print("x的值 : " + x );
            x++;//用于控制x的增加否则将会进入死循环，引起栈溢出，导致程序崩溃
            System.out.print("\n");//换行
        }
    }
}

（2）do...while循环

do {
       //代码语句
}while(条件);

与while循环最大的区别是while循环必须先判断条件，只有满足时才会执行，但do...while循环是先执行，再判断是否继续执

行

public class javacode {
    public static void main(String[] args) {
        int x = 1;
        do {
            System.out.println("x的值是：" + x);
            x++;
        } while (x <= 5);
    }
}

（3）for循环

for(初始化; 条件; 更新的内容) {
    //代码语句
}

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

public class javacode {
    public static void main(String[] args) {

        for(int x = 1; x < 5; x++){
            System.out.println("x的值是："+x);
        }
    }
}

条件语句：

条件语句主要有3种表达方式，这3种方式大同小异

if
if...else
if...if else...else

if语句

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

案例：

public class javacode {
    public static void main(String[] args) {
        int x=10;
        if(x>10){
            System.out.println("x比10大");
        }
        if (x==10){
            System.out.println("x等于10");
        }
        if(x<10){
            System.out.println("x比10小");
        }
    }
}

if...else语句

if 语句后面可以跟 else 语句，当 if 语句的布尔表达式值为 false 时，else 语句块会被执行。

if(条件{
   //如果条件成立
}else{
   //如果条件不成立
}

案例

public class javacode {
    public static void main(String[] args) {
        int x=10;
        if(x>10){
            System.out.println("x比10大");
        }else{
            System.out.println("x不比10大");
        }
        
    }
}

if...if else...else

if 语句后面可以跟 else if…else 语句，这种语句可以检测到多种可能的情况。

if(条件1){
   //满足条件1
}else if(条件2){
   //满足条件2
}else if(条件 3){
   //满足条件3
}else {
   //其余
}

案例

public class javacode {
    public static void main(String[] args) {
        int x=10;
        if(x>10){
            System.out.println("x比10大");
        } else if (x==10) {
            System.out.println("x等于10");
        }else {
            System.out.println("x比10小");
        }

    }
}

数组

一维数组

数组是一种用于存储相同数据类型的固定长度的数据结构，可以存放包括int ,char,double类型的变量，甚至包括存放数组。基本形式分为两种

存放的数据类型[] 变量名
存放的数据类型变量名[]

数组的声明分为两种

一种是直接在声明时填入值，例如 int[] arr = {1,2,3,4}
另一种是给数组一个长度，通过new操作符来定义数组 double[] arr = newdouble[10];

接下来，我们我们在一个案例里面使用这两种定义方法

public class javacode {
    public static void main(String[] args) {
        // 第一种方式定义数组
        double[] arr1 = {5.1, 2.6, 3.7, 1.2, 4.0, 4.31, 4.0, 45.5, 99.9999, 123};
        double total1 = 0;
        for (int i = 0; i < arr1.length; i++) {//.length是获取数组长度
            total1 += arr1[i];
        }
        System.out.println("方式一总和为： " + total1);//方式一总和为： 293.4099

        // 第二种方式定义数组
        double[] arr2 = new double[10];
        arr2[0] = 5.1;
        arr2[1] = 2.6;
        arr2[2] = 3.7;
        arr2[3] = 1.2;
        arr2[4] = 4.0;
        arr2[5] = 4.31;
        arr2[6] = 4.0;
        arr2[7] = 45.5;
        arr2[8] = 99.9999;
        arr2[9] = 123;
        double total2 = 0;
        for (int i = 0; i < 10; i++) {
            total2 += arr2[i];
        }
        System.out.println("方式二总和为： " + total2);//方式二总和为： 293.4099
    }
}

根据控制台输出的结果，我们发现两种方式都成功的定义了数组

多维数组

我们在前面提到了，数组是用于存放同一类型的数据结构，理所应当的，数组里面也可以存放数组，所以由此衍生了二维数组，三维数组，我们把这种存放数组的数组称为多维数组，接下来我们就来学习以二维数组为例的多维数组

我们来看这个例子，int[][] a = new int[2][3]; 可以看成一个两行三列的表格，其中第一行是第一个子数组，第二行是第二个子数组，如图

第一行数组里面的内容	第一行数组里面的内容	第一行数组里面的内容
第二行数组里面的内容	第二行数组里面的内容	第二行数组里面的内容

下面这个案例用于访问二维数组的每个变量

public class javacode {
    public static void main(String[] args) {
        int[][] a= {{1,2,3},{3,4,5},{6,7,8}};

        for(int i=0;i<a.length;i++) {  //二维数组的行循环

            for(int j=0;j<a[i].length;j++) {  //二维数组的列循环

                System.out.print(a[i][j]+" ");  //输出每个元素

                if(a[i][2]==a[i][j]) {  //当每一行输出三列后换行

                    System.out.println();

                }
            }
        }
    }
}

方法/函数

函数是写在类中具有一定特殊功能的代码块，函数的产生的目的是为了解决重复多次的写一段相同，或相似的代码来实现同一个功能或包含一样的逻辑，我们将这段代码封装成函数，只需要传入不同参数，就可以得到想要的结果，接下来我们来了解java的函数构成吧,java方法构成如下：

修饰符 返回值类型 方法名(参数类型1 参数名1，参数类型2 参数名2...参数类型n 参数名n){
    ...
    方法体
    ...
    return 返回值;
}

我们最先了解的main函数也是一个方法：

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

其中，public是访问权限修饰符，void是返回类型，main是方法名 string[] args是传入的类型和变量

接下来我们来自定义一个方法用于实现变量的相加：

public class javacode {
    public static void main(String[] args) {
        System.out.println(sum(1,2));//3
    }

    public static int sum(int a,int b) {
        return a+b;
    }
}

在这个案例中1,2是传入的实参（实际的参数），a,b是形参（形式上的参数），这是逻辑上的参数，只能作用于函数内部，因此我们就可以定义两个相同的变量

public class javacode {
    public static void main(String[] args) {
        int a=1,b=2;
        System.out.println(sum(a,b));
    }

    public static int sum(int a,int b) {
        return a+b;
    }
}

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

原创声明：本文系作者授权腾讯云开发者社区发表，未经许可，不得转载。

如有侵权，请联系 cloudcommunity@tencent.com 删除。

java

登录后参与评论

0 条评论

热度