初始Java笔记（java基础笔记）

初始java

Java语言简介：

​ 如今好像都说编程难，但是这种说发会让程序员更容易的找到高薪工作，但是说实话编程并不是和好多人想的那样复杂。如今是学习编程的最佳时机：一方面是我们一个很容易的得到学习资源，另一方面如今的公司即使是在经济紧缩时期，都在招聘程序开发人员。

​ 为什么学习Java，因为Java无处不在：安卓手机上的APP都是使用Java编写的。在安卓手机上，每当你搜索电影，或者是听歌，亦或是玩游戏时，你沉迷其中的就是Java程序员开发的软件。

​ Java似乎是比较难学，但是是一个必学的一门语言，学习Java的一个有事就是你可以**夸操作系统和计算机环境来使用Java。**Java程序可以是桌面软件，web应用程序，Internet服务器，Android APP，可以运行在Windows，Mac，Linux和其他操作系统中。

​ Java语言的另一个重要的优势就是，**你需要一个高度组织化的方法才能让程序运行起来。**如何编写程序以及如何储存和修改数据，对这些东西你一点都不能马虎。

​ Java语言是因为对c++的不满而对其进行改造后的到的，所以说他们两个很相似，值得一提的是，如果学习了一门编程语言，之后你要是学习另一门语言会容易很多，这是因为编程语言之间的思想都是差不多的，认真学完一个语言之后就可以更搞笑的学习另一门编程语言。（需要注意的是：C++是C的增强版）

计算机程序

​ **定义：**计算机程序也叫做软件，它告诉计算机该执行什么任务。

程序的工作原理

​ **源代码：**构成计算机程序的语句集合称为源代码。

​ 为了执行源代码文件，你需要一些帮助，帮助类型取决于你做使用的的编程语言。有些语言需要解释器来运行程序。解释器检查计算机程序的每一行，然后执行该行，然后再检查下一行 解释型语言的最大优势就是可以快速进行测试。 解释型语言的缺点是运行速度比其他程序慢，因为没一行语句都要翻译成计算机可以运行的指令，而且一次只能翻译一行。 其他语言需要编译器， 编译器会将程序翻译成计算机能够理解的格式。它能够使程序尽可能高效地运行，编译后的程序不需要解释器就可以直接运行。 编译后的程序，运行速度要比解释型程序快，但是它需要花费一些时间来测试。

​ Java同时需要编译器和解释器。

​ 虚拟器： 它可以使得相同的Java程序在无需修改的情况下，就能在不同的操作系统和不同的计算机设备上运行。虚拟机将字节码转换成设备的操作系统可以执行的指令。

初始Java程序——Hello World

​ 写一个程序实现在屏幕上打印出“Hello World”这个字符串。下面是代码及对代码的讲解：

public class Hello { // 这是程序的起点，Java解释器必须发现这个定一点，否则将拒绝运行程序。
    public static void main(String args[]){ 
        /* 入股程序的命令中给出了任何自变量（命令参数），它们将被传递给main()
    方法中被称作args的String数组，在本例子中没有使用自变量。
    	static——是一个告知编译器main()是用于类Hello 中的方法的关键字。为了使main()在程序做其它事之前就开始运行，
    这个关键字是必要的。
    	void——表明main()不返回任何信息。这一点很重要，因为Java编程语言要进行谨慎的类型检查，
    包括检查调用的方法确实返回这些方法所声明的类型
    	String args[]——是一个String数组的声明，它将包含位于类名之后的命令行中中自变量。*/
        System.out.println("Hello World!");
        /*声明如何使用类名，对象名和方法调用。它使用由System类的out成员引用的print-Stream对象的println()方法，
     将所要打印的东西答应出来。*/
        
    }
}

代码解释

当然，以下是 public static void main(String[] args) 的详细解释：

• public: 这是一个访问修饰符，表示这个方法对所有类和对象都是可见的。任何其他类都可以直接调用它。

• static: 这也是一个修饰符，表明 main 方法是静态方法，这意味着它属于类本身而不是类的实例。因此，在没有创建类的对象的情况下，可以直接通过类名来调用该方法。

• void: 这个关键字说明 main 方法不返回任何值（即没有返回类型）。

• main: 这是一个特殊的方法名，Java 虚拟机（JVM）在执行 Java 应用程序时会查找并调用这个方法作为程序的入口点。

• String[] args: 这是 main 方法的形式参数，表示一个字符串数组。当我们在命令行中运行 Java 程序时，可以向程序传递一系列参数，这些参数将作为字符串存储在这个数组中。在提供的代码片段中并未使用到 args 参数。

Java基础语法

关键字：Java语言保留的，Java的开发和运行平台认识，并能正确处理的一些词。

Java中的关键字

abstract：表明类或类中的方法是抽象的。

booleam：基本数据类型之一，布尔类型。

byte：基本数据类型之一，字节类型。

case：在switch语句中，表明其中的一个分支。

catch：用于处理例外情况，用来捕捉异常。

char：基本数据类型之一，字符类型。

class：类。

continue：回到一个块的开始处。

default：用在switch语句中，表明一个默认的分支。

do：用在**“do while”**循环结构中。

double：基本数据类型之一，双精度浮点数类型。

else：在条件语句中，表明当条件不成立时的分支。

extends：用来表明一个类是另一个类的子类。

final：用来表明一个类不能派生出子类，或类中的方法不能被覆盖，或声明一个变量或常量。

finally：用于处理异常情况，用来生命一个肯定会被执行到的块。

float：基本数据类型之一，单精度浮点数类型。

for：一种循环结构的引导词。

if：条件语句引导词。

implements：表明一个类实现了给定的接口。

import：表明要访问指定的类或包。

instanceof：用来测试一个对象是否是一个指定类的实例。

int：基本数据类型之一，整数类型。

long：基本数据类型之一，长整数类型。

interface：接口。

native：用来声明一个方法是由与机器相关的语言（如C/C++/FORTRAN语言）实现的。

new：用来申请新对象。

package：包。

private：一种访问方式，私有模式。

protected：一种访问方式，保护模式。

public：一种访问方式，公公模式。

return：从方法中返回的值。

short：基本数据类型之一，短整数类型。

static：表明域或方法是静态的，即该域或方法是属于类的。

strictfp：用来声明FP-strict（双精度或单精度浮点数）表达式，参见IEEE 754算术规范。

super：当前对象的父类对象引用。

switch：分支结构的引导词。

synchronized：表明一段代码的执行需要同步。

this：当前对象的引用。

throw：抛出一个异常。

transient：声明不用序列化的域。

try：尝试一个可能抛出异常的程序块。

void:表明方法不返回值。

volatile：表明两个或多个变量必须同步地发生变化。

while：用在循环结构中。

assert：声明断言。

enum：声明枚举类型。

注意：goto和const不是Java编程语言中使用的关键字，但是是Java的保留字，也就是说Java保留了它们，但是没有使用它们。true和false不是关键字，而是boolean类型量。

标识符：在Java编程语言中，标识符是赋予变量，类或方法的的名称。

标识符命名规则：

• 首字母只能以字母，下划线，$开头，其后可以跟字母‘下划线，$和数字’，示例：$abc, _ba, ab123都是有效的。

• 标识符区分大小写（事实上整个Java编程里面都是区分大小写的）abc和Abc是两个不同的标识符。

• 标识符不能是关键字。

• 标识符长度没有限制。

  标识符的命名建议：

  • 如果你标识符有多个单词过程，那么从第二个单词其首字母大写。
  • 标识符尽量命名的有意义，让人能够望文知意。
  • 尽量少用带有符号的标识符（主要是习惯问题）。
  • 由于Java使用Unicode字符集，所以Unicode字符集支持多种看起来相同的字母，建议标识符中最好使用ASCII字母。
  • 标识符不应该使用中文，虽然是会支持但是会把中文当作Unicode中的符号来对待，导致出现分歧。

Java中的数据类型

整数型

Java中的数据类型和其他编程语言中的数据类型差不多。下面是Java中包含的数据类型。

Java中的基本数据类型分为八个原始数据类型，原始类型可分为四种：

1. 整数型：byte, short, int, long
2. 浮点型：float, double
3. 字符型：char
4. 逻辑型：boolean

注意：整数型的值，如果没有特别指明，默认是int型。

取值范围和默认值：取值范围表示是按Java语言规范定义的且不依赖于平台。

名称	长度	范围	默认值
byte	8位	$-2^7...2^7-1$	0
shotr	16位	$-2^{15}...2^{15}-1$	0
int	32位	$-2^{63}...2^{31}-1$	0
long	64位	$-2{63}…2{63} - 1$0	0

浮点型

浮点型：float，double：Java用浮点数表示实数，简单地说就是带小数的数据。

​ 如果一个数字包括小数点或指数部分，或者在数字后带有字母F或f（float），D或d（double），则该数字文字为浮点型的

注意：浮点型的值，如果没有特别指明，默认是double型的。

取值范围和默认值：

名称	长度	默认值
float	32位	0.0f
double	64位	0.0

字符型：char

​ char类型用来表示单个字符。一个char代表一个16-bit无符号的（不分正负的）Unicode字符，一个char字符必须包含在单引号内。

‘ab’ //这是错误的

Unicode编码又叫统一码，万国码或单一码，是一种在计算机上使用的字符编码。

取值范围和默认值：

名称	长度	范围	默认值
char	16位	Unicode $2^{16}-1$	Unicode 0

Java中的转义字符

**转义字符是指，用一些普通字符的组合来代替一些特殊字符，由于其组合改变了原来字符表示的含义，因此称为“转义”。**常见的转义字符：

转义字符	含义
\n	回车（\u000a）
\t	水平制表符（\u0009）
\b	空格（\u0008）
\r	换行（\u000d）
\f	换页（\u000c）
\’	单引号（\u0027）
\"	双引号（\u0022）
\\	反斜杠（\u005c）

逻辑类型：boolean

​ 逻辑值有两种状态，即人们经常使用的“on”和“off”或“true”和“false”或“yes”和“no”，这样的值是用boolean类型来表示的。

注意：在整数型和boolean类型之间无转换计算。

声明和赋值

声明为Java程序实体引入标识符，能够使用这些名字访问到这些实体，声明实体包括：类名，属性名，方法名，变量名，参数名，接口名等等。简单来说就是定义某个东西并对外宣称它。

赋值就是为一个生命的变量或者常量赋予具体的值，也就是赋予值的意思。使用一个等号“=”来表示。

字符串String

字符串型只能表示一个字符，而用string就可以表示多个字符了。

数据类型示例

public class Assign {
    public static void main(String args[]){
        int x = 0, y = 0;   // 声明int变量
        float z = 3.1415f;  // 声明并赋值float
        double w = 3.1415;  // 声明并赋值double
        boolean truth = true;   // 声明并赋值boolean
        char c;     // 声明字符变量
        String str = "abc";     // 声明String字符串
        String str1 = "bye";    // 声明并赋值string变量
        c = 'A';    // 给字符变量赋值
        System.out.println("x: " + x + ", y: " + y + ", z: " + z + ", truth: " + truth +
                ", w: " + w + ", c: " + c + ", str: " + str + ", str1: " + str1 + ", c: " + c);

    }
}

常量和变量

**常量：**常量是值不可以改变的标识符。

变量：变量是值可以改变的标识符，用来引用一个储存单元，用标识符来表示，可以通过操作变量来操作变量所对应的内存区域或值块的值。

变量的定义规则：

• 遵从所有表示付的规则。
• 所有变量都可大小写混用，但首字母应大写。
• 尽量不要使用些划线和$符号。
• 可以先声明再赋值，如：int i ; i = 9

注释

• // ：注释单行语句
• /* */：多行注释
• /** */：文档注释：紧放在变量， 方法或类的声明之前的文档注释，表示该注释应该放在自动生成的文档中（由javadoc命令生成HTML文件）以当作对声明项的描述。

常用的 javadoc 标记

@author：作者

@version：版本

@deprecated：不推荐使用的方法

@param：方法的参数类型

@return：方法的返回类型

@see：“参见”，用于指定参考的内容

@exception：抛出的异常

@throws：抛出的异常，和 exception 同义

javadoc 标记的应用范围

​ 在类和接口文档注释中的标记有@see @deprecated @author @version

​ 在方法或者构造方法中的标记有:@see @deprecated @param @return @exception

@throws

在属性文档注释中的标记:@see @deprecated

Java编程基本的编码约定：

类——类名应该是名词，大小写可混用，但首字母应大写。

接口——接口名大小写规则与类名相同。

方法——方法名应该是动词，大小写可混用，但首字母小写。在每个方法名内，大写字母将词分隔并限制使用些划线。

变量——所有变量都可大小写混用，但首字母应小写。词由大写字母分隔，限制用下划线，限制使用美元符号，因为这字符对内部类有特殊的含义。变量名应该代表一定的含义。

常量——全部大写并用下划线将词分隔。

控制结构——当语句是控制语句的一部分时，即使是单个语句也应使用括号（{}）将语句封闭。

语句行——每行只写一个语句并使用四个缩进的空格使你的代码更易读。

注释——用注释来说明那些不明显的代码段落。

运算符

分隔符	. [ ] ( ) ; ,
右结合	++ – - ！
左结合	* / %
左结合	+ -
左结合	<< >> >>>
左结合	< > <= => instanceof(Java特有)
左结合	== !=
左结合	&
左结合	^
左结合	|
左结合	&&
左结合	||
右结合	？：
右结合	= *= /= %= += -= <<= >>= >>>= &= *= |=

注意：运算符的结合性决定了同优先级运算符的求值顺序

算数运算符

算数运算符指的是：+、-、*、/ 等基本运算。

​ 注意：%是求mod运算；

​ 整数的除法要小心：

​ 5 / 2 = 2 // 不是2.5

比较运算符

比较运算符指的是：>, <, >=, <=, ==, !=等类似运算

注意：

​ 字符可以比较大小；（用它们的ASCII编码， 化为整数）

​ 小心浮点数的相等比较

​ instanceof也是一个比较运算,用来判断一个对象是否属于某个类.

逻辑运算符

**运算符&&(定义为’与’)和||(定义为’或’)**执行布尔逻辑表达式.

++,–运算

++运算相当于:运算的变量加1.

–运算恰好相反,相当于运算的变量减1.

**注意:**x++ 和 ++x 并不是一回事.(前者先使用后增,后者想增在使用.)

三目运算 ? :

三目运算? : 表达的是：判断问号前面的条件表达式是否为真, 如果为真, 则返回冒号前面的值,否则返回冒号后面的值.

控制语句

​ 在Java中，控制语句用于控制程序的执行流程，主要包括条件语句（if, else, switch）和循环语句（for, while, do-while）。这些语句允许程序根据不同的条件执行不同的代码。

分支控制语句

​ 分支控制语句允许程序在满足特定条件时执行不同的代码路径。

• if语句：最基本的条件语句，用于在条件为真时执行代码块。

if (条件) {
    // 当条件为真是执行的代码
}

• if-else 语句：在条件为假时提供另一种执行路径。

if (条件) {
    // 当条件为真时执行的代码
}
else {
    //当条件为假时执行的代码
}

也可以是多个if-else语句连着用

• switch语句：用于基于变量的值选择执行不同代码的条件选择。

switch (变量) {
    case 值1:
        // 当变量值等于1时执行的代码块
        break;
    case 值2:
        // 当变量值等于2时执行的代码块
        break;
    // 更多case……
    default:
        // 如果没有匹配的case，执行这里的代码
        break;
}

• 循环控制语句

循环控制语句允许程序重复执行一段代码，直到满足某个条件。

• for循环：在已知循环次数的情况下使用。

for (初始化表达式; 循环条件; 更新表达式) {
    // 循环体
}

• while循环：在循环次数未知，但有明确退出条件时使用。

while (循环条件) {
    // 循环体
}

• do- while循环：至少执行一次循环体，然后根据条件决定是否继续循环。

do {
    //循环体
}
while (循环条件) ;

• 循环控制语句的特殊用法

  • break语句： 用于立即退出循环（for， while， do-while， switch）。

  • // 在循环中使用break
    if (需要退出循环){
        break;
    }
    

  • continue语句： 用于跳过当前循环的剩余部分，直接开始下一个循环。

  • // 在循环中使用continue
    if (需要跳过本次循环) {
        continue;
    }
    

  • label（标签）： 用于标识循环，与break和continue结合使用，可以跳出多层或跳过特定循环。

   outerLoop: for (int i = 0; i < 10; i++){
       innerLoop: for(int j = 0; j < 10: j++)
           // 使用标签
           if (需要退出外层循环) {
               break outerLoop;
           // 使用标签
            if(需要跳出内层循环){
                continue innerLoop
            }
           }
   }
   ```

### 数组和集合

​	在Java中，数组和集合时储存和操作数据的重要数据结构。它们允许你以一种有序的方式储存多个数据项。

#### 数组（Arrays）

​	数组是一种基本的数据结构，用于储存固定大小的同类型元素集合。数组在声明时需要指定大小和数据类型。

- **声明数组：**

```java
int [] numbers;		// 声明一整形数组
numbers = new int[10];		//创建一个大小为10的整形数组

• 初始化数组：

int[] numbers = {1, 2, 3, 4, 5};	// 直接初始化

• 访问数组元素：

int firstElement = numbers[0];	//获取第一个元素
numbers[2] = 6;	//修改第三个元素的值

• 遍历数组：

for (int i = 0; i < numbers.length; i++) {
    System.out.println(number[i])
}

• 多维数组：

int[][] matrix = new int[3][3];		//创建一个3x3的二维数组

集合（Collections）

​ 集合是Java提供的一种灵活的数据结构，它允许动态地添加和删除元素。Java集合框架提供了多种集合类型，如List， Set， Map等。

• List：有序集合，允许重复元素。

list<String> names = new ArrayList<>();		// 创建一个字符串列表
names.add("Alice"); 	//添加元素
names.remove("Bob"); 	//删除元素

• Set：无序集合，不允许重复元素。

Set<String> uniqueNames = new HashSet<>(); 	// 创建一个字符串集合
uniqueNames.add("Alice"); 	// 添加元素，不会添加重复的“Alice”

• **Map：**键值对集合，每一个元素由唯一的键和值组成。

Map<String, Integer> ages = new HashMap<>(); 	// 创建一个字符串到整数的映射
ages.put("Alice", 25); 	// 添加键值对
int age = ages.get("Alice"); 	// 获取键为“Alice”的值

• 迭代集合：

for(String name : names) {
    System.out.println(name);
}

​ 集合框架提供了多种方法来操作集合，如添加， 删除，查找和遍历元素。使用集合可以有效的管理数据，特别是在需要频繁修改数据结构时。

方法（Method）

​ 在Java中，方法（Method）是执行特定任务的代码块，它可以被其他代码调用。方法的封装使得代码更加模块化，易于维护和重用。

方法的基本结构

• 声明方法：

returnType methdodName(parameterList) {
    // 方法体
    return result; // 如果返回值
}

• 返回类型：方法执行后可以返回的数据类型，如int， String， void（无返回值）等。
• 方法名：方法的标识符，遵循Java的命名规则。
• 参数列表：方法可以接受的输入值，可以有多个参数，用逗号分隔。
• 方法体：包括执行任务代码。
• 返回值：方法执行完成后返回的结果。

方法的重载（Overloading）

​ 方法重载允许在同一个类中定义多个同名的方法，只要它们的参数列表不同（参数类型，数量或顺序）。

• 重载示例：

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
    public double add(double a, double b) {
        return a + b;
    }
}

• 递归示例：

public class Factorial {
    public static int factorial(int n) {
        if (n == 1) {
            return 1;
        } else {
            return n * factorial(n - 1);
        }
    }
}

方法的调用

​ 方法调用是通过传递参数给方法，然后执行方法体中的代码。

• 调用示例：

public class Test {
    public static void main(String[] args) {
        int sum = Calculator.add(5, 3);
        // 调用Calculator类的add方法
        System.out.println(sum);
        // 输出结果
    }
}

方法的参数传递

​ Java方法参数传递有两种方法：值传递（Pass by Value）和引用传递（Pass by Reference）。

• 值传递：传递的是参数的副本，修改副本不影响原始数据。
• 引用传递：传递的是对象的引用，修改引用指向的对象会影响原始数据。

方法的调用

​ 方法调用是通过传递参数给方法，然后执行方法体中的代码。

• 调用示例：

public class Test {
    public static void main(String[] args) {
        int sum = Calculator.add(5, 3);
        // 调用Calculator类的add方法
        System.out.println(sum);
        // 输出结果
    }
}

方法的参数传递

​ Java方法参数传递有两种方法：值传递（Pass by Value）和引用传递（Pass by Reference）。

• 值传递：传递的是参数的副本，修改副本不影响原始数据。
• 引用传递：传递的是对象的引用，修改引用指向的对象会影响原始数据。