Java学习笔记

最新推荐文章于 2024-07-10 11:26:23 发布
最新推荐文章于 2024-07-10 11:26:23 发布
阅读量407 收藏
点赞数
分类专栏： java 文章标签： java intellij-idea 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JMisme/article/details/122550150
版权

java环境的配置

1、添加环境变量 JAVA_HOME 选择jdk路径

2、添加两个path路径

​ 1、%JAVA_HOME%\bin

​ 2、%JAVA_HOME%\jre\bin

3、 命令行输入 java -version 确认环境配置成功

0、IDEA的使用

  • 新建一个空项目

在这里插入图片描述

  • 选择空项目在这里插入图片描述

  • 为项目命名，并确认
    在这里插入图片描述

  • 新建一个Module

  • 在这里插入图片描述

  • 选择Java，JDK1.8，命名
    在这里插入图片描述

  • 设置项目结构(Project Structure)

    在这里插入图片描述
    在这里插入图片描述

1、Java注释

###1、单行注释

//Hello World

2、多行注释

/*
	Hello World
*/

3、文档注释

2、数据类型

java是强类型语言

1、基本数据类型

img

2、引用类型

​ 类、接口类型、数组类型、枚举类型、注解类型。

3、二者的区别

​ 基本数据类型在被创建的时，会在栈上划分一块内存空间，并将数值直接存储在栈上。（不用new空间）

public class Demo01 {
    public static void main(String[] args) {
        // 整数拓展：    进制  二进制0b   十进制  八进制0  十六进制0x

        int i = 10;
        int i2 = 010;   // 八进制0
        int i3 = 0x10;  // 十六进制0x   0~9 A~F 15

        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);
        System.out.println(" ==========================");

        // ================================
        // 浮点数拓展？  银行业务怎么表示?钱
        // BigDecimal 数学工具类
        // ================================
        // float   有限 离散 舍入误差 大约
        // double
        // 最好完全避免使用浮点数进行比较
        // 最好完全避免使用浮点数进行比较
        // 最好完全避免使用浮点数进行比较

        float f = 0.1f; // 0.1
        double d = 1.0/10;  // 0.1

        System.out.println(f==d); // false

        float d1 = 23131313131313131f;
        float d2 = d1 + 1;

        System.out.println(d1==d2); // true
    }
}

3、类型转换

在这里插入图片描述

注意点：

1. 不能对布尔值进行转换
2. 不能把对象类型转换为不相干的类型
3. 在把高容量转换到低容量的时候，需要强制转换，反之则不用
4. 转换的时候可能存在内存溢出，或者精度问题！


int i = 128;
byte b = (byte)i; // 内存溢出

// 强制转换 （类型）变量名 高-->低
// 自动转换               低-->高

System.out.println(i);
System.out.println(b);

/*
        注意点：
        1. 不能对布尔值进行转换
        2. 不能把对象类型转换为不相干的类型
        3. 在把高容量转换到低容量的时候，需要强制转换，反之则不用
        4. 转换的时候可能存在内存一处，或者精度问题！
         */
System.out.println("==================");
System.out.println((int)23.7);  // 23
System.out.println((int)-45.89f);   // -45

System.out.println("===================");
char c = 'a';
int d = c + 1;
System.out.println(d);
System.out.println((char)d);

操作比较大的数的时候，注意溢出问题

JDK7 新特性，数字之间可以用下划线分割

int money = 10_0000_0000;
int years = 20;
int total = money*years;    //-1474836480,计算的时候溢出了
long total2 = money*years;  //默认是int，转换之前已经存在问题了

long total3 = money*(long)years; //先把一个数转换为long
System.out.println(total3);

// L l  用L不用l

4、变量

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

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

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

    type varName [=value] [{,varName[=value]}];、
//数据类型 变量名 = 值；可以使用逗号隔开来声明多个同类型变量。

注意事项：

1. 每个变量都有类型，类型可以是基本类型，也可以是引用类型。
2. 变量名必须是合法的标识符。
3. 变量声明是一条完整的语句，因此每一个声明都必须以分号结束

变量作用域

  • 类变量
  • 实例变量
  • 局部变量
public class Variable{
    static int allClicks = 0;	//	类变量
    String str="hello world";	//	实例变量
    
    public void method(){
		int i = 0;	//	局部变量
    }
}

Java访问修饰符

在这里插入图片描述

修饰符，不存在先后顺序

final

对类：该类不可被继承。

  • 在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。

对方法：锁定方法，防止任何继承类修改它的含义。

  • 只有在想明确禁止 该方法在子类中被覆盖的情况下才将方法设置为final的。

对变量：基本数据类型一旦初始化后，便不能更改；引用对象初始化后，便不能再指向新的对象。

public class Demo04 {
    // 修饰符，不存在先后顺序
    static final double PI = 3.14;

    public static void main(String[] args) {
        System.out.println(PI);
    }
}

变量的命名规范

  • 所有变量、方法、类名：见名知意

  • 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词以外，后面的单词首字母大写

    lastname lastName

  • 局部变量：首字母小写和驼峰原则

  • 常量：大写字母和下划线： MAX_VALUE

  • 类名：首字母大写和驼峰原则：Man，GoodMan

  • 方法名：首字母小写和驼峰原则：run(),runRun()

5、运算符

  • 算术运算符：+，-，*，/，%，++，–

  • 赋值运算符：=

  • 关系运算符：>，<，>=，<=，==，!= instanceof

    instanceof：二元操作运算符，左边的对象是否是它右边的类的实例，返回 boolean 的数据类型。

  • 逻辑运算符：&&，||，!

  • 位运算符：&，|，^，~，>>，<<，>>> （了解）

  • 条件运算符：？

  • 扩展复制运算符：+=，-=，*=，/=

位运算符

        /*
        A  =  0011 1100
        B  =  0000 1101
        ---------------------
        A&B = 0000 1100
        A|B = 0011 1101
        A^B = 0011 0001
        ~B  = 1111 0010
        
        左移  右移   效率极高
        << 左移 *2
        >> 右移 /2
         */

字符串连接符

        int a = 10;
        int b = 20;

        // 字符串连接符  + , String
        System.out.println(""+a+b);	// 输出 1020
        System.out.println(a+b+"");	// 输出 30

三元运算符

        // x ? y : z
        // 如果x==true，则结果为y，否则结果为z

        int score = 50;
        String type =  score < 60 ? "不及格":"及格"; //必须掌握
        // if
        System.out.println(type);

6、包机制

打包语句：

package com.Ming.lesson01;

导包语句：

import	com.Ming.lesson01.Demo01;
import  com.Ming.lesson01.*; //包含lesson01下的所有的类

相当于文件夹

一般利用公司域名导致作为包名

开发规范相关书籍：《阿里巴巴开发手册》

7、Scanner

通过Scanner类来获取用户的输入

基本语法：

Scanner s = new Scanner(System.in);

通过Scanner类的next()与nextLine()方法获取输入的字符串，在读取前我们一般需要使用hasNext()与hasNextLine()判断是否还有输入的数据。

注意：凡是io流的类，如果不关闭，就会一直占用资源，所以用完记得使用 s.close() 来关闭scanner

  • next()
    • 1、一定要读取到有效字符后才可以结束输入
    • 2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉
    • 3、只有输入有效字符后才将其后面的空白作为分隔符或结束符
    • 4、next()不能得到带有空格的字符串
  • nextLine()
    • 1、以Enter为结束符。也即是说nextLine()方法返回的是输入回车之前的所有字符。
    • 2、可以获得空白。

8、命令行传参

public class args {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i + "] :" + args[i]);
        }
    }
}

生成 args.class 文件

javac args.java

退回到src文件夹

java com.Ming.method.args Hello I'm Spiderman

输出结果

在这里插入图片描述

9、可变参数

public static void printMax(double... numbers){
    //如果参数为空，则退出函数
    if(numbers.length == 0){
        System.out.println("No argument passed");
        return;
    }
    double result = numbers[0];
    //排序
    for (double number : numbers) {
        if (number > result){
            result = number;
        }
    }
    System.out.println("最大值为：" + result);
}

10、数组

在这里插入图片描述

静态初始化：创建 + 赋值

int[] a = {1,2,3,4,5};
System.out.println(a[0]);

动态初始化：包含默认初始化

int[] b = new int[10];
b[0] = 10;
b[1] = 10;

1.稀疏数组

在这里插入图片描述

实现源码

public class ArrayDemo01 {
    public static void main(String[] args) {
        //疏数组
        //1.创建一个二维数组11*11 0：没有妻子，1：黑棋  2：白起
        int[][] array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始的数组
        System.out.println("输出原始的数组");

        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }

        System.out.println("======================");
        System.out.println("转换为稀疏数组");
//        2.转换为稀疏数组保存
//        获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if(array1[i][j] != 0){
                    sum++;

                }
            }
        }
        System.out.println("有效值的个数:" + sum);

        int[][] array2 = new int[sum+1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;

//        遍历二维数组，将非零的值，存放到稀疏数组中
        int count = 0;
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if(array1[i][j] != 0){
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array1[i][j];
                }
            }
        }

//        输出稀疏数组
        System.out.println("输出稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            for (int j = 0; j < array2[i].length; j++) {
                System.out.print(array2[i][j]+"\t");
            }
            System.out.println();

        }

//        还原
        System.out.println("===========================");
        System.out.println("还原");
//        1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
//        2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
//        3.打印
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + " ");
            }
            System.out.println();
        }
    }
}

11、方法

1、静态方法(static)

和类一起加载

public class Demo02{
    public static void main(String[] args){
		// 和类一起加载的
        public static void a(){
            // 会调用失败，因为调用了一个不存在的方法
            b();
        }
        // 类实例化 之后才存在
        public void b(){
            
        }
    }
}

12、面向对象

在这里插入图片描述

1、类与对象

​ 类是一个模板：抽象，对象是一个具体的实例

2、方法

​ 定义、调用！

3、对应的引用

​ 引用类型：除了8大基本类型

​ 对象是通过引用来操作的：栈 --> 堆

4、属性：字段Field 成员变量

​ 默认初始化：

​ 数字：0 0.0

​ char： u0000

​ boolean： false

​ 引用：null

​ 修饰符 属性类型 属性名 = 属性值

5、对象的创建和使用

  • 必须使用new 关键字创建对象，构造器 Person kuangshen = new Person();
  • 对象的属性 kuangshen.name
  • 对象的方法 kuangshen.sleep()

6、类：

​ 静态的属性 属性

​ 动态的行为 方法

1、封装

2、继承

IDEA快速写出set和get的快捷键：alt+insert

super注意点：

1、super调用父类的构造方法，必须在构造方法的第一个

2、super必须只能出现在子类的方法或者构造方法中！

3、super和this不能同时调用构造方法！

Vs this：

  • 代表的对象不同
    • this：本身调用者这个对象
    • super：代表父类对象的应用
  • 前提
    • this：没有继承也可以使用
    • super：之恶能在继承条件下才可以使用
  • 构造方法
    • this()：奔雷的构造
    • super()：父类的构造

1、重写

需要有继承关系，子类重写父类的方法！

​ 1、方法名必须相同

​ 2、参数列表必须相同

​ 3、修饰符：范围可以扩大但不能缩小：public>protected>default>private

​ 4、抛出的异常：范围可以被缩小，但不能扩大：ClassNotFoundException<-Exception(大)

重写，子类的方法和弗雷必须要一直；方法体不同！

有些方法不能被重写

​ 1、static 方法，属于类，它不属于实例

​ 2、final 常量

​ 3、private 方法

3、多态

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！

父类型，可以指向子类，但是不能调用子类独有的方法

package com.Ming.inherit.demo03;

public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了：父类的引用指向子类
        Student s1 = new Student();
        //Person 父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！
        ((Student)s2).eat();
        s2.run();
    }
}

多态注意事项：

1、多态是方法的多态，属性没有多态

2、父类和子类，有联系 否则会出现 类型转换异常！ ClassCastException!

3、存在条件：继承关系，方法需要重写，父类引用指向子类对象！ Father f1 = new Son();

1、instanceof的使用

注意：

Object object = new Student();

引用类型为Object，实际类型为Student

X instanceof Y

  • 能不能编译通过 取决于X的引用类型与Y是否有父子关系
  • 是否为true 取决于X的实际类型是否是Y的子类
// Object > Person > Student
// Object > Person > Teacher
Object object = new Student();

//System.out.println(X instanceof Y);
// 能不能编译通过  取决于X的引用类型与Y是否有父子关系
// 是否为true  取决于X的实际类型是否是Y的子类

System.out.println(object instanceof Student); //true
System.out.println(object instanceof Person); //true
System.out.println(object instanceof Object); //true
System.out.println(object instanceof Teacher); //true
System.out.println(object instanceof String); //false
System.out.println("==================================");
Person person = new Student();
System.out.println(person instanceof Student); //true
System.out.println(person instanceof Person); //true
System.out.println(person instanceof Object); //true
System.out.println(person instanceof Teacher); //true
//System.out.println(person instanceof String); //编译报错！
System.out.println("==================================");
Student person = new Student();
System.out.println(student instanceof Student); //true
System.out.println(student instanceof Person); //true
System.out.println(student instanceof Object); //true
//System.out.println(student instanceof Teacher); //编译报错！
//System.out.println(person instanceof String); //编译报错！

1、父类引用指向子类的对象

2、把子类转换为父类，向上转型；

3、把父类转换为子类，向下转型；强制类型转换

4、方便方法的调用，减少重复的代码！

2、static的使用

1、静态导入包
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;

public class test {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
    }
}
2、静态变量
3、静态方法

静态方法不能使用非静态方法，因为静态方法和类一同加载，而此时非静态方法还未加载。

4、静态代码块

一个类的静态代码块，只在第一次实例化时执行。

代码块执行顺序：静态代码块（只执行一次）>匿名代码块>构造代码块

3、其他

1、抽象类

abstract 抽象类：类 extends：单继承~ （接口可以多继承）

abstract，抽象方法，只有方法名字，没有方法的实现！

1、不能new这个抽象类，只能靠子类区实现它：约束！

2、抽象类种可以写普通的方法

3、抽象方法必须在抽象类中

抽象的抽象：约束

2、接口

implements

作用：

  1. 约束
  2. 定义一些方法，让不同的人实现
  3. public abstract
  4. public static final
  5. 接口不能被实例化，接口中没有构造方法
  6. implements可以实现多个接口
  7. 必须要重写接口中的方法

UserService.java

//interface 定义的关键字，接口都需要有实现类
public interface UserService {
    //接口中的所有定义起始都是抽象的 public abstract

    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}

TimeService.java

public interface TimeService {
    void timer();
}

UserServiceImpl.java

import java.sql.Time;

// 抽象类：extends~
// 类 可以实现接口 implements 接口
// 实现了接口的类，就必须重写接口中的方法
public class UserServiceImpl implements UserService, TimeService {
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void update(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

3、内部类

  1. 成员内部类
  2. 静态内部类
  3. 局部内部类
  4. 匿名内部类

13、异常处理

java把异常当作对象来处理，并定义了一个基类java.lang.Throwable作为所有异常的父类。

异常体系结构

在这里插入图片描述

异常的分类：

  • 检查性异常：最具代表的检查性异常是用户错误或问题引起的异常，这是程序员无法预见的，例如要打开一个不存在文件时，一个异常就发生了，这些异常在编译时不能被简单地忽略。
  • 运行时异常：运行时异常是可能被程序员避免的异常。与检查性异常相反，运行时异常可以在编译时被忽略。
  • 错误ERROR：错误不是异常，而是脱离程序员控制地问题。错误在代码中通常被忽略。例如，当栈溢出时，一个错误就发生了，它们在编译也检查不到地。

经验总结：

  • 处理运行时异常时，采用逻辑去合理规避同时辅助try-catch处理
  • 在多重catch快后面，可以加一个catch（Exception）来处理肯恩会被遗漏的异常
  • 对于不确定的代码，也可以加上try-catch，处理潜在的异常
  • 尽量去处理异常，切记只是简单地调用printStackTrace（）去打印输出
  • 具体如何处理异常，要根据不同的业务需求和异常类型去决定
  • 尽量添加finally语句块去释放占用的资源
做个大侠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JDK环境变量的设置
weixin_34402408的博客
03-25 974
2019独角兽企业重金招聘Python工程师标准>>> ...
java学习笔记
csdnlxk98的博客
04-26 815
第一个Java程序Java语言的平台                JavaSE                                 JVM：保证Java语言跨平台 JavaME--Android                JRE：Java程序的运行环境         JavaEE                                 JDK：Java程序的开发环境 ...
java path JAVA_HOME class的设置及其用意_bin910729_新浪博客
weixin_42215229的博客
05-28 3531
今天再次设置java的环境变量，突然发现每次设置都只是按照步骤一步步将其设置完，并不了解为啥要设置，于是上网找了找，找到遍文章，觉得不错，就留下了。 仅供记录学习。转自：http://bbs.tech.163.com/bbs/tech_0ik1/147645925.html 在把jdk安装到计算机中之后，我们来进行设置使java环境能够使用。 首先右键点我的电脑。...
JAVA_HOME变量的详细配置（图文）
大剑师兰特的GIS世界
06-21 3万+
用到Java项目的时候，有时候要用到Java_home，这个需要在系统配置中配置一下。如何操作呢？以下为详细的图文步骤。
【Java】Windows系统中Java环境变量配置指南：详细配置JAVA_HOME和CLASSPATH（全网最详细的图文教程，建议收藏）
最新发布
科技改变人类，技术成就未来
07-10 3094
在Windows系统中配置Java环境变量（JAVA_HOME 和 CLASSPATH）是Java开发的基本步骤。首先，从Oracle官方下载并安装JDK，确保安装路径正确。然后，通过系统属性进入环境变量设置，新建或编辑系统变量：JAVA_HOME 指向JDK安装路径，CLASSPATH 包含 .;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;，并在 Path 中添加 %JAVA_HOME%\bin。完成后，打开命令提示符，通过 echo %JAVA_HO
java 开发环境配置 JAVA_HOME 和 MAVEN_HOME
二等碗
04-08 3965
在Java和Maven的开发环境中，JAVA_HOME和MAVEN_HOME是非常重要的环境变量，它们帮助操作系统定位Java运行时环境（JRE）和Maven仓库以及执行文件。
配置JAVA_HOME环境变量的作用是什么？
qq_62547236的博客
08-19 8943
为什么要配置JAVA_HOME环境变量？配置的环境变量是为IDEA运行程序服务的吗？
JAVA学习笔记
NASA诺亚方舟
05-22 239
JAVA学习笔记 一 JDK安装 1.1环境变量配置 1.1.1 永久配置环境变量 打开方式：计算机-高级-环境变量 JAVA_HOME：自己建的系统变量，添加到JDK目录即可 //切记，不是用户变量 path：系统默认环境变量，添加两个bin文件，jdk\bin和jdk\jre\bin classpath：执行class文件时，指定优先搜索java类的存放路径 1.1.2 临时配...
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
java学习笔记markdown
03-12
【Java学习笔记Markdown版】是针对Java初学者和进阶者的一份详尽教程，以Markdown格式编写，便于阅读和整理。Markdown是一种轻量级的标记语言，它允许用户使用易读易写的纯文本格式编写文档，然后转换成结构化的HTML...
java学习笔记1
09-20
Java学习笔记1 Java学习笔记1是学习Java过程中的笔记，主要记录了Eclipse开发环境中的快捷键使用、编辑功能、查找和调试等知识点。 Eclipse快捷键 Eclipse中有许多快捷键，掌握这些快捷键可以大大提高开发效率。...
(完整版)最全的java学习笔记(必看).pdf
05-27
Java学习笔记 Java是一种流行的编程语言，广泛应用于Android应用程序开发、Web应用程序开发、桌面应用程序开发等领域。以下是Java学习笔记的摘要信息： 一、Java技术基础 * 1.1 编程语言：Java是一种面向对象的...
java学习笔记资源合集
05-25
java学习笔记 Java 自 1995 年诞生，至今有 16 年的历史，从诞生之日起，逐渐被广泛接受并成为推 动了 web 迅速发展。Java 的三种核心机制为虚拟机机制、代码安全机制、垃圾回收机制。 Java 最大的特点是平台无关性...
Java学习笔记学习笔记
10-24
Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习笔记Java学习...
java环境的搭建
10-27 1356
windowsxp下配置JDK环境变量：1.安装JDK，安装过程中可以自定义安装目录等信息，例如我们选择安装目录为D:/java/jdk1.5.0_08；　2.安装完成后，右击“我的电脑”，点击“属性”；3.选择“高级”选项卡，点击“环境变量”；4.在“系统变量”中，设置3项属性，JAVA_HOME,PATH,CLASSPATH(大小写无所谓),若已存在则点击“编辑”，不存在...
java 环境配置(详细教程)
热门推荐
xhmico的博客
01-09 40万+
文章目录前言一、jdk 下载二、windows1、jdk 安装2、环境变量的配置3、检测是否配置成功 前言 java 环境配置，网上教程很多，那我为什么还要写？ 首先为了完善我的知识体系 今后一些软件的安装教程也可能会用到 想写一个更加详细的，因为这并不仅仅是写给 IT 行业的，其它行业可能也需要配置java环境 提示：以下是本篇文章正文内容，下面案例可供参考 一、jdk 下载 如果你电脑已经下载了 jdk ，那就恭喜你可以跳过这一步了 jdk 的下载路径：https://www.oracle.co
什么是 JAVA_HOME？
yueqian_edu的博客
03-22 5249
　　JAVA_HOME 是一个操作系统 (OS) 环境变量，可以在安装 Java Development Kit (JDK) 或 Java Runtime Environment (JRE) 后进行设置。JAVA_HOME 环境变量指向安装 JDK 或 JRE 的文件系统位置。此变量应在所有安装了 Java 的操作系统上配置，包括 Windows、Ubuntu、Linux、Mac 和 Android。 　　本地安装的 Java 运行时实际上并未使用 JAVA_HOME 环境变量。相反，安装在桌面计算机上的
Java学习笔记：从入门到精通
"这是一份详尽的Java学习笔记电子书，特别适合初学者。书中内容细致入微，涵盖了从基础到进阶的各种知识点，通过图片形式生动地展示了Java编程的核心概念。" 在Java学习过程中，了解对象的概念是至关重要的。粗粒度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值