Java学习day01

Java介绍

Java 是由 Sun公司于 1995 年 5 月推出的 Java 面向对象程序设计语言和 Java 平台的总称。由 James Gosling（Java之父）和同事们共同研发，并在 1995 年正式推出。后来 Sun 公司被 Oracle （甲骨文）公司收购，Java 也随之成为 Oracle 公司的产品。

面向对象编程语言

面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将程序中的数据和操作数据的方法组织在一起，形成对象。面向对象编程强调数据的封装性、继承性和多态性。一些关键概念：类（class），对象（object），封装（encapsulation），继承（inheritance），多态（polymorphism）。

编译解释型语言

Java使用了先编译为字节码再解释执行的方式（Java虚拟机运行时）。

Java三个平台版本

JavaSE

Java Standard Edition（Java平台标准版），它允许开发和部署在桌面、服务器、嵌入式环境和实时环境中使用的Java应用程序。Java包含了支持Java WEB服务开发的类，并为JavaEE和JavaME提供基础。

JavaEE

Java Enterprise Edition（Java平台企业版），Java EE是针对企业级应用开发的平台。它构建在Java SE的基础之上，提供了大量的扩展API和服务，用于开发复杂的分布式、事务性和可伸缩的企业应用。Java EE包括各种规范和技术，如Servlet、JSP、EJB、JPA、JMS等，以及用于构建Web服务、企业级安全、事务管理等功能的组件。Java EE适用于开发大型企业级应用、Web应用程序和服务端应用程序。

JavaME

Java Micro Edition（Java平台微型版），是面向嵌入式设备和移动设备的Java平台。它针对资源受限的设备，例如智能手机、嵌入式系统和物联网设备，提供了一个轻量级的Java运行环境和相关的库。Java ME的特点是占用资源少、体积小、适应性强，可以在资源有限的设备上运行Java应用程序。Java ME包括一系列的配置和配置文件，可以根据设备的特性和需求进行定制。

区别及联系

这三个平台版本在功能和目标上有所区别，适用于不同的应用场景。Java SE是Java的基础，用于开发通用应用程序；Java EE是针对企业级应用的扩展，提供了更多的功能和服务；Java ME则专注于嵌入式和移动设备的开发。开发者可以根据具体的需求选择适合的平台版本进行开发。

Java代码的运行过程

源程序(.java)——>编译器——>字节码(.class)

编译

源代码编写完成后，需要使用Java编译器（例如javac命令）将源代码编译成字节码文件。字节码是一种与特定平台无关的中间代码，以扩展名为".class"的二进制文件存储。

执行

JVM负责加载、校验字节码文件，一旦验证通过，JVM会按照指令逐行执行字节码。最终输出程序的运行结果

JDK、JRE、JVM

JDK

Java开发工具集（Java Development Kits）。包括：Java编译器、Java运行时解释器、Java应用程序编程接口、Java文档化工具、其他工具及资源。对于开发者来说，JDK 是必需的，因为它提供了编译和构建 Java 程序的工具。

JRE

Java运行时环境(Java Runtime Environment)。包含三项主要功能：加载代码、校验代码、执行代码。JRE 是 Java 程序运行所需的最小环境。JRE 包含了 JVM 和运行 Java 程序所需的类库和支持文件，但不包含开发工具。如果只是需要运行已编译的 Java 程序而不进行开发，那么只需要安装 JRE 即可。

JVM

Java Virtual Machine(Java虚拟机)是在一台计算机上由软件或硬件模拟的计算机，用于读取并处理经编译的字节码class文件。JVM提供了内存管理、垃圾回收、线程管理和异常处理等运行时支持。JVM 的存在使得 Java 程序能够在不同的硬件和操作系统上运行，实现了 Java 的跨平台特性。

Java编译器针对Java虚拟机产生class文件，所以是独立于平台的。

Java解释器负责将Java虚拟机产生的代码在特定的平台上运行。

三者的关系

JDK包含了JRE，JRE包含了JVM。JDK 是用于开发 Java 程序的工具包，JVM 是用于运行 Java 程序的虚拟机，而 JRE 则是运行 Java 程序所需的最小环境。在开发过程中，需要安装 JDK，而在部署和运行 Java 程序时，只需要安装 JRE。

---

环境搭建

环境变量

**环境变量（environment variables）**一般是指在操作系统中用来指定系统运行环境的一些参数（变量）；环境变量在系统中通常具有全局特性。

关于IDEA

快速生成入口方法：main+enter

快速生成输出语句：sout+enter

---

Java基础语法

注释

Java 支持三种类型的注释：单行注释、多行注释和文档注释。

1. 单行注释：

   使用双斜线 // 开始，直到行尾结束。

   单行注释通常用于在代码中添加简短的解释、注释掉单行代码或进行调试。

   示例：

   // 这是一个单行注释
   int x = 10; // 初始化变量 x
   

2. 多行注释：

   使用斜线加星号 /* 开始，星号加斜线 */ 结束。

   多行注释可以跨越多行，用于注释较长的代码块。

   示例：

   /*
    * 这是一个多行注释
    * 它可以跨越多行
    */
   int y = 20; // 初始化变量 y
   

3. 文档注释：

   使用斜线加星号加两个星号 /** 开始，星号加斜线 */ 结束。

   文档注释是一种特殊的注释，可以用来生成代码文档。

   文档注释可以包含类、方法、字段等的详细描述、参数说明、返回值说明等。

   示例：

   /**
    * 这是一个文档注释示例
    * 它可以用来生成代码文档
    */
   public class MyClass {
       /**
        * 这是一个方法的文档注释
        * @param x 参数 x
        * @param y 参数 y
        * @return 返回结果
        */
       public int myMethod(int x, int y) {
           // 方法体
       }
   }
   

注释在 Java 程序中起到了以下作用：

• 提高代码的可读性：注释可以向其他开发者或自己解释代码的意图和逻辑，使代码更易于理解和维护。

• 帮助调试和排错：通过在代码中添加注释，可以标记出可能引起问题的地方，以便更轻松地进行调试和排错。

• 自动生成文档：文档注释可以通过工具生成代码文档，帮助其他开发人员了解如何使用你的代码。

标识符

在 Java 编程中，标识符（Identifier）是用来标识变量、方法、类、包等程序元素的名称。标识符是由一系列字符组成的，遵循一定的命名规则和约定。

Java 的标识符命名规则如下：

1. 标识符可以包含以下字符：

   • 大写字母 A-Z

   • 小写字母 a-z

   • 数字 0-9（但不能作为首字母）

   • 下划线 _

   • 美元符号 $（在某些情况下可以使用，但不推荐）

2. 标识符的命名规范：

   • 标识符可以由字母、数字、下划线和美元符号组成，但不能以数字开头。
   • 标识符区分大小写，例如 myVariable 和 myvariable 是不同的标识符。
   • 标识符应具有描述性，能够清晰表达其所代表的含义。
   • 标识符不应与 Java 的关键字和保留字冲突，例如 if、for、class 等。

3. 命名约定：

   • 类名：采用驼峰命名法（Camel Case），首字母大写，例如 MyClass。
   • 方法名和变量名：采用驼峰命名法，首字母小写，例如 myMethod、myVariable。
   • 常量名：通常使用全大写字母，单词间用下划线分隔，例如 MAX_VALUE。
   • 包名：采用全小写字母，单词间用点号 . 分隔，例如 com.example.myproject。

以下是一些示例合法的标识符：

int myVariable;
String firstName;
double PI;
MyClass myObject;

需要注意的是，Java 的标识符应当具有一定的规范性和可读性，以提高代码的可理解性和可维护性。选择有意义的标识符名称能够使代码更易于阅读和理解，有助于团队协作和代码维护。

关键字

类和接口相关：

关键字	说明	关键字	说明
class	类定义	interface	接口定义
enum	枚举类型定义	extends	类继承
implements	类实现接口	new	创建对象

数据类型和修饰符：

关键字	说明	关键字	说明
boolean	布尔类型	double	双精度浮点型
byte	字节类型	float	单精度浮点型
char	字符类型	int	整型
short	短整型	long	长整型
final	不可更改	static	静态
volatile	可变	transient	不被序列化
public	公共访问权限	private	私有访问权限
protected	受保护访问权限	abstract	抽象类

条件和循环控制：

关键字	说明	关键字	说明
if	条件判断	switch	多路分支选择
else	条件分支	case	分支选择
default	默认分支	while	循环
do	循环	for	循环
break	跳出循环	continue	继续下一次循环
return	返回值	assert	断言
instanceof	类型判断	synchronized	同步方法块
try	异常处理	catch	捕获异常
finally	异常处理完毕	throw	抛出异常
throws	方法声明异常

**注意：**goto和const虽然从未被使用但也被作为关键字保留，也不能使用。

变量

变量就是值可以改变的值。作用是存储程序在运行中所需要的值，也可以对值进行改变，进而改变程序的运行结果或运行流程。

**注意：**变量在使用之前必须先声明并赋值。如果在使用变量之前尝试访问它们，将会引发编译错误。

分类

1. 局部变量（Local Variables）：局部变量是在方法、构造函数或代码块内部声明的变量。它们只在声明的方法、构造函数或代码块内部可见。局部变量必须在使用之前进行初始化，并且在声明的方法、构造函数或代码块执行完毕后会被销毁。

   void exampleMethod() {
       int age = 25; // 局部变量
       System.out.println(age);
   }
   

2. 成员变量（Instance Variables）：成员变量是在类内部、方法外部声明的变量。它们属于对象实例，每个对象都有自己的一份成员变量副本。成员变量可以通过创建对象实例来访问，它们的值在对象创建时被初始化，并且在对象的整个生命周期内保持存在。

   class ExampleClass {
       int age; // 成员变量
   
       void exampleMethod() {
           System.out.println(age); // 可以访问成员变量
       }
   }
   

3. 静态变量（Static Variables）：静态变量是使用static关键字修饰的变量，它们属于类而不是对象实例。静态变量在类加载时被初始化，它们的值对于所有对象实例来说是共享的。可以通过类名直接访问静态变量。

   class ExampleClass {
       static int count; // 静态变量
   
       void exampleMethod() {
           System.out.println(count); // 可以访问静态变量
       }
   }
   

4. 参数变量（Parameters）：参数变量是在方法或构造函数的声明中定义的变量。它们用于接收调用方法或构造函数时传递的参数值，并在方法或构造函数内部使用。参数变量的作用范围限于方法或构造函数内部。

   void exampleMethod(int age) { // 参数变量
       System.out.println(age);
   }
   

此外，在Java中还有一种特殊的变量称为类变量（Class Variables），它是指使用static关键字修饰的静态变量。类变量属于类本身，而不是对象实例。它们在类加载时初始化，且对于所有对象实例来说是共享的。

引用变量

在Java中，引用变量是一种特殊类型的变量，用于存储对象的引用或地址。与基本数据类型（如整数、浮点数等）不同，引用变量并不直接存储实际的数据值，而是存储对象在内存中的地址。

当创建一个对象时，实际的对象数据被存储在堆内存中，而引用变量则存储了该对象在堆内存中的地址。通过引用变量，我们可以间接地访问和操作对象的属性和方法。

示例：

class Person {
    String name;
    int age;
}

public class Example {
    public static void main(String[] args) {
        Person person1 = new Person(); // 创建一个Person对象
        person1.name = "John";
        person1.age = 25;

        Person person2 = person1; // 引用变量person2指向同一个对象

        System.out.println(person1.name); // 输出 "John"
        System.out.println(person2.age);  // 输出 25

        person2.name = "Alice"; // 修改通过person2引用的对象的属性

        System.out.println(person1.name); // 输出 "Alice"，因为person1和person2引用同一个对象
    }
}

在上面的示例中，我们创建了一个Person类的对象，并使用引用变量person1和person2来引用该对象。person1和person2实际上都保存了对象在堆内存中的地址。因此，通过任一引用变量，我们可以访问和修改对象的属性。

需要注意的是，引用变量本身不存储对象的数据，而是指向对象的地址。当没有任何引用变量指向一个对象时，该对象将成为垃圾，最终会被Java的垃圾回收机制回收释放内存空间。

引用变量是Java中非常重要的概念，它使得我们能够处理和操作复杂的对象数据结构。

变量声明

Java是一门强类型的编程语言，每个变量都必须声明类型
格式：
<数据类型> <变量名>；（只声明，不初始化）
<数据类型> <变量名> = <值>；（声明的同时初始化）
<数据类型> <变量名1>,<变量名2>；（同时声明多个同类型变量）

示例：

// 声明和初始化一个整型变量
int age = 25;

// 声明一个字符串变量
String name;

// 给字符串变量赋值
name = "John Smith";

// 同时声明多个变量
int age1 = 18,age2 = 20;

变量类型

在Java中，有多种变量类型可供使用，每种类型用于存储不同种类的数据。以下是Java中常见的变量类型：

1. 基本数据类型（Primitive Data Types）：Java提供了一组基本的数据类型，用于存储简单的数据值。基本数据类型包括：

   • 整数类型：byte、short、int、long
   • 浮点数类型：float、double
   • 字符类型：char
   • 布尔类型：boolean

   基本数据类型具有固定的内存大小，用于存储整数、浮点数、字符和布尔值等简单数据。

2. 引用数据类型（Reference Data Types）：引用数据类型用于存储对象的引用或地址。引用数据类型包括：

   • 类：用于创建自定义类的对象。
   • 接口：用于定义接口并实现多态。
   • 数组：用于存储多个相同类型的元素。

   引用数据类型存储了对象在内存中的地址，通过引用可以访问和操作对象的属性和方法。

3. 字符串类型（String）：字符串类型是一种特殊的引用数据类型，用于存储文本数据。在Java中，字符串类型被定义为String类，它提供了许多方法用于处理字符串。

4. 数组类型（Array）：数组类型用于存储多个相同类型的元素。在Java中，数组是一个固定长度的对象，它可以存储基本数据类型或引用数据类型的元素。

5. 枚举类型（Enum）：枚举类型用于定义一组命名的常量。枚举类型在Java中是一种特殊的类，它可以包含枚举常量，并提供了一些方法和属性。

命名规范

• 遵循标识符的命名规范

• 同一作用域中变量名不能重复

变量作用域

在Java中，每个变量都有其作用域（Scope），即变量的可见性和有效性范围。变量的作用域定义了在程序中哪些部分可以引用该变量。

Java中的变量作用域可以分为以下几种：

1. 类级作用域（Class-level Scope）：类级作用域的变量在整个类中都可见和可访问。这些变量通常被称为类变量或静态变量，使用static关键字声明。类级作用域的变量可以被类的任何方法、构造函数或静态方法引用。
2. 实例级作用域（Instance-level Scope）：实例级作用域的变量在类的实例（对象）中可见和可访问。这些变量通常被称为实例变量，它们属于类的每个实例。实例级作用域的变量可以在类的任何非静态方法、构造函数或实例方法中引用。
3. 局部作用域（Local Scope）：局部作用域的变量仅在其定义的块或方法内可见和可访问。这些变量通常被称为局部变量。局部变量在方法、循环、条件语句等代码块中声明，并且只在声明的块中有效。局部变量在声明后初始化，并且在声明的块结束后不再可用。
4. 方法参数作用域（Method Parameter Scope）：方法参数作用域的变量是在方法声明中定义的参数。它们在方法中起到类似于局部变量的作用。方法参数的作用域仅限于方法内部。

示例：

public class Example {
    // 类级作用域的变量（类变量）
    static int classVariable;

    // 实例级作用域的变量（实例变量）
    int instanceVariable;

    public void method() {
        // 局部作用域的变量（局部变量）
        int localVariable = 10;

        // 方法参数作用域的变量
        // 参数x的作用域仅限于该方法内部
    }
}

常量

在Java中，常量是指在程序执行过程中其值不能被修改的变量。常量在程序中具有固定的值，一旦被定义，就无法再更改。Java中的常量通常使用final关键字进行声明。

以下是Java中定义常量的两种常见方式：

1. 常量变量：常量变量是使用final关键字声明的变量，它的值在声明后不能再次被修改。通常使用大写字母表示常量的名称，多个单词之间使用下划线分隔。

final int MAX_VALUE = 100;
final double PI = 3.14159;
final String MESSAGE = "Hello, World!";

2. 常量字段：常量字段是使用static final关键字声明的类级变量。它们在整个类中都可见和可访问，且其值在程序执行期间不可更改。

public class Constants {
    public static final int MAX_VALUE = 100;
    public static final double PI = 3.14159;
    public static final String MESSAGE = "Hello, World!";
}

常量的好处是可以提高代码的可读性、可维护性和可重用性。通过使用常量，可以避免魔术数（Magic Numbers）和重复的字面量，使代码更具可读性，并且如果需要修改常量的值，只需在定义处修改即可，无需在整个代码中搜索和替换

public class Test {
    public static void main(String[] args) {
        //Java中常见的常量
        System.out.println("整型常量："+10);
        //八进制表示：0+数字
        System.out.println("八进制表示："+010);
        //十六进制：0X或0x+数字
        System.out.println("十六进制："+0x10);
        //字符常量 用单引号表示
        System.out.println("字符常量："+'a');
        //字符串常量 用双引号表示
        System.out.println("字符串常量："+"hello");
        //布尔类型常量 true false
        System.out.println("布尔类型常量："+true);

        //使用final修饰的变量为常量
        final int num = 10;
        //修改num的值会报错 语法错误：常量的值不可改变
    }
}