java学习笔记

| 目录名称 | 说明 |
| -------- | ------------------------------------------------------------ |
| bin | 该路径下存放了JDK的各种工具命令。javac和java就放在这个目录。 |
| conf | 该路径下存放了JDK的相关配置文件。 |
| include | 该路径下存放了一些平台特定的头文件。 |
| jmods | 该路径下存放了JDK的各种模块。 |
| legal | 该路径下存放了JDK各模块的授权文档。 |
| lib | 该路径下存放了JDK工具的一些补充JAR包。 |

### 1.3 HelloWorld小案例

HelloWorld案例是指在计算机屏幕上输出“HelloWorld”这行文字。各种计算机语言都习惯使用该案例作为第一个演示案例。

#### 2.3.1 Java程序开发运行流程

开发Java程序，需要三个步骤：编写程序，编译程序，运行程序。

#### 2.3.2 HelloWorld案例的编写

1. 新建文本文档文件，修改名称为HelloWorld.java。

**注意**：后缀名为java的才是java文件。

2. 用记事本打开HelloWorld.java文件，输写程序内容。

**注意**：代码要跟我编写的完全保持一致。

```java
public class HelloWorld {
   public static void main(String[] args) {
       System.out.println("HelloWorld");
   }
}
```

3. 保存

**注意**：未保存的文件在左上角会有*符号标记

4. 编译文件。编译后会产生一个class文件。

java文件：程序员自己编写的代码。

class文件：交给计算机执行的文件。

5. 运行代码

**注意**：运行的是编译之后的class文件。

> 用到两个命令：
>
> javac + 文件名 + 后缀名（就是编译java文件）
>
> java + 文件名（运行编译之后的class文件）

# Java基础语法

## 1. 注释

注释是对代码的解释和说明文字。

Java中的注释分为三种：

* 单行注释：

~~~java
// 这是单行注释文字
~~~

* 多行注释：

~~~java
/*
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
注意：多行注释不能嵌套使用。
~~~

* 文档注释（暂时用不到）：

```java
/**
这是多行注释文字
这是多行注释文字
这是多行注释文字
*/
```

### 使用的技巧

如果我们要对代码进行解释，那么就可以使用注释。

当注释的内容比较少，一行就写完了，可以用单行注释。

如果注释的内容比较多，需要写在多行，那么可以使用多行注释。

### 注意点

注释的内容不会参与编译和运行的，仅仅是对代码的解释说明而已。

所以，不管在注释当中写什么内容，都不会影响代码运行的结果。

## 2. 关键字

### 2.1 概念

被Java赋予了特定含义的英文单词。

当我们在代码中写了关键字之后，程序在运行的时候，就知道要做什么事情了。

注意：关键字很多，不用刻意去记。

| **abstract** | **assert** | **boolean** | **break** | **byte** |
| -------------- | ---------------- | ------------- | -------------- | ---------- |
| **case** | **catch** | **char** | **class** | **const** |
| **continue** | **default** | **do** | **double** | **else** |
| **enum** | **extends** | **final** | **finally** | **float** |
| **for** | **goto** | **if** | **implements** | **import** |
| **instanceof** | **int** | **interface** | **long** | **native** |
| **new** | **package** | **private** | **protected** | **public** |
| **return** | **strictfp** | **short** | **static** | **super** |
| **switch** | **synchronized** | **this** | **throw** | **throws** |
| **transient** | **try** | **void** | **volatile** | **while** |

### 2.2 第一个关键字class

表示定义一个类。创建一个类。

类：Java项目最基本的组成单元，一个完整的Java项目有可能会有成千上万个类来组成的。

class后面跟随的就是这个类的名字，简称：类名。

在类名后面会有一对大括号，表示这个类的内容。

举例：

```java
public class HelloWorld{

}
```

解释：class表示定义类。

类名：HelloWorld

HelloWorld后面的大括号表示这个类的范围。

## 3. 字面量

作用：告诉程序员，数据在程序中的书写格式。

| **字面量类型** | **说明** | **程序中的写法** |
| -------------- | ----------------------------------------- | -------------------------- |
| 整数 | 不带小数的数字 | 666，-88 |
| 小数 | 带小数的数字 | 13.14，-5.21 |
| 字符 | 必须使用单引号，有且仅能一个字符 | ‘A’，‘0’， ‘我’ |
| 字符串 | 必须使用双引号，内容可有可无 | “HelloWorld”，“黑马程序员” |
| 布尔值 | 布尔值，表示真假，只有两个值：true，false | true 、false |
| 空值 | 一个特殊的值，空值 | 值是：null |

~~~java
public class Demo {
public static void main(String[] args) {
System.out.println(10); // 输出一个整数
System.out.println(5.5); // 输出一个小数
System.out.println('a'); // 输出一个字符
System.out.println(true); // 输出boolean值true
System.out.println("欢迎来到黑马程序员"); // 输出字符串
}
}
~~~

### 区分技巧

1. 不带小数点的数字都是整数类型的字面量。
2. 只要带了小数点，那么就是小数类型的字面量。
3. 只要用双引号引起来的，不管里面的内容是什么，不管里面有没有内容，都是字符串类型的字面量。
4. 字符类型的字面量必须用单引号引起来，不管内容是什么，但是个数有且只能有一个。
5. 字符类型的字面量只有两个值，true、false。
6. 空类型的字面量只有一个值，null。

## 4. 变量

### 4.1 什么是变量？

变量就在程序中临时存储数据的容器。但是这个容器中只能存一个值。

### 4.2 变量的定义格式

数据类型变量名 = 数据值；

#### 4.2.1 格式详解

数据类型：限定了变量当中能存储什么类型的数据。

如果要存10，那么数据类型就需要写整数类型。

如果要存10.0，那么数据类型就需要写小数类型。

变量名：其实就是这个容器的名字。

当以后想要使用变量里面的数据时，直接使用变量名就可以了。

数据值：真正存储在容器中的数据。

分号：表示语句的结束，就跟以前写作文时候的句号是一样的。

#### 4.2.2 常用的数据类型

整数：int

小数：（浮点数）double

其他数据类型稍后讲解

举例：

```java
public class VariableDemo{
   public static void main(String[] args){
       //定义一个整数类型的变量
       //数据类型变量名 = 数据值;
       int a = 16;
       System.out.println(a);//16

       //定义一个小数类型的变量
       double b = 10.1;
       System.out.println(b);//10.1
   }
}
```

#### 4.2.3 变量的注意事项

- 变量名不能重复
- 在一条语句中，可以定义多个变量。但是这种方式影响代码的阅读，所以了解一下即可。
- 变量在使用之前必须要赋值。

案例：

```java
public class VariableDemo2{
   public static void main(String[] args){
       //1.变量名不允许重复
       //int a = 10;
       //int a = 20;
       //System.out.println(a);

       //2.一条语句可以定义多个变量
       //了解。
       //int a = 10, b = 20, c = 20,d = 20;
       //System.out.println(a);//?
       //System.out.println(b);//?


       //3.变量在使用之前必须要赋值
       int a = 30;
       System.out.println(a);
   }
}
```

### 4.3 变量的练习

需求：说出公交车到终点站之后，车上一共有多少乘客？

一开始没有乘客。

第一站：上去一位乘客，没有下来乘客。

第二站：上去两位乘客，下来一位乘客。

第三站：上去两位乘客，下来一位乘客。

第四站：没有上去乘客，下来一位乘客。

第五站：上去一位乘客，没有下来乘客。

问：到了终点站之后，车上一共多少乘客？

代码解析：

```java
public class VariableTest1{
   //主入口
   public static void main(String[] args){
       //一开始没有乘客。
       int count = 0;
       //第一站：上去一位乘客
       //在原有的基础上 + 1
       count = count + 1;
       //System.out.println(count);
       //第二站：上去两位乘客，下来一位乘客
       count = count + 2 - 1;
       //第三站：上去两位乘客，下来一位乘客
       count = count + 2 - 1;
       //第四站：下来一位乘客
       count = count - 1;
       //第五站：上去一位乘客
       count = count + 1;
       //请问：到了终点站，车上一共几位乘客。
       System.out.println(count);//3
   }
}
```

## 5. 数据类型

### 5.1 Java语言数据类型的分类

- 基本数据类型
- 引用数据类型（面向对象的时候再深入学习）

### 5.2 基本数据类型的四类八种

| 数据类型 | 关键字 | 内存占用 | 取值范围 |
| :------: | :-----: | :------: | :---------------------------------------: |
| 整数 | byte | 1 | 负的2的7次方 ~ 2的7次方-1(-128~127) |
| | short | 2 | 负的2的15次方 ~ 2的15次方-1(-32768~32767) |
| | int | 4 | 负的2的31次方 ~ 2的31次方-1 |
| | long | 8 | 负的2的63次方 ~ 2的63次方-1 |
| 浮点数 | float | 4 | 1.401298e-45 ~ 3.402823e+38 |
| | double | 8 | 4.9000000e-324 ~ 1.797693e+308 |
| 字符 | char | 2 | 0-65535 |
| 布尔 | boolean | 1 | true，false |

#### 说明

e+38表示是乘以10的38次方，同样，e-45表示乘以10的负45次方。

在java中整数默认是int类型，浮点数默认是double类型。

#### 需要记忆以下几点

byte类型的取值范围：

-128 ~ 127

int类型的大概取值范围：

-21亿多 ~ 21亿多

整数类型和小数类型的取值范围大小关系：

double > float > long > int > short > byte

最为常用的数据类型选择：

- 在定义变量的时候，要根据实际的情况来选择不同类型的变量。

比如：人的年龄，可以选择byte类型。

比如：地球的年龄，可以选择long类型。

- 如果整数类型中，不太确定范围，那么默认使用int类型。

- 如果小数类型中，不太确定范围，那么默认使用double类型。

- 如果要定义字符类型的变量，那么使用char

- 如果要定义布尔类型的变量，那么使用boolean

### 5.3 定义8种基本数据类型变量

```java
public class VariableDemo3{
public static void main(String[] args){
//1.定义byte类型的变量
//数据类型变量名 = 数据值;
byte a = 10;
System.out.println(a);

//2.定义short类型的变量
short b = 20;
System.out.println(b);

//3.定义int类型的变量
int c = 30;
System.out.println(c);

//4.定义long类型的变量
long d = 123456789123456789L;
System.out.println(d);

//5.定义float类型的变量
float e = 10.1F;
System.out.println(e);

//6.定义double类型的变量
double f = 20.3;
System.out.println(f);

//7.定义char类型的变量
char g = 'a';
System.out.println(g);

//8.定义boolean类型的变量
boolean h = true;
System.out.println(h);

}
}
```

#### **注意点**

- 如果要定义一个整数类型的变量，不知道选择哪种数据类型了，默认使用int。
- 如果要定义一个小数类型的变量，不知道选择哪种数据类型了，默认使用double。
- 如果要定义一个long类型的变量，那么在数据值的后面需要加上L后缀。（大小写都可以，建议大写。）
- 如果要定义一个float类型的变量，那么在数据值的后面需要加上F后缀。（大小写都可以）

# 1.运算符和表达式

## 运算符：

就是对常量或者变量进行操作的符号。

比如： + - * /

## 表达式：

用运算符把常量或者变量连接起来的，符合Java语法的式子就是表达式。

比如：a + b 这个整体就是表达式。

而其中+是算术运算符的一种，所以这个表达式也称之为算术表达式。

# 2.算术运算符

分类：

```java
+ - * / %
```

运算特点：

```java
+ - * :跟小学数学中一模一样没有任何区别.
```

```java
/：
1.整数相除结果只能得到整除，如果结果想要是小数，必须要有小数参数。
2.小数直接参与运算，得到的结果有可能是不精确的。
案例：
System.out.println( 10 / 3);//3
System.out.println(10.0 / 3);//3.3333333333333335
```

```java
%：取模、取余。
他做的也是除法运算，只不过获取的是余数而已。
案例：
System.out.println(10 % 2);//0
System.out.println(10 % 3);//1
应用场景：
//可以利用取模来判断一个数是奇数还是偶数
System.out.println(15 % 2);//1 奇数
```

### 练习：数值拆分

需求：键盘录入一个三位数，将其拆分为个位、十位、百位后，打印在控制台

代码示例：

```java
//1.键盘录入一个三位数
//导包 --- 创建对象 --- 接收数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int number = sc.nextInt();//123

//2.获取这个三位数的个位、十位、百位并打印出来
//公式：
//针对于任意的一个数而言
//个位：数字 % 10
int ones = number % 10;
//十位：数字 / 10 % 10
int tens = number / 10 % 10;
//百位：数字 / 100 % 10
int hundreds = number / 100 % 10;

//输出结果
System.out.println(ones);
System.out.println(tens);
System.out.println(hundreds);
```

公式：

获取任意一个数上每一位数。

个位：数字 % 10

十位：数字 / 10 % 10

百位：数字 / 100 % 10

千位：数字 / 1000 % 10

。。。以此类推。。。

# 3.隐式转换

### 概念：

也叫自动类型提升。

就是把一个取值范围小的数据或者变量，赋值给另一个取值范围大的变量。此时不需要我们额外写代码单独实现，是程序自动帮我们完成的。

### 简单记忆：

就是小的给大的，可以直接给。

### 两种提升规则：

* 取值范围小的，和取值范围大的进行运算，小的会先提升为大的，再进行运算。
* byte、short、char三种类型的数据在运算的时候，都会直接先提升为int，然后再进行运算。

### 取值范围从小到大的关系：

byte short int long float double

# 4.强制转换

### 概念：

如果要把一个取值范围大的数据或者变量赋值给另一个取值范围小的变量。是不允许直接操作。

如果一定要这么干，就需要加入强制转换。

### 书写格式：

目标数据类型变量名 = （目标数据类型）被强转的数据；

简单理解：

要转成什么类型的，那么就在小括号中写什么类型就可以了。

案例：

```java
public class OperatorDemo2 {
public static void main(String[] args) {
double a = 12.3;
int b = (int) a;
System.out.println(b);//12
}
}
```

注意点：

强制转换有可能会导致数据发生错误。（数据的精度丢失）

# 5.字符串的+操作

### 核心技巧：

* 当+操作中出现字符串时，此时就是字符串的连接符，会将前后的数据进行拼接，并产生一个新的字符串。
* 当连续进行+操作时，从左到右逐个执行的。

# 6.字符的+操作

### 规则：

当+操作中出现了字符，会拿着字符到计算机内置的ASCII码表中去查对应的数字，然后再进行计算。

### 案例：

```java
char c = 'a';
int result = c + 0;
System.out.println(result);//97
```

ASCII码表中：

'a' ----- 97

'A' ----- 65

# 7.算术运算符的总结

分类：

```java
+ - * / % 这些操作跟小学数学几乎是一模一样的。
```

注意点：

* / 和 % 的区别：他们两个都是做除法运算，/取结果的商。% 取结果的余数。
* 整数操作只能得到整数，如果想要得到小数，必须有浮点数参与运算。

算术运算符的高级用法：

是以+为例进行的讲解，其余减法，乘法，除法的运算规则也是一样的。

特例：字符串只有+操作，没有其他操作。

# 8.自增自减运算符

### 分类：

```java
++ 自增运算符
-- 自减运算符
```

++：就是把变量里面的值+1

--：就是把变量里面的值-1

### 使用方式：

* 放在变量的前面，我们叫做先++。比如：++a
* 放在变量的后面，我们叫做后++。比如：a++

### 注意点：

不管是先++，还是后++。单独写在一行的时候，运算结果是一模一样的。

### 案例：

```java
//++
int a = 10;
a++;//就是让变量a里面的值 + 1
System.out.println(a);//11
++a;//就是让变量a里面的值 + 1
System.out.println(a);//12
```

### 自增自减运算符的应用场景：

某些情况下，变量需要进行加1或者减1的时候使用。

比如：过生日多一岁，就用到了自增运算符。

比如：购物商场中，选择商品数量，也用到了自增或者自减运算符。

比如：统计很多数据中，有多少个数据满足要求，也用到了自增运算符。

# 9.赋值运算符

最为常用的： =

运算过程：就是把等号右边的结果赋值给左边的变量

案例：

```java
public class OperatorDemo6 {
public static void main(String[] args) {
//1.最为简单的赋值运算符用法
int a = 10;//就是把10赋值给变量a
System.out.println(a);

//2.如果等号右边需要进行计算。
int b = 20;
int c = a + b;//先计算等号右边的，把计算的结果赋值给左边的变量
System.out.println(c);

//3.特殊的用法
a = a + 10;//先计算等号右边的，把计算的结果赋值给左边的变量
System.out.println(a);//20
}
}
```

# 10.扩展赋值运算符

### 分类：

+=、-=、*=、/=、%=

### 运算规则：

就是把左边跟右边进行运算，把最终的结果赋值给左边，对右边没有任何影响。

### 案例：

```java
public class OperatorDemo7 {
public static void main(String[] args) {
//扩展赋值运算符
int a = 10;
int b = 20;
a += b;//把左边和右边相加，再把最终的结果赋值给左边，对右边没有任何影响
// 相当于 a = a + b;
System.out.println(a);//30
System.out.println(b);//20
}
}
```

### 注意点：

扩展的赋值运算符中隐层还包含了一个强制转换。

以+=为例。

a += b ;实际上相当于 a = (byte)(a + b);

```java
public class OperatorDemo8 {
public static void main(String[] args) {
byte a = 10;
byte b = 20;
//a += b;
a = (byte)(a + b);
System.out.println(a);//30
}
}
```

# 11.关系运算符

又叫比较运算符，其实就是拿着左边跟右边进行了判断而已。

### 分类：

| 符号 | 解释 |
| ---- | ------------------------------------------------------------ |
| == | 就是判断左边跟右边是否相等，如果成立就是true，如果不成立就是false |
| != | 就是判断左边跟右边是否不相等，如果成立就是true，如果不成立就是false |
| > | 就是判断左边是否大于右边，如果成立就是true，如果不成立就是false |
| >= | 就是判断左边是否大于等于右边，如果成立就是true，如果不成立就是false |
| < | 就是判断左边是否小于右边，如果成立就是true，如果不成立就是false |
| <= | 就是判断左边是否小于等于右边，如果成立就是true，如果不成立就是false |

### 注意点：

* 关系运算符最终的结果一定是布尔类型的。要么是true，要么是false
* 在写==的时候，千万不要写成=

# 14.逻辑运算符

### & 和 | 的使用：

&：逻辑与（而且）

两边都为真，结果才是真，只要有一个为假，那么结果就是假。

|：逻辑或（或者）

两边都为假，结果才是假，只要有一个为真，那么结果就是真。

# 流程控制语句

在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的。所以，我们必须清楚每条语句的执行流程。而且，很多时候要通过控制语句的执行顺序来实现我们想要的功能。

### 1.1 流程控制语句分类

顺序结构

判断和选择结构(if, switch)

循环结构(for, while, do…while)

### 1.2 顺序结构

顺序结构是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的。

顺序结构执行流程图：

![1545615769372](img\1545615769372.png)

## 判断语句：if语句

### 2.1 if语句格式1

```java
格式：
if (关系表达式) {
语句体;
}
```

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体

③如果关系表达式的值为false就不执行语句体

④继续执行后面的语句内容

### 2.2 if语句格式2

```java
格式：
if (关系表达式) {
语句体1;
} else {
语句体2;
}
```

执行流程：

①首先计算关系表达式的值

②如果关系表达式的值为true就执行语句体1

③如果关系表达式的值为false就执行语句体2

### 2.3 if语句格式3

```java
格式：
if (关系表达式1) {
语句体1;
} else if (关系表达式2) {
语句体2;
}
…
else {
语句体n+1;
}
```

执行流程：

①首先计算关系表达式1的值

②如果值为true就执行语句体1；如果值为false就计算关系表达式2的值

③如果值为true就执行语句体2；如果值为false就计算关系表达式3的值

④…

⑤如果没有任何关系表达式为true，就执行语句体n+1。

## switch语句

### 3.1 格式

```java
switch (表达式) {
   case 1:
       语句体1;
       break;
   case 2:
       语句体2;
       break;
   ...
   default:
       语句体n+1;
       break;
}
```

### 3.2 **执行流程：**

- 首先计算出表达式的值
- 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
- 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。

## 循环结构

### 4.1 for循环结构（掌握）

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

#### 4.1.1 for循环格式：

```java
for (初始化语句;条件判断语句;条件控制语句) {
循环体语句;
}
```

**格式解释：**

- 初始化语句：用于表示循环开启时的起始状态，简单说就是循环开始的时候什么样
- 条件判断语句：用于表示循环反复执行的条件，简单说就是判断循环是否能一直执行下去
- 循环体语句：用于表示循环反复执行的内容，简单说就是循环反复执行的事情
- 条件控制语句：用于表示循环执行中每次变化的内容，简单说就是控制循环是否能执行下去

**执行流程：**

①执行初始化语句

②执行条件判断语句，看其结果是true还是false

如果是false，循环结束

如果是true，继续执行

③执行循环体语句

④执行条件控制语句

⑤回到②继续

**for循环书写技巧：**

- 确定循环的开始条件
- 确定循环的结束条件
- 确定循环要重复执行的代码

### 4.2 while循环

#### 4.2.1 格式：

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

### 4.3 do...while循环

本知识点了解即可

格式：

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

### 4.4 三种格式的区别：

for和while循环，是先判断，再执行。

do...while是先执行，再判断。

当知道循环次数或者循环范围的时候，用for循环。

当不知道循环次数，也不知道循环范围，但是知道循环的结束条件时，用while循环。

# 数组

##1.数组的概念：

指的是一种容器，可以同来存储同种数据类型的多个值。

但是数组容器在存储数据的时候，需要结合隐式转换考虑。

比如：

定义了一个int类型的数组。那么boolean。double类型的数据是不能存到这个数组中的，

但是byte类型，short类型，int类型的数据是可以存到这个数组里面的。

建议：

容器的类，和存储的数据类型保持一致。

举例：

整数1 2 3 4 56 就可以使用int类型的数组来存储。

小数1.1 1.2 1.3 1.4 就可以使用double类型的数组来存储。

字符串"aaa" "bbb" "ccc" 就可以使用String类型的数组来存储。

## 2.数组的定义

### 格式一：

数据类型 [] 数组名

比如：int [] array

### 格式二：

数据类型数组名 []

比如： int array []

### 详解：

数据类型：限定了数组以后能存什么类型的数据。

方括号：表示现在定义的是一个数组。

数组名：就是一个名字而已，方便以后使用。

### 注意点：

方法括号跟数组名，谁写在前面，谁写在后面都是一样的。

平时习惯性使用第一种方式。

## 3.数组的静态初始化

### 完整格式：

数据类型[] 数组名 = new 数据类型[]{元素1，元素2，元素3，元素4...};

比如：

int[] arr = new int[]{11,22,33};

double[] arr = new double[]{1.1,1.2,1.3};

### 格式详解：

数据类型：限定了数组以后能存什么类型的数据。

方括号：表示现在定义的是一个数组。

数组名：其实就是名字而已，方便以后使用，在起名字的时候遵循小驼峰命名法。

arr namesArr

new：就是给数组在内存中开辟了一个空间。

数据类型：限定了数组以后能存什么类型的数据。

前面和后面的数据类型一定要保持一致。

int[] arr = new double[]{11,22,33};//错误写法

方括号：表示现在定义的是一个数组。

大括号：表示数组里面的元素。元素也就是存入到数组中的数据。

多个元素之间，一定要用逗号隔开。

### 注意点：

* 等号前后的数据类型必须保持一致。
* 数组一旦创建之后，长度不能发生变化。

### 简化格式:

数据类型[] 数组名 = {元素1，元素2，元素3，元素4...};

比如：

int[] array = {1,2,3,4,5};

double[] array = {1.1,1.2,1.3};

## 4.地址值

```java
int[] arr = {1,2,3,4,5};
System.out.println(arr);//[I@6d03e736

double[] arr2 = {1.1,2.2,3.3};
System.out.println(arr2);//[D@568db2f2
```

打印数组的时候，实际出现的是数组的地址值。

数组的地址值：就表示数组在内存中的位置。

##5.数组元素访问

### 格式：

数组名[索引];

### 作用：

* 获取数组中对应索引上的值

* 修改数组中对应索引上的值

一旦修改之后，原来的值就会被覆盖了。

## 6.索引

也叫角标、下标

就是数组容器中每一个小格子对应的编号。

### 索引的特点：

* 索引一定是从0开始的。
* 连续不间断。
* 逐个+1增长。

## 7.数组的遍历

遍历：就是把数组里面所有的内容一个一个全部取出来。

数组的长度：数组名.length;

通用代码：

```java
for(int i = 0; i < arr.length; i++){
//在循环的过程中，i依次表示数组中的每一个索引
sout(arr[i]);//就可以把数组里面的每一个元素都获取出来，并打印在控制台上了。
}
```

## 8.数组的动态初始化

### 格式：

数据类型[] 数组名 = new 数据类型[数组的长度];

#面向对象编程

## 1. 类和对象

### 1.1 类和对象的理解

客观存在的事物皆为对象，所以我们也常常说万物皆对象。

* 类
* 类的理解
* 类是对现实生活中一类具有共同属性和行为的事物的抽象
* 类是对象的数据类型，类是具有相同属性和行为的一组对象的集合
* 简单理解：类就是对现实事物的一种描述
* 类的组成
* 属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
* 行为：指事物能执行的操作，例如：手机事物（打电话，发短信）
* 类和对象的关系
* 类：类是对现实生活中一类具有共同属性和行为的事物的抽象
* 对象：是能够看得到摸的着的真实存在的实体
* 简单理解：**类是对事物的一种描述，对象则为具体存在的事物**

### 1.2 类的定义

类的组成是由属性和行为两部分组成

* 属性：在类中通过成员变量来体现（类中方法外的变量）
* 行为：在类中通过成员方法来体现（和前面的方法相比去掉static关键字即可）

类的定义步骤：

①定义类

②编写类的成员变量

③编写类的成员方法

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

### 1.3 对象的使用

* 创建对象的格式：
* 类名对象名 = new 类名();
* 调用成员的格式：
* 对象名.成员变量
* 对象名.成员方法();
* 示例代码

```java
/*
创建对象
格式：类名对象名 = new 类名();
范例：Phone p = new Phone();

使用对象
1：使用成员变量
格式：对象名.变量名
范例：p.brand
2：使用成员方法
格式：对象名.方法名()
范例：p.call()
*/

## 2. 对象内存图

### 2.1 单个对象内存图

* 成员变量使用过程

![1](images\1.png)

* 成员方法调用过程

![2](images\2.png)

### 2.2 多个对象内存图

* 成员变量使用过程

![3](images\3.png)

* 成员方法调用过程

![4](images\4.png)

* 总结：

多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份

## 3. 成员变量和局部变量

### 3.1 成员变量和局部变量的区别

* 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）
* 内存中位置不同：成员变量（堆内存）局部变量（栈内存）
* 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）
* 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）

## 4. 封装

### 4.1 封装思想

1. 封装概述
是面向对象三大特征之一（封装，继承，多态）

**对象代表什么，就得封装对应的数据，并提供数据对应的行为**

2. 封装代码实现
将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
成员变量private，提供对应的getXxx()/setXxx()方法

### 4.2 private关键字

private是一个修饰符，可以用来修饰成员（成员变量，成员方法）

* 被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作
* 提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰
* 提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

* 示例代码：

```java
/*
学生类
*/
class Student {
//成员变量
String name;
private int age;

//提供get/set方法
public void setAge(int a) {
if(a<0 || a>120) {
System.out.println("你给的年龄有误");
} else {
age = a;
}
}

public int getAge() {
return age;
}

//成员方法
public void show() {
System.out.println(name + "," + age);
}
}
/*
学生测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
//给成员变量赋值
s.name = "林青霞";
s.setAge(30);
//调用show方法
s.show();
}
}
```

### 4.3 private的使用

* 需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出林青霞，30

* 示例代码：

```java
/*
学生类
*/
class Student {
//成员变量
private String name;
private int age;

//get/set方法
public void setName(String n) {
name = n;
}

public String getName() {
return name;
}

public void setAge(int a) {
age = a;
}

public int getAge() {
return age;
}

public void show() {
System.out.println(name + "," + age);
}
}
/*
学生测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();

//使用set方法给成员变量赋值
s.setName("林青霞");
s.setAge(30);

s.show();

//使用get方法获取成员变量的值
System.out.println(s.getName() + "---" + s.getAge());
System.out.println(s.getName() + "," + s.getAge());

}
}
```

### 4.4 this关键字

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

```java
public class Student {
private String name;
private int age;

public void setName(String name) {
this.name = name;
}

public String getName() {
return name;
}

public void setAge(int age) {
this.age = age;
}

public int getAge() {
return age;
}

public void show() {
System.out.println(name + "," + age);
}
}
```

## 5. 构造方法

### 5.1 构造方法概述

构造方法是一种特殊的方法

* 作用：创建对象 Student stu = **new Student();**

* 格式：

public class 类名{

修饰符类名( 参数 ) {

}

* 功能：主要是完成对象数据的初始化

* 示例代码：

```java
class Student {
private String name;
private int age;

//构造方法
public Student() {
System.out.println("无参构造方法");
}

public void show() {
System.out.println(name + "," + age);
}
}
/*
测试类
*/
public class StudentDemo {
public static void main(String[] args) {
//创建对象
Student s = new Student();
s.show();
}
}
```

### 5.2 构造方法的注意事项

* 构造方法的创建

如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法

* 构造方法的重载

如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

* 推荐的使用方式

无论是否使用，都手工书写无参数构造方法

* 重要功能！

可以使用带参构造，为成员变量进行初始化

* 示例代码

```java
/*
学生类
*/
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();
}
}
```

### 5.3 标准类制作

① 类名需要见名知意

② 成员变量使用private修饰

③ 提供至少两个构造方法

* 无参构造方法
* 带全部参数的构造方法

④ get和set方法

提供每一个成员变量对应的setXxx()/getXxx()

⑤ 如果还有其他行为，也需要写上

#.API

## 1.1API概述

- 什么是API

API (Application Programming Interface) ：应用程序编程接口

- java中的API

指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

##常用的API

### 1 Math类

#### 1.1 概述

> tips：了解内容

查看API文档，我们可以看到API文档中关于Math类的定义如下：

![1576047659085](.\assets\1576047659085.png)

Math类所在包为java.lang包，因此在使用的时候不需要进行导包。并且Math类被final修饰了，因此该类是不能被继承的。

Math类包含执行基本数字运算的方法，我们可以使用Math类完成基本的数学运算。

###2 System类

#### 2.1 概述

> tips：了解内容

查看API文档，我们可以看到API文档中关于System类的定义如下：

![1576049347968](assets/1576049347968.png)

System类所在包为java.lang包，因此在使用的时候不需要进行导包。并且System类被final修饰了，因此该类是不能被继承的。

System包含了系统操作的一些常用的方法。比如获取当前时间所对应的毫秒值，再比如终止当前JVM等等。

### 3 Runtime

#### 3.1 概述

Runtime表示Java中运行时对象，可以获取到程序运行时设计到的一些信息

#### 3.2 常见方法

<font color="red" size="3">**常见方法介绍**</font>

### 4 Object类

#### 4.1 概述

> tips：重点讲解内容

查看API文档，我们可以看到API文档中关于Object类的定义如下：

![1576053677194](assets/1576053677194.png)

Object类所在包是java.lang包。Object 是类层次结构的根，每个类都可以将 Object 作为超类。所有类都直接或者间接的继承自该类；换句话说，该类所具备的方法，其他所有类都继承了。

查看API文档我们可以看到，在Object类中提供了一个无参构造方法，如下所示：

![1576053871503](assets/1576053871503.png)

但是一般情况下我们很少去主动的创建Object类的对象，调用其对应的方法。更多的是创建Object类的某个子类对象，然后通过子类对象调用Object类中的方法。

拉过勾的相信

关注

11
点赞
踩
10

收藏

觉得还不错? 一键收藏
0
评论
java学习笔记

变量就在程序中临时存储数据的容器。但是这个容器中只能存一个值。数据类型变量名 = 数据值；```java//1.定义byte类型的变量//数据类型变量名 = 数据值;//2.定义short类型的变量//3.定义int类型的变量int c = 30;//4.定义long类型的变量//5.定义float类型的变量//6.定义double类型的变量//7.定义char类型的变量。
复制链接

扫一扫