【Java】 基础知识

一. JAVA 概述

(一) java语言跨平台原理

1. 平台

🔰平台指的是操作系统；
        ◓ Windows
        ◓ Mac
        ◓ Linux

2. 跨平台

🔰java 程序可以在任意操作系统上运行；

3. 跨平台原理

🔰在需要运行Java应用程序的操作系统上，安装一个与操作系统对应的Java虚拟机(JVM)即可；

---

(二) JRE 和 JDK

1. JRE

🔰是Java虚拟机运行时环境，包含JVM和运行时所需要的核心类库；

2. JDK

🔰是Java程序开发工具包，包含JRE和开发人员使用的工具；
🔰我们想要开发一个全新的Java程序，那么就必须安装JDK；

3. JDK, JRE 和 JVM 的关系

---

(三) 常用 DOS 命令

1. 打开命令提示符窗口

1. 按下win+R ⇒ 2. 输入cmd ⇒ 3. 按下回车键

2. 常用命令

操作	说明
盘符名称：	盘符切换 。E: 回车，表示切换到E盘
dir	查看当前路径下的内容
cd 目录	进入单级目录。cd itheima
cd…	回退到上一级目录
cd 目录1\目录2…	进入多级目录。cd itheima\javase
cd\	回退到盘符目录
cls	清屏
exit	退出命令提示符窗口

---

(四) Path 环境变量的配置

1. 为什么要配置Path环境变量

🔰为了在开发Java程序的时候，能够方便的使用javac和java这些命令，我们需要配置Path环境变量；

2. 如何配置Path环境变量

1.
2.
3.

3. 如何检测配置Path环境变量是否成功

🔰命令提示符窗口上输入javac，出现如下图一样的内容即可；

---

Ⅰ main方法格式

public static void main(String[] args) {
   }

---

Ⅱ 输出语句范例

System.out.println("内容");  输出内容并换行
System.out.print("内容");    输出内容不换行
System.out.println();        起到换行作用

---

Ⅲ JVM退出

System.exit(0);              JVM退出(java虚拟机退出)

---

Ⅳ IDEA中项目结构

🔰项目->模块->包->类

---

---

二. 基础语法

(一) 注释

🔰单行注释：//注释信息；快捷键：Ctrl+/
🔰多行注释：/*注释信息*/；快捷键：Ctrl+Shift+/

---

(二) 标识符

1. 标识符定义规则

🔰由数字，字母，下划线(_)和($)组成；
        ◓ 不能以数字开头；
        ◓ 不能是关键字；
        ◓ 区分大小写；

2. 常见命名约定

1) 小驼峰命名法：(常用于命名方法和变量)

    1) 约定1：标识符是一个单词 ⇒首字母小写(name)
    2) 约定2：标识符是多个单词 ⇒第一个单词首字母小写，其他的首字母大写(firstName)

2) 大驼峰命名法：(常用于命名类)

    1) 约定1：标识符是一个单词 ⇒首字母大写(Student)
    1) 约定2：标识符是多个单词 ⇒每个单词的首字母大写(GoodStudent)

---

(三) 数据类型

🔰定义long 类型数据时应定义成如下：

long a = 10L;

🔰定义float 类型数据时应定义成如下：

float a = 10F;

数据类型内存占用和取值范围

---

(四) 数据类型转换

1. 自动类型转换(隐式)

🔰把一个表示数据范围小的数值或者变量赋值给另一个表示数据范围大的变量；
🔰范例：double d = 10;

1.特点：代码不需要进行特殊处理，自动完成。
2.规则：数据范围从小到大。

2. 强制类型转换(显式)

🔰把一个表示数据范围大的数值或者变量，赋值给另一个表示数据范围小的变量；
        ◓ 格式：目标数据类型 变量名 = (目标数据类型)值或者变量;
        ◓ 范例：int k = (int)88.88;

1) int转换为String

🔰转换方式
        ◓ 方式一：直接在数字后加一个空字符串
        String s1 = number + "";
        ◓ 方式二：通过String类静态方法valueOf()
        String s2 = String.valueOf(number);

2) String转换为int

🔰转换方式
        ◓ 方式一：先将字符串数字转成Integer，再调用valueOf()方法
        Integer i = Integer.valueOf("s");
        int x = i.intValue();
        ◓ 方式二：通过Integer静态方法parseInt()进行转换
        int y = Integer.parseInt(s);

---

(五) ASCII码表

记住三个：48代表0，65代表A,97代表a。其余的查表即可。

---

(六) 变量的作用域

🔰规定了变量所能使用的范围，只有在作用域范围内变量才能被使用。
🔰根据变量声明地点的不同，变量的作用域也不同。
🔰根据作用域的不同，一般将变量分为不同的类型：类变量、局部变量、方法参数变量及异常处理参数变量。

1. 类变量

🔰类变量也称为成员变量，声明在类中，不属于任何一个方法，作用域是整个类。

2. 局部变量

🔰局部变量是指在方法或者方法代码块中定义的变量，其作用域是其所在的代码块。

3. 方法参数变量

🔰作为方法参数声明的变量的作用域是整个方法。

4. 异常处理参数变量

🔰异常处理参数变量的作用域是在异常处理块中，该变量是将异常处理参数传递给异常处理块，与方法参数变量类似。

---

---

三. 运算符

(一) 算术运算符

---

(二) 赋值运算符

---

(三) 自增自减运算符

🔰++ 和 - - 即可以放在变量的后面，也可以放在变量的前面；
🔰单独使用的时候，++ 和 - - 无论放在变量前边还是后边，结果都是一样的；
🔰参与操作的时候，如果放在变量的后边，先拿变量参与操作，后拿变量做++ 或者 - - ；如果放在变量的前面，先拿变量做++ 或者 - - ，后拿变量参与操作；

---

(四) 比较运算符

🔰关系运算符的结果都是Boolean类型，要么true，要么false；
🔰如果进行多次判断，不能连着写，例如1<x<3，此时需要用到逻辑运算符
🔰千万不要把“==”误写成“=”；

---

(五) 逻辑运算符

🔰与（并且） && 全都是true才是true，否则是false
🔰或（或者）|| 有一个是true就是true；全都是false就是false
🔰非（取反） ！本来是true，变成false；本来是false，变成true

---

(六) 三元运算符

🔰格式：关系表达式 ？ 表达式1 ： 表达式2；
🔰范例：a > b ? a : b;

---

---

四. 分支语句

(一) if 语句

if(关系表达式) {
   
	语句体1;
} else {
   
	语句体2；
}

---

(二) switch 语句

switch(表达式) {
   
	case 值1：
		语句体1；
		break;
	case 值2：
		语句体1；
		break;
	……
	default：
		语句体n+1；
		break;
}

---

---

五. 循环语句

(一) for 循环语句

for(初始化语句；条件判断语句；条件控制语句) {
   
	循环语句；
}

增强for循环

// 元素数据类型 必须和 数组/集合对象名 是同类型
for(元素数据类型 变量名 : 数组/集合对象名) {
   
	循环体;
}

for(int i : arr) {
    System.out.println(i); }

for(String s : list) {
    System.out.println(s); }

---

(二) while 循环语句

初始化语句；
while(条件判断语句) {
   
	循环体语句；
	条件控制语句；
}

---

(三) do…while 循环语句

初始化语句；
do {
   
	循环体语句；
	条件控制语句；
} while(条件判断语句)；

---

(四) 三种循环的区别

🔰do…while循环至少会执行一次循环体。
🔰for循环和while循环只有在条件成立的时候才会去执行循环体。

---

(五) 死循环

for(;;) {
   }
while(true) {
   }
do {
   } while(true);

---

(六) 跳转控制语句

🔰continue    跳过本次循环，继续下一次循环
🔰break        停止整个循环的执行

---

---

六. 数组

🔰定义格式：int[] arr;
🔰动态初始化：int[] arr = new int[3];
🔰静态初始化：int[] arr = {1, 2, 3, 4, 5};
🔰静态初始化：int[][] arr = { {1, 2}, {3, 4, 5}};
🔰 获取数组长度的函数：arr.length

---

---

七. 方法

(一) 方法的定义与调用

🔰方法的定义：
    public static 返回值类型 方法名(参数) {
            方法体
            return 返回值；
    }
🔰调用：
    1)方法名(参数);     ⇒     qq(a);
    2)数据类型 变量名 = 方法名(参数) ； ⇒    int c = qq(a);

---

(二) 方法注意事项

🔰方法不能嵌套定义；
🔰void表示无返回值，可以省略return，也可以单独的书写return，后面不能加数据；

---

(三) 方法重载

🔰多个方法在同一个类中
🔰多个方法具有相同的方法名
🔰多个方法的参数不相同，类型不相同或数量不同

---

---

八. 面向对象基础

(一) 类的定义

🔰类的定义步骤：
    ①定义类；
    ②编写类的成员变量；
        【位置发生了变化】在类中方法外
    ③缩写类的成员方法；
        跟之前定义方法的格式相同【static关键字暂时不加】

public class 类名{
    
	//成员变量
	变量1的数据类型 变量1;
	变量2的数据类型 变量2;
	……
	//成员方法
	方法1；
	方法2；
	…… }

---

(二) 对象的使用

🔰创建对象
    格式：类名 对象名 = new 类名();
    范例：phone p = new phone();
🔰使用对象的成员变量
    格式：对象名.变量名
    范例：p.brand
🔰使用对象的成员方法
    格式：对象名.方法名()
    范例：p.call()

---

(三) 封装

🔰面向对象三大特征

1. 封装 2. 继承 3. 多态

🔰封装的原则
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private，提供对应的getXxx()/setXxx()方法
🔰封装的好处
通过方法来控制成员变量的操作，提高了代码的安全性，把代码用方法进行封装，提高了代码的复用性

1. private 关键字

🔰是一个权限修饰符，可以修饰成员变量和成员方法
🔰作用是保护成员不被别的类使用，被private修饰的成员只在本类中才能访问

🔰针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
    ⚪提供“gei变量名()”方法，用于获取成员变量的值，方法用public修饰
    ⚪提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰


private 关键字的作用
🔰把成员变量用private修饰
🔰提供对应的getXxx()/setXxx()方法

2. this 关键字

🔰this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）
    ⚪方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量
    ⚪方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量

---

(四) 构造方法

🔰作用：创建对象；
🔰格式：

public class 类名 {
    
	修饰符 类名(参数) {
    
	}
}

🔰构造方法的调用：
    构造方法在创建对象的时候调用执行
    举例：Student s = new Student();

1. 构造方法的注意事项

🔰构造方法的创建
    ⚪如果没有定义构造方法，系统会给出一个默认的无参构造方法；
    ⚪如果定义了构造方法，系统不再提供默认的构造方法；
🔰构造方法也是方法，可以进行重载
🔰可以使用有参构造方法，对成员变量进行赋值，达到初始化数据的效果
🔰构造方法的重载
    ⚪如果自定义了带参构造方法，还要使用无参构造方法，就必须再写一个无参构造方法；

2. 标准类的制作

成员类
① 成员变量
    ⚪ 使用private修饰
② 构造方法
    ⚪ 提供一个无参构造方法
    ⚪ 提供一个带多个参数的构造方法
③ 成员方法
    ⚪ 提供每一个成员变量对应的setXxx()/getXxx()
    ⚪ 提供一个显示对象信息的show()
测试类
④ 创建对象并为其成员变量赋值的两种方式
    ⚪ 无参构造方法创建对象后使用setXxx()赋值
    ⚪ 使用带参构造方法直接创建带有属性值的对象

//学生类
class Student {
   
	private String name;
	private int age;
	public Student() {
   }
	public Student(String name) {
   
		this.name = name;
	}
	public Student(int age) {
   
		this.age = age;
	}
	public Student(String name,int age) {
   
		this.name = name;
		this.age = age;
	}
	public void show() {
   
		System.out.println(name + "," + age);
	}
}
//测试类
public class StudentDemo {
   
	public static void main(String[] args) {
   
		//创建对象
		Student s1 = new Student();
		s1.show();
		//public Student(String name)
		Student s2 = new Student("林青霞");
		s2.show();
		//public Student(int age)
		Student s3 = new Student(30);
		s3.show();
		//public Student(String name,int age)
		Student s4 = new Student("林青霞",30);
		s4.show();
	}
}

---

---

九. API

🔰 什么是API？
     应用程序编程接口
     说白了就是java提供好的一些核心类库
🔰 如何查看API帮助文档？
     1.打开API帮助文档
     2.点击索引选项卡
     3.在搜索框输入要搜索的类
     4.查看该类中的组成部分

---

(一) Scanner(数据输入)

Scanner 使用的基本步骤

1. 导包：

//写在类定义的上边
import java.util.Scanner;    

2. 创建对象：

//写在类定义的里面
Scanner sc = new Scanner(System.in);    

3. 接收数据：

//接收[int]类型数据(类内)
int k = sc.nextInt();          
//接收[float]类型数据(类内)    
float k = sc.nextFloat();       
//接收[String]类型数据(类内)   
String name = sc.nextLine();       

🔰 快捷键：sc.nextLine();+ctrl+alt+v

---

(二) Random(随机数)

Random使用的基本步骤

1. 导包：

import java.util Random;    

2. 创建对象：

Random r = new Random();   

3. 接收数据：

//获取随机数([int]范围：[0, 100) )
int k = ss.nextInt(100);  
//获取随机数([boolean])    
boolean k = ss.nextBoolean(); 
//获取随机数([float])
float k = ss.nextFloat();    

🔰 快捷键：r.nextint(10);+ctrl+alt+v

---

(三) String(内容不可变)

字符串比较

🔰 比较地址是否相同
                s1 == s2
🔰 比较内容是否相同
                s1.equals(s2)

常用字符串函数

🔰获取字符串长度的函数：字符串对象.length()
🔰返回指定索引处的字符值：字符串对象.charAt(i)
      一般用于字符串遍历

字符串改成int类型数组

String s = "91 27 46 38 50";
// 以空格为分割点，字符串转换成String数组
String[] strArray = s.split(" "); 
int[] arr = new int[strArray.length];
for(int i=0; i<arr.length; i++) {
   
arr[i] = Integer.parseInt(strArray[i]);
}

char[]转换成String: (通过构造方法)

String s2 = new String(arr);

byte[]转换成String: (通过构造方法)

String num = new String(arr, 0, 5);  //第一个开始，读5个

String转换为StringBuilder: (通过构造方法)

StringBuilder sb = new StringBuilder(s);

---

(四) StringBuilder(内容可变)

🔰 StringBuilder是一个字符串缓冲区。
🔰 它可以在原有的空间上继续拼接字符串内容！

常用函数

🔰 sb.append(“hello”);       => 添加数据，并返回对象本身
🔰 sb.reverse();                 => 返回相反的字符序列

StringBuilder转换为String: (通过toString()方法)

String s = sb.toString();

---

(五) Math

🔰Math类概述：Math 包含执行基本数字运算的方法；
🔰Math中方法的调用方式：
      ● Math类中无构造方法，但内部的方法都是静态的，则可以通过 类名.进行调用 Math.abs(23)
🔰Math类的常用方法：

Math.abs(int a);              // 返回参数的绝对值
Math.ceil(double a);          // 返回大于等于参数的最小double值，等于一个整数
   c = Math.ceil(12.4)==>c = 13.0    c = Math.ceil(12.8)==>c = 13.0
Math.floor(double a);         // 返回小于等于参数的最小double值，等于一个整数
   c = Math.floor(12.4)==>c = 12.0   c = Math.floor(12.8)==>c = 12.0
Math.round(float a);          // 按照四舍五入返回最接近参数的int
   c = Math.round(12.4)==>c = 12     c = Math.round(12.8)==>c = 13
Math.max(int a, int b);       // 返回最大值
Math.min(int a, int b);       // 返回最小值
Math.pow(double a, double b); 返回a的b次幂的值
Math.random();                // 返回值为double的正值，[0.0, 1.0)

---

(六) System

🔰System类的常用方法：

// 终止当前运行的Java虚拟机，非零表示异常终止
ystem.exit(0);          
// 返回当前时间(以毫秒为单位(可以用于计算程序运行耗时))
long a = System.currentTimeMillis();  

---

(七) Object

🔰Object类概述：
      ● Object 是类层次结构的根，每个类都可以将 Object 作为超类。该类所具备的方法，所有类都会有一份

1. toString方法

🔰重写toString方法的方式：

1. Alt + Insert 选择toString
2. 在类的空白区域，右键 -> Generate -> 选择toString

🔰toString方法的作用：
    ● 以良好的格式，更方便的展示对象中的属性值
🔰示例代码：

class Student extends Object {
    
   private String name;
   public Student() {
    }
   public Student(String name) {
    this.name = name; }
   public String getName() {
     return name; }
   public void setName(String name) {
    this.name = name; }
   @Override
   public String toString() {
    
       return "Student{" + "name='" + name + '\'' + '}';
   }
}
public class ObjectDemo {
    
   public static void main(String[] args) {
    
       Student s = new Student();
       s.setName("林青霞");
       System.out.println(s);
       System.out.println(s.toString());
   }
}

// Student{name='林青霞'}
// Student{name='林青霞'}

2. equals方法

🔰equals方法的作用：
    ● 用于对象之间的比较，返回true和false的结果
    ● 举例：s1.equals(s2); s1和s2是两个对象
🔰重写equals方法的场景：
    ● 不希望比较对象的地址值，想要结合对象属性进行比较的时候
🔰重写equals方法的方式：

1. alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
2. 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。
   🔰示例代码：

class Student extends Object {
    
   private String name;
   public Student() {
    }
   public Student(String name) {
    this.name = name; }
   public String getName() {
     return name; }
   public void setName(String name) {
    this.name = name; }
   @Override
   public boolean equals(Object o) {
    
       if (this == o) return true;
       if (o == null || getClass() != o.getClass()) return false;
       Student student = (Student) o; //student ­­ s
       return name != null ? name.equals(student.name) : >student.name == null;
   }
}
public class ObjectDemo {
    
   public static void main(String[] args) {
    
       tudent s1 = new Student();
       s1.setName("林青霞");
       Student s2 = new Student();
       s2.setName("林青霞");
//需求：比较两个对象的内容是否相同
       System.out.println(s1.equals(s2));
   }
}

// true

---

(八) Arrays

🔰该类包含用于操作数组的各种方法，如排序和搜索

import java.util.Arrays; // 函数导包(类外)

Arrays.toString(arr);    // 返回指定数组的内容的字符串表示方式
// 输出内容：[11, 12, 23, 34, 43, 76]
Arrays.sort(arr);       // 对数组进行排序

---

(九) 时间日期类

1. Date，SimpleDateFormat

🔰Date 代表了一个特定的时间，精确到毫秒；
🔰SimpleDateFormat是一个具体的类，用于以区域设置敏感的方式格式化和解析日期。

// 创建日期对象(获取当前时间部分时间值)
Date date = new Date();
// 创建对象(对获取的时间进行加工，便于理解)
SimpleDateFormat formats = new SimpleDateFormat(); // 默认：2022/10/14 下午3:07
SimpleDateFormat format = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss"); // 2022年10月14日 15:07:45
// 格式化：将日期格式化成日期/时间的字符串(从Date到String)
String s = formats.format(date);
String ss = format.format(date);
//解析：从给定字符串的开始解析文本以生成日期(从String到Date)
String sss = "2048-08-09 11:11:11";
Date d = format.parse(sss); // 输出结果：Fri Oct 14 15:07:45 CST 2022
System.out.println(s);
System.out.println(ss);

2. Calendar

🔰为操作日历字段提供了一些方法

// 创建日历对象(多态的形式)(获取当前时间段的所有时间值)
Calendar c = Calendar.getInstance();

// 返回给定日历字段的值
int year = c.get(Calendar.YEAR); 
// 将指定的时间量添加或减去给定的日历字段     
c.add(Calendar.YEAR, -3);         
// 自定义当前日历的年月日
c.set(2020, 12, 23);                  

🔰c.get(参数值)

参数值	描述
Calendar.YEAR	指示当前年份
Calendar.MONTH	指示当前月份(+1)，给获取的值 +1
Calendar.DATE	指示当前日期
Calendar.WEEK_OF_YEAR	指示这一个年中的第n个星期
Calendar.WEEK_OF_MONTH	指示这一个月中的第n个星期
Calendar.DAY_OF_MONTH	指示这一个月中的第n天
Calendar.DAY_OF_YEAR	指示这一个年中的第n天
Calendar.DAY_OF_WEEK	指示这一个星期中的第n天(-1)
Calendar.AM_PM	指示HOUR是在中午之前还是中午之后 （上午：0， 下午：1）
Calendar.HOUR	指示上午或下午的小时
Calendar.HOUR_OF_DAY	指示当前一天中的第n小时
Calendar.MINUTE	指示当前一小时中的第n分钟
Calendar.SECOND	指示当前一分钟的第n秒
Calendar.MILLISECOND	指示当前一秒中的第n毫秒

---

(十) File类

🔰File类介绍：
      ● 它是文件和目录路径名的抽象表示
      ● 文件和目录是可以通过File封装成对象的
      ● 对于File而言，其封装的并不是一个真正存在的文件，仅仅是一个路径名而已。它可以是存在的，也可以
是不存在的。将来是要通过具体的操作把这个路径的内容转换为具体存在的

1. File类的构造方法

// 通过将给定的路径名字符串转换为抽象路径名来创建新 的 File实例。
File f1 = new File("E:\\itcast\\java.txt");
// 从父路径名字符串和子路径名字符串创建新的File实例。
File f2 = new File("E:\\itcast","java.txt");
// 从父抽象路径名和子路径名字符串创建新的 File实例。
File f3 = new File("E:\\itcast");
File f4 = new File(f3,"java.txt");

2. File类创建功能

//需求1：我要在E:\\itcast目录下创建一个文件java.txt
File f1 = new File("E:\\ss\\java.txt");
//当具有该名称的文件不存在时，创建一个由该抽象路径名命名的新空文件，并返回true
//当具有该名称的文件存在时，返回false
boolean b = f1.createNewFile(); // 创建新空文件
       
//需求2：我要在E:\\itcast目录下创建一个目录JavaSE
File f2 = new File("E:\\ss\\JavaSE");
//当具有该名称的目录不存在时，创建一个由该抽象路径名命名的新空目录，并返回true
//当具有该名称的目录存在时，返回false
boolean bb = f2.mkdir(); // 创建新空目录
       
//需求3：我要在E:\\itcast目录下创建一个多级目录JavaWEB\\HTML
File f3 = new File("E:\\itcast\\JavaWEB\\HTML");
//当具有该名称的多级目录不存在时，创建一个由该抽象路径名命名的新空多级目录，并返回true
//当具有该名称的多级目录存在时，返回false
boolean bbb = f3.mkdirs(); //创建新空多级目录

3. File类判断和获取功能

🔰判断功能

//创建一个File对象
File f = new File("E:\\ss\\java.txt");

// 测试此抽象路径名表示的File是否为目录，是：返回true
boolean b = f.isDirectory();
// 测试此抽象路径名表示的File是否为文件，是：返回true
boolean bb = f.isFile();
// 测试此抽象路径名表示的File是否存在，是：返回true
boolean bbb = f.exists();

🔰获取功能

//创建一个File对象
File f = new File("ss\\java.txt");
// 返回此抽象路径名的绝对路径名字符串
String s = f.getAbsolutePath();
// 将此抽象路径名转换为路径名字符串
String ss = f.getPath();
// 返回由此抽象路径名表示的文件或目录的名称
String sss = f.getName();
       
File f2 = new File("E:\\ss");
// 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组(包含目录和文件)
String[] strArray = f2.list();
for(String str : strArray) {
    
	System.out.println(str); }

// 返回此抽象路径名表示的目录中的文件和目录的File对象数组(只有文件)
File[] fileArray = f2.listFiles();
for(File file : fileArray) {
    
	if (file.isFile()) {
    
		System.out.println(file.getName());
	}
}

4. File类删除功能

// 在当前模块目录下创建java.txt文件
File f1 = new File("E:\\ss\\java - 副本 (6).txt");
// 删除由此抽象路径名表示的文件或目录，成功，返回true
boolean b = f1.delete();

🔰绝对路径和相对路径的区别:
       ● 绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：E:\itcast\java.txt
       ● 相对路径：必须使用取自其他路径名的信息进行解释。例如：myFile\java.txt

---

(十一) IO流

🔰IO流介绍：
      ◓ IO：输入/输出(Input/Output)
      ◓ 流：是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输
      ◓ IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载
🔰IO流的分类：
      ◓ 按照数据的流向
          ◉ 输入流：读数据
          ◉ 输出流：写数据
      ◓ 按照数据类型来分
          ◉ 字节流
             ● 字节输入流
             ● 字节输出流
          ◉ 字符流
             ● 字符输入流
             ● 字符输出流
🔰IO流的使用场景：
      ◓ 如果操作的是纯文本文件，优先使用字符流
      ◓ 如果操作的是图片、视频、音频等二进制文件。优先使用字节流
      ◓ 如果不确定文件类型，优先使用字节流。字节流是万能的流

1. 字节流写数据

🔰FileOutputStream(String name)：创建文件输出流以指定的名称写入文件；
🔰使用字节输出流写数据的步骤：
      ◓ 创建字节输出流对象(调用系统功能创建了文件，创建字节输出流对象，让字节输出流对象指向文件)
      ◓ 调用字节输出流对象的写数据方法
      ◓ 释放资源(关闭此文件输出流并释放与此流相关联的任何系统资源)

//创建字节输出流对象
FileOutputStream fos = new FileOutputStream("E:\\ss\\fos.txt");
// 做了三件事情：
// A:调用系统功能创建了文件
// B:创建了字节输出流对象
// C:让字节输出流对象指向创建好的文件
fos.write(97); // 将指定的字节写入此文件输出流
// 关闭此文件输出流并释放与此流相关联的任何系统资源。
fos.close();

<