java入门

JAVA入门

标识符和关键字

标识符是用来给变量、类、方法以及包进行命名的。4大规则：

1. 必须以字母、下划线_、美元符号$开头。
2. 其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。
3. 大小写敏感，且长度无限制。
4. 不可以是Java的关键字。

标识符的使用规范

• 表示类名的标识符：每个单词的首字母大写，如Man, GoodMan
• 表示方法和变量的标识符：第一个单词小写，从第二个单词开始首字母大写，我们称之为“驼峰原则”，如eat(), eatFood()

Java不采用ASCII字符集，而是采用Unicode字符集。因此，这里字母的含义不仅仅是英文，还包括汉字等等。但是不建议大家使用汉字来定义标识符！

变量的分类和作用域

变量有三种类型：局部变量、成员变量(也称为实例变量)和静态变量。

局部变量、成员变量、静态变量的核心区别

成员变量（也叫实例变量 member variable）【暂不用掌握，讲面向对象再说】

方法外部、类的内部定义的变量。从属于对象，生命周期伴随对象始终。如果不自行初始化，它会自动初始化成该类型的默认初始值。

· 静态变量（类变量 static variable）【暂不用掌握，讲面向对象再说】

使用static定义。 从属于类，生命周期伴随类始终，从类加载到卸载。 (注：讲完内存分析后我们再深入！先放一放这个概念！) 如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值，如表 2-3所示。

常量(Constant)

在Java语言中，用关键字final来定义一个常量。常量一旦被初始化后不能再更改。

声明格式：

final  type  varName = value;
1

为了更好的区分和表述，一般将1、2、3、’a’、’b’、true、false、helloWorld等称为字符常量，而使用final修饰的PI等称为符号常量。

变量和常量命名规范

• 所有变量、方法、类名：见名知义
• 类成员变量：首字母小写和驼峰原则: monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则: Man, GoodMan
• 方法名：首字母小写和驼峰原则: run(),runRun()

基本数据类型(primitive data type)

Java数据类型分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。

注意事项

1. 引用数据类型的大小统一为4个字节，记录的是其引用对象的地址！

整型

Java 语言整型常量的四种表示形式

1. 十进制整数，如：99, -500, 0
2. 八进制整数，要求以 0 开头，如：015
3. 十六进制数，要求 0x 或 0X 开头，如：0x15
4. 二进制数，要求0b或0B开头，如：0b01110011

整形常量默认为int类型。

Java语言的整型常数默认为int型，声明long型常量可以后加l或L 。

【示例】long类型常数的写法及变量的声明

long a = 55555555;      //编译成功，在int表示的范围内(21亿内)。

long b = 55555555555;   //不加L编译错误，已经超过int表示的范围。
1
2
3
4

报错：The literal 55555555555 of type int is out of range，所以我们需要修改代码为：

long b = 55555555555L;
1

浮点型(Floating Point Number)

1. float类型又被称作单精度类型，尾数可以精确到7位有效数字。

2. double表示这种类型的数值精度约是float类型的两倍，又被称作双精度类型，绝大部分应用程序都采用double类型。

3. Java浮点类型常量有两种表示形式

   (1) 十进制数形式： 例: 3.14 314.0 0.314

   (2) 科学记数法形式 例：3.14e0 3.14E2 3.14E-1

4. 浮点型不精确，不要用于比较

   

   

   上一个例子会出现true的结果原因是：这是因为由于字长有限，浮点数能够精确表示的数是有限的，因而也是离散的。

   浮点数一般都存在舍入误差，很多数字无法精确表示(例如0.1)，其结果只能是接近， 但不等于。二进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次幂。并不是所有的小数都能可以精确的用二进制浮点数表示。

   浮点数存在舍入误差，数字不能精确表示。浮点数适合普通的科学和工程计算，精度足够；但不适合精度要求非常高的商业计算，这时候要使用BigDecimal进行运算和比较。

   java.math包下面的两个有用的类：BigInteger和BigDecimal，这两个类可以处理任意长度的数值。BigInteger实现了任意精度的整数运算。BigDecimal实现了任意精度的浮点运算。

5. 浮点常量默认类型是double，要改成float可以后面加F或f

float类型的数值有一个后缀F或者f，没有后缀F/f的浮点数值默认为double类型。也可以在浮点数值后添加后缀D或者d， 以明确其为double类型。

字符型 Java用Unicode

unicode使用变长编码可以给英文省内存空间啥的。

ASCII字符集表示了英文字母、数字、特殊字符、控制符，所有字符集的老祖宗，大家都会兼容它。但是一个字节能够表示256个状态，而ASCII字符只用到128个，后面128个一直是空的。

于是有了ISO8859-1, 别名叫latin-1, 包含了256个字符。前128个字符与ASCII中完全相同。后128个包括了西欧语言、希腊语、泰语、阿拉伯语、希伯来语对应的文字符号。

随着我国的计算机普及，汉字的处理也有了我们自己的方案。那就是GB2312，两个字节表示1个汉字。两个字节可以表示65536个状态，汉字再多也能全部包含。后来，又有了GBK、GB18030。

我国的台湾地区自己搞了一套显示繁体中文的大五码BIG5。

全世界各个地方，都有自己的文字编码。由于不互通，经常造成乱码的问题。

如果有一种统一的字符集，将世界上所有语言字符都纳入其中，每一个字符都给予一个全球独一无二的编码，那么乱码问题就会消失。于是，全球所有国家和民族使用的所有语言字符的统一字符集诞生了，这就是Unicode字符集。

Unicode字符集是为了给全世界所有字符一个唯一的编码，“唯一”对应的英文为Unique，而编码的英文为code。

Unicode采用了字符集和编码分开的策略。Unicode之前，Unicode诞生之前可以将字符集和字符编码混为一谈，而在Unicode中必须严格区分开。

Unicode字符集统一采用两个字节表示一个字符，包括英文字母。但是，由于英文占据互联网信息的绝大部分。真实存储和传输时，会造成极大的浪费；

因此，目前主要采用UTF-8编码来实现具体的存储和传输。UTF-8是变长编码，用1-6个字节编码Unicode字符。西欧字符仍然是1个字节，汉字3个字节。

字符型在内存中占2个字节，在Java中使用单引号来表示字符常量。例如'A'是一个字符，它与"A"是不同的，"A"表示含有一个字符的字符串。

char 类型用来表示在Unicode编码表中的字符。Unicode编码被设计用来处理各种语言的文字，它占2个字节，可允许有65536个字符。

Unicode具有从0到65535之间的编码，他们通常用从’\u0000’到’\uFFFF’之间的十六进制值来表示（前缀为u表示Unicode）

Java 语言中还允许使用转义字符 ‘\’ 来将其后的字符转变为其它的含义。常用的转义字符及其含义和Unicode值如表2-6所示。

注意事项

以后我们学的String类，其实是字符序列(char sequence), 本质是char字符组成的数组。

String是一个类，是一个对象

布尔型(boolean)

1.布尔数组每个1字节，布尔变量则4字节；

2.java中的布尔就只有true与false，不能用0或非0的整数代替。

1. boolean类型有两个常量值，true和false。
2. 在内存中占一个字节或4个字节，不可以使用 0 或非 0 的整数替代true和false，这点和C语言不同。

【注意点】

JVM规范指出boolean当做int处理，也就是4字节，boolean数组当做byte数组处理，这样我们可以得出boolean类型占了单独使用是4个字节，在数组中是确定的1个字节。

运算符(operator)

二元运算符的运算规则：

整数运算：

• 如果两个操作数有一个为long, 则结果也为long。
• 没有long时，结果为int。即使操作数全为short，byte，结果也是int。

浮点运算：

• 如果两个操作数有一个为double，则结果为double。
• 只有两个操作数都是float，则结果才为float。

取模运算：

• 其操作数可以为浮点数,一般使用整数，结果是“余数”，“余数”符号和左边操作数相同，如：7%3=1，-7%3=-1，7%-3=1。

造成：两个整数相除，直接保留结果的整数部分，没有四舍五入也不会自己从int变成double，除非两个操作数中有一个double

关系运算符用来进行比较运算。

关系运算的结果是布尔值：true/false；

注意事项

• =是赋值运算符，而真正的判断两个操作数是否相等的运算符是==。
• ==、!= 是所有（基本和引用）数据类型都可以使用。
• > 、>=、 <、 <= 仅针对数值类型（byte/short/int/long，float/double 以及char）

逻辑运算的操作数和运算结果都是boolean值。

短路与和短路或采用短路的方式。从左到右计算，如果只通过运算符左边的操作数就能够确定该逻辑表达式的值，则不会继续计算运算符右边的操作数，提高效率。

位运算指的是进行二进制位的运算。

新手雷区

• &和|既是逻辑运算符，也是位运算符。如果两侧操作数都是boolean类型，就作为逻辑运算符。如果两侧的操作数是整数类型，就是位运算符。
• 不要把^当做数学运算乘方，是位的异或操作。

字符串连接符

+运算符两侧的操作数中只要有一个是字符串(String)类型，系统会自动将另一个操作数转换为字符串然后再进行连接。

条件运算符

x为 boolean 类型表达式，先计算 x的值，若为true，则整个运算的结果为表达式y的值，否则整个运算结果为表达式z 的值。

运算符优先级的问题

运算符的优先级

老鸟建议

• 大家不需要去刻意的记这些优先级，表达式里面优先使用小括号来组织！！
• 逻辑与、逻辑或、逻辑非的优先级一定要熟悉！（逻辑非>逻辑与>逻辑或）。
• 如：a||b&&c的运算结果是：a||(b&&c)，而不是(a||b)&&c

数据类型的转换

我们讲解了八种基本数据类型，除了boolean类型之外的七种类型是可以自动转化的。

自动类型转换

自动类型转换指的是容量小的数据类型可以自动转换为容量大的数据类型。如图2-6所示，黑色的实线表示无数据丢失的自动类型转换，而虚线表示在转换时可能会有精度的损失。

自动类型转换图

可以将整型常量直接赋值给byte、 short、 char等类型变量，而不需要进行强制类型转换，只要不超出其表数范围即可。

蓝色虚线精度损失

强制类型转换

强制类型转换，又称为造型（cast），用于强制转换数值的类型，可能损失精度。

当将一种类型强制转换成另一种类型，而又超出了目标类型的表数范围，就会被截断成为一个完全不同的值。

• 不能在布尔类型和任何数值类型之间做强制类型转换

基本类型转化时常见错误和问题

1. 操作比较大的数时，要留意是否溢出，尤其是整数操作时。

2. L和l的问题：

   (1) 不要命名名字为l的变量，字母l容易和数字1混淆。

   (2) long类型使用大写L，不要用小写l

【示例】类型转换常见问题一

int money = 1000000000; //10亿
int years = 20;
//返回的total是负数，超过了int的范围
int total = money*years;
System.out.println("total="+total);
//返回的total仍然是负数。默认是int，因此结果会转成int值，再转成long。但是已经发生//了数据丢失
long total1 = money*years; 
System.out.println("total1="+total1);
//返回的total2正确:先将一个因子变成long，整个表达式发生提升。全部用long来计算。
long total2 = money*((long)years); 
System.out.println("total2="+total2);
1
2
3
4
5
6
7
8
9
10
11

Scanner处理键盘输入

【示例】使用Scanner获取键盘输入

import java.util.Scanner;
public class Welcome2 {
    public static void main(String[ ] args) {
        Scanner scanner = new Scanner(System.in);
        // 将输入的一行付给string1
        String string1 = scanner.nextLine();
        // 将输入单词到第一个空白符为止的字符串付给string2
        String string2 = scanner.next();
        // 将输入的数字赋值给变量
        int a = scanner.nextInt();
        System.out.println("-----录入的信息如下-------");
        System.out.println(string1);
        System.out.println(string2);
        System.out.println(a * 10);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

switch多分支结构(多值情况)

1. switch会根据表达式的值从相匹配的case标签处开始执行，一直执行到break处或者是switch的末尾。如果表达式的值与任一case值不匹配，则进入default语句。
2. switch中表达式的值，是int(byte、short、char也可，long不行)、枚举，字符串。

循环结构

循环结构分两大类，一类是当型，一类是直到型。

• 当型：

当布尔表达式条件为true时，反复执行某语句，当布尔表达式的值为false时才停止循环，比如：while与for循环。

• 直到型：

先执行某语句， 再判断布尔表达式，如果为true，再执行某语句，如此反复，直到布尔表达式条件为false时才停止循环，比如do-while循环。

while循环

语法结构：

while (布尔表达式) {
        循环体;
}
1
2
3

1. 在循环刚开始时，会计算一次“布尔表达式”的值，若条件为真，执行循环体。而对于后来每一次额外的循环，都会在开始前重新计算一次。
2. 语句中应有使循环趋向于结束的语句，否则会出现无限循环–––"死"循环。

do-while循环

语法结构：

do {
        循环体;
     } while(布尔表达式) ;
1
2
3

do-while循环结构会先执行循环体，然后再判断布尔表达式的值，若条件为真，执行循环体，当条件为假时结束循环。do-while循环的循环体至少执行一次。

循环结构(for)

语法结构：

for (初始表达式; 布尔表达式; 迭代因子) {
        循环体;
}
1
2
3

• 初始化部分设置：循环变量的初值
• 条件判断部分为：布尔表达式
• 迭代因子：控制循环变量的增减

for循环在执行条件判定后，先执行的循环体部分，再执行步进。

编译器将while(true)与for(;;)看作同一回事，都指的是无限循环。

break语句和continue语句

1. break用于强行退出整个循环
2. continue用于结束本次循环，继续下一次

带标签的continue语句

“标签”是指后面跟一个冒号的标识符，例如：label:。对Java来说唯一用到标签的地方是在循环语句之前。

goto有害论中，最有问题的就是标签，而非goto，随着标签在一个程序里数量的增多，产生错误的机会也越来越多。

但Java标签不会造成这方面的问题，因为它们的活动场所已被限死，不可通过特别的方式到处传递程序的控制权。

java中只有continue可以使用标签跳转

【示例】带标签的continue

//控制嵌套循环跳转(打印101-150之间所有的质数)
public class Test18 {
    public static void main(String args[ ]) {
        outer: for (int i = 101; i < 150; i++) {
            for (int j = 2; j < i / 2; j++) {
                if (i % j == 0){
                    continue outer;  //符合某条件，跳到外部循环继续
                }
            }
            System.out.print(i + "  ");
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

执行结果如图所示：

递归结构

1. 递归是一种常见的算法思路，在很多算法中都会用到。比如：深度优先搜索（DFS:Depth First Search）等。
2. 递归的基本思想就是“自己调用自己”。

递归结构包括两个部分：

• 定义递归头。 解决：什么时候不调用自身方法。如果没有头，将陷入死循环，也就是递归的结束条件。
• 递归体。 解决：什么时候需要调用自身方法。

递归的缺陷

算法简单是递归的优点之一。但是递归调用会占用大量的系统堆栈，内存耗用多，在递归调用层次多时速度要比循环慢的多，所以在使用递归时要慎重。

面向对象编程**(Object Oriented Programing)**

对象和类的详解

// 每一个源文件必须有且只有一个public class，并且类名和文件名保持一致！

对于一个类来说，有三种成员：属性field、方法method、构造器constructor。

属性（field 成员变量）

属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。

在定义成员变量时可以对其初始化，如果不对其初始化，Java使用默认的值对其初始化。

属性定义格式

[修饰符]  属性类型  属性名 = [默认值] ;
1

方法

**方法用于定义该类或该类实例的行为特征和功能实现。**方法是类和对象行为特征的抽象。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

[修饰符]  方法返回值类型  方法名(形参列表) {
    // n条语句
}
1
2
3

构造方法(构造器 constructor)

构造器用于对象的初始化，而不是创建对象！

构造方法是负责初始化（装修），不是建房子

声明格式：

[修饰符] 类名(形参列表){ //n条语句}
1

构造器4个要点：

• 构造器通过new关键字调用！！
• 构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用return返回某个值。
• 如果我们没有定义构造器，则编译器会自动定义一个无参的构造方法。如果已定义则编译器不会自动添加！
• 构造器的方法名必须和类名一致！

JAVA虚拟机内存模型概念

学习内存模型是为了更好理解面向对象

我们前面做过的内存分析过程：

Java虚拟机的内存可以分为三个区域：栈stack、堆heap、方法区method area。

虚拟机栈（简称：栈）的特点如下：

1. 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等）
2. JVM为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）
3. 栈属于线程私有，不能实现线程间的共享！
4. 栈的存储特性是“先进后出，后进先出”
5. 栈是由系统自动分配，速度快！栈是一个连续的内存空间！

堆的特点如下：

1. 堆用于存储创建好的对象和数组(数组也是对象)
2. JVM只有一个堆，被所有线程共享
3. 堆是一个不连续的内存空间，分配灵活，速度慢！
4. 堆被所有的线程所共享，在堆上的区域，会被垃圾回收器做进一步划分，例如新生代、老年代的划分。

方法区（也是堆）特点如下：

1. 方法区是JAVA虚拟机规范，可以有不同的实现。

   i. JDK7以前是“永久代”

   ii. JDK7部分去除“永久代”，静态变量、字符串常量池都挪到了堆内存中

   iii. JDK8是“元数据空间”和堆结合起来。

2. JVM只有一个方法区，被所有线程共享！

3. 方法区实际也是堆，只是用于存储类、常量相关的信息！

4. 用来存放程序中永远是不变或唯一的内容。（类信息【Class对象，反射机制中会重点讲授】、静态变量、字符串常量等）

5. 常量池主要存放常量：如文本字符串、final常量值。

参数传值机制

Java中，方法中所有参数都是“值传递”，也就是“传递的是值的副本”。 也就是说，我们得到的是“原参数的复印件，而不是原件”。

· 基本数据类型参数的传值

传递的是值的副本。 副本改变不会影响原件。

· 引用类型参数的传值

传递的是值的副本。但是引用类型指的是“对象的地址”。因此，副本和原参数都指向了同一个“地址”，改变“副本指向地址对象的值，也意味着原参数指向对象的值也发生了改变”。

垃圾回收机制(Garbage Collection)

Java引入了垃圾回收机制，令C++程序员最头疼的内存管理问题迎刃而解。Java程序员可以将更多的精力放到业务逻辑上而不是内存管理工作上，大大的提高了开发效率。

垃圾回收原理和算法

· 内存管理

Java的内存管理很大程度就是：堆中对象的管理，其中包括对象空间的分配和释放。

• **对象空间的分配：**使用new关键字创建对象即可
• **对象空间的释放：**将对象赋值null即可。

· 垃圾回收过程

任何一种垃圾回收算法一般要做两件基本事情：

1. 发现无用的对象
2. 回收无用对象占用的内存空间。

垃圾回收机制保证可以将“无用的对象”进行回收。

无用的对象指的就是没有任何变量引用该对象。Java的垃圾回收器通过相关算法发现无用对象，并进行清除和整理。

垃圾回收相关算法

1. 引用计数法

   堆中的每个对象都对应一个引用计数器，当有引用指向这个对象时，引用计数器加1，而当指向该对象的引用失效时（引用变为null），引用计数器减1，最后如果该对象的引用计算器的值为0时，则Java垃圾回收器会认为该对象是无用对象并对其进行回收。优点是算法简单，缺点是“循环引用的无用对象”无法别识别。

   

   【示例】循环引用演示

   代码中，s1和s2互相引用对方，导致他们引用计数不为0，但是实际已经无用，但无法被识别。

   public class Student {
       String name;
       Student friend;
       
       public static void main(String[ ] args) {
           Student s1 = new Student();
           Student s2 = new Student();
           
           s1.friend = s2;
           s2.friend = s1;        
           s1 = null;
           s2 = null;
       }
   }
   
   
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16

2. 引用可达法（根搜索算法）

程序把所有的引用关系看作一张图，从一个节点GC ROOT开始，寻找对应的引用节点，找到这个节点以后，继续寻找这个节点的引用节点，当所有的引用节点寻找完毕之后，剩余的节点则被认为是没有被引用到的节点，即无用的节点。

通用的分代垃圾回收机制(先了解，学到高级可以再看)

分代垃圾回收机制，是基于这样一个事实：不同的对象的生命周期是不一样的。因此，不同生命周期的对象可以采取不同的回收算法，以便提高回收效率。我们将对象分为三种状态：年轻代、年老代、永久代。同时，将处于不同状态的对象放到堆中不同的区域。

1. 年轻代

所有新生成的对象首先都是放在Eden区。年轻代的目标就是尽可能快速的收集掉那些生命周期短的对象，对应的是Minor GC，每次 Minor GC 会清理年轻代的内存，算法采用效率较高的复制算法，频繁的操作，但是会浪费内存空间。当“年轻代”区域存放满对象后，就将对象存放到年老代区域。

2. 年老代

在年轻代中经历了N(默认15)次垃圾回收后仍然存活的对象，就会被放到年老代中。因此，可以认为年老代中存放的都是一些生命周期较长的对象。年老代对象越来越多，我们就需要启动Major GC和Full GC(全量回收)，来一次大扫除，全面清理年轻代区域和年老代区域。

3. 永久代

用于存放静态文件，如Java类、方法等。持久代对垃圾回收没有显著影响。JDK7以前就是“方法区”的一种实现。JDK8以后已经没有“永久代”了，使用metaspace元数据空间和堆替代。

·Minor GC:

用于清理年轻代区域。Eden区满了就会触发一次Minor GC。清理无用对象，将有用对象复制到“Survivor1”、“Survivor2”区中。

·Major GC：

用于清理年老代区域。

·Full GC：

用于清理年轻代、年老代区域。 成本较高，会对系统性能产生影响。

JVM调优和Full GC

在对JVM调优的过程中，很大一部分工作就是对于Full GC的调节。有如下原因可能导致Full GC：

1. 年老代（Tenured）被写满
2. 永久代（Perm）被写满
3. System.gc()被显式调用
4. 上一次GC之后Heap的各域分配策略动态变化

开发中容易造成内存泄露的操作

内存泄漏：

指堆内存由于某种原因程序未释放，造成内存浪费，导致运行速度减慢甚至系统崩溃等。

老鸟建议

• 在实际开发中，经常会造成系统的崩溃。如下这些操作我们应该注意这些使用场景。 请大家学完相关内容后，回头过来温习下面的内容。不要求此处掌握相关细节。

如下四种情况时最容易造成内存泄露的场景，请大家开发时一定注意：

1.创建大量无用对象

比如：大量拼接字符串时，使用了String而不是StringBuilder。

String str = "";
for (int i = 0; i < 10000; i++) {   
    str += i;     //相当于产生了10000个String对象
}
1
2
3
4

2. 静态集合类的使用

像HashMap、Vector、List等的使用最容易出现内存泄露，这些静态变量的生命周期 和应用程序一致，所有的对象也不能被释放。

3. 各种连接对象（IO流对象、数据库连接对象、网络连接对象）未关闭

IO流对象、数据库连接对象、网络连接对象等连接对象属于物理连接，和硬盘或者网 络连接，不使用的时候一定要关闭。

4. 监听器的使用不当

释放对象时，没有删除相应的监听器

其他要点

1. 程序员无权调用垃圾回收器。
2. 程序员可以调用System.gc()，该方法只是通知JVM，并不是运行垃圾回收器。尽量少用，会申请启动Full GC，成本高，影响系统性能。
3. Object对象的finalize方法，是Java提供给程序员用来释放对象或资源的方法，但是尽量少用

本节作业

1. 垃圾回收过程一般分为两步，是哪两步？发现，回收
2. 垃圾回收常见的两种算法是什么？引用计数法，引用可达法
3. 堆内存划分成：年轻代、年老代、永久代。垃圾回收器划分成：Minor GC、Major GC、Full GC。这三种垃圾收回器都对应哪些区域？
4. 对JVM调优的过程中，很大一部分工作就是对于Full GC的调节。这句话对吗？对
5. System.gc()的作用是什么？通知系统调用Full GC。

this的用法：

• 普通方法中，this总是指向调用该方法的对象。
• 构造方法中，this总是指向正要初始化的对象。

创建对象的四步：

this的其他要点：

• this()调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。
• this不能用于static方法中。
• this是作为普通方法的“隐式参数”，由系统传入到方法中。

意思就是说，在一个构造函数里面调用另一个构造函数使用this（无参/有参）, 并且必须位于构造方法的第一句。

static 关键字

静态变量(类变量)、静态方法(类方法)：static声明的属性或方法。

静态变量/静态方法生命周期和类相同，在整个程序执行期间都有效。它有如下特点：

1. 为该类的公用变量，属于类，被该类的所有实例共享，在类载入时被初始化。
2. static变量只有一份。
3. 一般用“类名.类变量/方法”来调用。
4. 在static方法中不可直接访问非static的成员

静态初始化块

构造方法用于对象的普通属性初始化。

静态初始化块，用于类的初始化操作，初始化静态属性。

在静态初始化块中不能直接访问非static成员。

注意事项

静态初始化块执行顺序(学完继承再看这里)：

• 上溯到Object类，先执行Object的静态初始化块，再向下执行子类的静态初始化块，直到类的静态初始化块为止。
• 构造方法执行顺序和上面顺序一样！！

public class TestStatic2 {
    static String company; //公司名称
    static {
        System.out.println("执行类的初始化工作");
        company = "北京尚学堂";
        printCompany();
    }   
    public static void printCompany(){
        System.out.println(company);
    }   
    public static void main(String[ ] args) {
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

变量的分类和作用域

变量有三种类型：局部变量、成员变量(也称为实例变量)和静态变量。

局部变量、成员变量、静态变量的核心区别

包机制(package、import)

包（package）相当于文件夹对于文件的作用。用于管理类、用于解决类的重名问题。

package的使用有两个要点：

1. 通常是类的第一句非注释性语句。
2. 包名：域名倒着写即可，便于内部管理类。

注意事项

• 写项目时都要加包，不要使用默认包。
• com.gao和com.gao.car，这是两个完全独立的包。只是逻辑上看,后者是前者的一部分。

JDK中的主要包

表 JDK中的主要包

导入类import

如果要使用其他包的类，需使用import，从而在本类中直接通过类名来调用，否则就需要书写类的完整包名和类名。

注意要点

• Java会默认导入java.lang包下所有的类，因此这些类我们可以直接使用。
• 如果导入两个同名的类，只能用包名+类名来显示调用相关类：java.util.Date date = new java.util.Date();

静态导入

静态导入(static import): 其作用是用于导入指定类的静态属性和静态方法，这样我们可以直接使用静态属性和静态方法。

【示例】静态导入的使用

package com.itbaizhan;
import static java.lang.Math.*;//导入Math类的所有静态属性
import static java.lang.Math.PI;//导入Math类的PI属性


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


1
2
3
4
5
6
7
8
9
10
11
12
13

继承_instanceof 运算符

instanceof是二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true；否则，返回false。比如：

【示例】使用instanceof运算符进行类型判断

public class Test{
    public static void main(String[ ] args) {
        Student s = new Student("高淇",172,"Java");
        System.out.println(s instanceof Person);
        System.out.println(s instanceof Student);
    }
}


1
2
3
4
5
6
7
8
9

两条语句的输出结果都是true

继承使用要点

1. 父类也称作超类、基类。 子类：派生类等。
2. Java中只有单继承，没有像C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。
3. Java中类没有多继承，接口有多继承。
4. 子类继承父类，**可以得到父类的全部属性和方法 (除了父类的构造方法)，**但不见得可以直接访问(比如，父类私有的属性和方法)。
5. 如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。

方法重写override

子类重写父类的方法，可以用自身行为替换父类行为。重写是实现多态的必要条件。

方法重写需要符合下面的三个要点：

1. = =：方法名、形参列表相同。
2. ≤：返回值类型和声明异常类型，子类小于等于父类。
3. ≥：访问权限，子类大于等于父类。

final关键字

final关键字的作用：

• 修饰变量: 被他修饰的变量不可改变。一旦赋了初值，就不能被重新赋值。

  final int MAX_SPEED = 120;

• **修饰方法：**该方法不可被子类重写。但是可以被重载！

  final void study(){}

• 修饰类: 修饰的类不能被继承。比如：Math、String等。

  final class A {}

final修饰类如图所示。

“组合”

核心是“将父类对象作为子类的属性”。

组合比较灵活。继承只能有一个父类，但是组合可以有多个属性。所以，有人声称“组合优于继承，开发中可以不用继承”，但是，不建议大家走极端。

对于is -a关系建议使用继承，has-a关系建议使用组合。

比如：上面的例子，Student is a Person这个逻辑没问题，但是：Student has a Person就有问题了。这时候，显然继承关系比较合适。

再比如：笔记本和芯片的关系显然是has-a关系，使用组合更好。

本节作业

1. 面向对象的三大特征是什么？继承，封装，多态
2. 继承的两个主要作用是什么？代码复用，建模
3. JAVA中实现继承是哪个关键词？extends
4. JAVA中的类继承，是单继承还是多继承？JAVA中其他地方有多继承吗？单继承，接口
5. 子类继承父类可以获得除父类构造方法之外的所有，但不见得都能使用。找现实中的例子打比喻描述这个现象。
6. 定义类时，没有使用extends，他的父类是什么？Object
7. 完成课堂中，Person、Student继承关系的代码测试。
8. 完成课堂中，Person、Student组合关系的代码测试。
9. 组合和继承的关系如何理解？has it与 is it
10. 完成课堂中，方法重写的测试。
11. 方法重写和方法重载什么区别？重写是继承里面的，重载完全不是同一个方法
12. final关键字修饰变量、方法、类，都分别代表什么含义？变量不可修改，方法不可重写，类不可继承

Object类详解

所有类都是Object类的子类，也都具备Object类的所有特性。

Object类基本特性

1. Object类是所有类的父类，所有的Java对象都拥有Object类的属性和方法。
2. 如果在类的声明中未使用extends，则默认继承Object类。

toString方法

Object类中定义有public String toString()方法，其返回值是 String 类型。Object类中toString方法的源码为：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
1
2
3

根据如上源码得知，默认会返回“类名+@+16进制的hashcode”。在打印输出或者用字符串连接对象时，会自动调用该对象的toString()方法。

【示例】重写toString()方法

class Person {
    String name;
    int age;
    @Override
    public String toString() {
        return name+",年龄："+age;
    }
}
public class Test {
    public static void main(String[ ] args) {
        Person p=new Person();
        p.age=20;
        p.name="李东";
        System.out.println("info:"+p);
        
        Test t = new Test();
        System.out.println(t);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

执行结果如图所示：

补:IDEA部分快捷键

IDEA快捷键和相关操作：

1. 类的结构视图：alt+7

2. 看类的源码：ctrl+左键

3. 自动生成构造器、get、set方法、equals等：alt+insert

4. 查看错误：alt+enter

5. 快捷输出常见字符串：

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

   b) sout System.out.println();

   c) soutm System.out.println(“描述：所在类中的，所在方法”);

==和equals方法

==代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

equals()提供定义“对象内容相等”的逻辑。比如，我们在公安系统中认为id相同的人就是同一个人、学籍系统中认为学号相同的人就是同一个人。

equals()默认是比较两个对象的hashcode。但，可以根据自己的要求重写equals方法。

重写的话，快捷键里面，ctrl+return

super关键字

1. super“可以看做”是直接父类对象的引用。可通过super来访问父类中被子类覆盖的方法或属性。
2. 使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。
3. 在一个类中，若是构造方法的第一行没有调用super(…)或者this(…); 那么Java默认都会调用super(),含义是调用父类的无参数构造方法。

【示例】super关键字的使用

public class TestSuper01 { 
    public static void main(String[ ] args) {
        new ChildClass().f();
    }
}
class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println ("FatherClass.value="+value);
    }
}
class ChildClass extends FatherClass {
    public int  value;
public int  age;
    public void f() {
        super.f();  //调用父类的普通方法
        value = 200;
        System.out.println("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value); //调用父类的成员变量
    }
public void f2() {
        System.out.println(age);     }


}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

执行结果如图所示：

继承树追溯

属性/方法查找顺序：(比如：查找变量h)

• 先查找当前类中有没有属性h
• 依次上溯每个父类，查看每个父类中是否有h，直到Object
• 如果没找到，则出现编译错误。
• 上面步骤，只要找到h变量，则这个过程终止。

构造方法调用顺序：

构造方法第一句总是：super(…)来调用父类对应的构造方法。所以，流程就是：先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止。

**注：**静态初始化块调用顺序，与构造方法调用顺序一样，不再重复。

【示例】继承条件下构造方法的执行过程

public class TestSuper02 { 
    public static void main(String[ ] args) {
        System.out.println("开始创建一个ChildClass对象......");
        new ChildClass();
    }
}
class FatherClass {
    public FatherClass() {
        System.out.println("创建FatherClass");
    }
}
class ChildClass extends FatherClass {
    public ChildClass() {
        System.out.println("创建ChildClass");
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

执行结果如图所示：

静态初始化与构造器

先静态初始化，创建类之后，在堆中给新对象一个空间，在栈中使用栈帧调用构造器的方法，从而给堆中的对象进行初始化，然后将该对象地址传递给对象名字。这样就创建了一个对象。

因此，静态初始化仅一次，静态代码块仅在编译的时候执行一次，不会在每一个对象创建的时候都执行。

import java.util.Objects;


public class Point {
    double x;
    double y;

    static {
        System.out.println("Point 静态加载");
    }

    public Point(double x) {
        System.out.println("POINT的构造器" + x);
    }


    public static void main(String[] args) {
        new X(2);
        new X(3);
        new X(4);
    }
}

class X extends Point {

    static {
        System.out.println("X的静态代码块");
    }

    public X(double x) {
        super(x);
        System.out.println("POINT子类构造器" + x);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

执行结果

Point 静态加载
X的静态代码块
POINT的构造器2.0
POINT子类构造器2.0
POINT的构造器3.0
POINT子类构造器3.0
POINT的构造器4.0
POINT子类构造器4.0

进程已结束,退出代码0
1
2
3
4
5
6
7
8
9
10

封装的实现—使用访问控制符

Java是使用访问控制符来控制哪些细节需要封装，哪些细节需要暴露的。

Java中4种访问控制符分别为private、default、protected、public。

访问权限修饰符

public：全局友好

protected：父子友好 包内友好

缺省：包内友好

private：类内友好

☆

【注】关于protected的两个细节：

1. 若父类和子类在同一个包中，子类可访问父类的protected成员,也可访问父类对象的protected成员。
2. 若子类和父类不在同一个包中，子类可访问父类的protected成员，不能访问父类对象的protected成员。

开发中封装的简单规则:

• 属性一般使用private访问权限。

  属性私有后， 提供相应的get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作（注意：boolean变量的get方法是is开头!）。

• 方法：一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰。

多态polymorphism

**多态指的是同一个方法调用，由于对象不同可能会有不同的行为。**现实生活中，同一个方法，具体实现会完全不同。 比如：同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

多态的要点：

1. 多态是方法的多态，不是属性的多态（多态与属性无关）。
2. 多态的存在要有3个必要条件：继承，方法重写，父类引用指向子类对象。
3. ☆父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了。

父类引用指向子类对象后，用该父类引用调用子类重写的方法，此时多态就出现了

但是这里会出现问题就是，编译器只认你这个Animal的身份，只能用Animal及以上的方法，而不能用Animal的子类的DOG的独有的seeDoor()的方法。。。。即使你的内核是只狗

虽然只能使用Animal及以上的方法，但是在Animal中的方法如果被DOG重写了的话，执行的是DOG里面的算法而不是Animal里面的。

转型(casting)

1. 父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。
2. 向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型。

抽象

抽象方法

1. 使用abstract修饰的方法，没有方法体，只有声明。
2. 定义的是一种“规范”，就是告诉子类必须要给抽象方法提供具体的实现。

· 抽象类

1. 包含抽象方法的类就是抽象类。
2. 通过抽象类，我们就可以做到严格限制子类的设计，使子类之间更加通用。

抽象类的使用要点:

1. 有抽象方法的类只能定义成抽象类
2. 抽象类不能实例化，即不能用new来实例化抽象类。
3. 抽象类可以包含属性、方法、构造方法。但是构造方法不能用来new实例，只能用来被子类调用。
4. 抽象类只能用来被继承。
5. 抽象方法必须被子类实现。

接口interface

接口就是一组规范（就像我们人间的法律一样），所有实现类都要遵守。

面向对象的精髓，最能体现这一点的就是接口。为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、Java、C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。

接口的作用

· 为什么需要接口?接口和抽象类的区别?

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。全面地专业地实现了：规范和具体实现的分离。

接口是两个模块之间通信的标准，通信的规范。如果能把你要设计的模块之间的接口定义好，就相当于完成了系统的设计大纲，剩下的就是添砖加瓦的具体实现了。大家在工作以后，做系统时往往就是使用“面向接口”的思想来设计系统。

**接口和实现类不是父子关系，是实现规则的关系。**比如：我定义一个接口Runnable，Car实现它就能在地上跑，Train实现它也能在地上跑，飞机实现它也能在地上跑。就是说，如果它是交通工具，就一定能跑，但是一定要实现Runnable接口。、

定义接口的详细说明：

• **访问修饰符：**只能是public或默认。

• **接口名：**和类名采用相同命名机制。

• **extends：**接口可以多继承。

• **常量：**接口中的属性只能是常量，总是：public static final 修饰。不写也是。

• **方法：**接口中的方法只能是：public abstract。 省略的话，也是public abstract。

• 子类通过implements来实现接口中的规范。

• 接口不能创建实例，但是可用于声明引用变量类型。

• 一个类实现了接口，必须实现接口中所有的方法，并且这些方法只能是public的。

• JDK1.8（不含8）之前，接口中只能包含静态常量、抽象方法，不能有普通属性、构造方法、普通方法。

JDK1.8（含8）后，接口中可以包含普通的静态方法、默认方法。

接口中定义静态方法和默认方法(JDK8)

JAVA8之前，接口里的方法要求全部是抽象方法。

JAVA8（含8）之后，以后允许在接口里定义默认方法和静态方法。

JDK8新特性_默认方法

Java 8及以上新版本，允许给接口添加一个非抽象的方法实现，只需要使用 default 关键字即可，这个特征又叫做默认方法（也称为扩展方法）。

默认方法和抽象方法的区别是抽象方法必须要被实现，默认方法不是。作为替代方式，接口可以提供默认方法的实现，所有这个接口的实现类都可以得到默认方法。

张怡桢说：

但是若哪个子类重写了默认，使用接口引用调用该默认方法时，真正运行的代码是子类里面的默认方法。

就是说，编译类型：接口；运行类型：子类

方法有无认编译，运行有无先看子类再往上

public class Test {
    public static void main(String[] args) {
        A a = new Test_A();
        a.moren();
    }
}


interface A {


    default void moren(){
        System.out.println("我是接口A中的默认方法！");
    }
}


class  Test_A implements  A {
    
    @Override
    public void moren() {
        System.out.println("Test_A.moren");
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

接口中的静态方法

JDK8新特性_静态方法

JAVA8以后，我们也可以在接口中直接定义静态方法的实现。

这个静态方法直接从属于接口（接口也是类，一种特殊的类），可以通过接口名调用。

如果子类中定义了相同名字的静态方法，**那就是完全不同的方法了，直接从属于子类。**可以通过子类名直接调用。

静态方法不存在重写的问题。just it self

接口的多继承

接口支持多继承。和类的继承类似，子接口extends父接口，会获得父接口中的一切。

【示例】接口的多继承

interface A {
    void testa();
}
interface B {
    void testb();
}
/**接口可以多继承：接口C继承接口A和B*/
interface C extends A, B {
    void testc();
}
public class Test implements C {
    public void testc() {
}
    public void testa() {
    }
    public void testb() {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

字符串String类详解

String是最常用的类，要掌握String类常见的方法，它底层实现也需要掌握好，不然在工作开发中很容易犯错。

• String类又称作不可变字符序列。
• String位于java.lang包中，Java程序默认导入java.lang包下的所有类。
• Java字符串就是Unicode字符序列，例如字符串“Java”就是4个Unicode字符’J’、’a’、’v’、’a’组成的。
• Java没有内置的字符串类型，而是在标准Java类库中提供了一个预定义的类String，每个用双引号括起来的字符串都是String类的一个实例。

String类和常量池

Java内存分析中，我们会经常听到关于“常量池”的描述，实际上常量池也分了以下三种：

1. 全局字符串常量池
2. class文件常量池
3. 运行时常量池(Runtime Constant Pool)
1
2
3

我们只关注运行时常量池即可。

【示例】字符串相等判断（以后一般判断字符串值是否相等，使用equals()）

String g1 = "北京尚学堂";
String g2 = "北京尚学堂";
String g3 = new String("北京尚学堂");


System.out.println(g1 == g2);   // true
System.out.println(g1 == g3);   // false
System.out.println(g1.equals(g3));   //true

1
2
3
4
5
6
7
8
9

内部类

我们把一个类放在另一个类的内部定义，称为内部类(inner class)。

内部类的两个要点：

• 内部类提供了更好的封装。只能让外部类直接访问，不允许同一个包中的其他类直接访问。
• 内部类可以直接访问外部类的私有属性，内部类被当成其外部类的成员。但外部类不能访问内部类的内部属性。

注意

内部类只是一个编译时概念，一旦我们编译成功，就会成为完全不同的两个类。对于一个名为Outer的外部类和其内部定义的名为Inner的内部类。编译完成后会出现Outer.class和Outer$Inner.class两个类的字节码文件。所以内部类是相对独立的一种存在，其成员变量/方法名可以和外部类的相同。

【示例】内部类的定义和使用

/**外部类Outer*/
class Outer {
    private int age = 10;
    public void show(){
        System.out.println(age);//10
    }
    /**内部类Inner*/
    public class Inner {
        //内部类中可以声明与外部类同名的属性与方法
        private int age = 20;
        public void show(){
            System.out.println(age);//20
        }
    }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

内部类的分类

非静态内部类

非静态内部类（外部类里使用非静态内部类和平时使用其他类没什么不同）

1. 非静态内部类对象必须寄存在一个外部类对象里。因此，如果有一个非静态内部类对象那么一定存在对应的外部类对象。非静态内部类对象单独属于外部类的某个对象。
2. 非静态内部类可以直接访问外部类的成员，但是外部类不能直接访问非静态内部类成员。
3. 非静态内部类不能有静态方法、静态属性和静态初始化块。
4. 成员变量访问要点：
   • 内部类属性：this.变量名。
   • 外部类属性：外部类名.this.变量名。

【示例】内部类中访问成员变量

/**外部类Outer1*/
class Outer1 {
   private int age = 10;
   public void show(){
      System.out.println(age);//10
   }
   /**内部类Inner*/
   public class Inner1 {
      //内部类中可以声明与外部类同名的属性与方法
      private int age = 20;
      public void show(){
         System.out.println(age);//20
         System.out.println(Outer1.this.age); //10   访问外部类的普通属性
      }
   }
}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

内部类的访问：

\1. 外部类中定义内部类：new Inner()。

\2. 外部类以外的地方使用非静态内部类：

Outer.Inner varname = new Outer().new Inner()。

静态内部类

定义方式：

static  class   ClassName {
//类体
}
1
2
3

使用要点：

1. 静态内部类可以访问外部类的静态成员，不能访问外部类的普通成员。
2. 静态内部类看做外部类的一个静态成员。

【示例】静态内部类的访问

/*
测试静态内部类
 */
class Outer2{
   private  int a = 10;
   private static int b = 20;
   //相当于外部类的一个静态成员
   static class Inner2{
      public void test(){
//       System.out.println(a);   //静态内部类不能访问外部类的普通属性
         System.out.println(b);  //静态内部类可以访问外部类的静态属性
      }
   }
}
public class TestStaticInnerClass {
   public static void main(String[ ] args) {
      //通过 new 外部类名.内部类名() 来创建内部类对象
      Outer2.Inner2 inner =new Outer2.Inner2();
      inner.test();
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

Outer2.Inner2 inner =new Outer2.Inner2();

匿名内部类

适合那种只需要使用一次的类。比如：键盘监听操作等等。在安卓开发、awt、swing开发中常见。

/**
 * 测试匿名内部类
 */
public class TestAnonymousInnerClass {


    public void test1(A a) {
        a.run();
    }


    public static void main(String[] args) {
        TestAnonymousInnerClass  tac = new TestAnonymousInnerClass();
        tac.test1(new A() {
            @Override
            public void run() {
                System.out.println("匿名内部类测试!  我是新定义的第一个匿名内部类！");
            }
        });




        tac.test1(new A() {
            @Override
            public void run() {
                System.out.println("我是新定义的第二个匿名内部类");
            }
        });


    }


}


interface  A {
    void run();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

注意

• 匿名内部类没有访问修饰符。
• 匿名内部类没有构造方法。因为它连名字都没有那又何来构造方法呢。

局部内部类

定义在方法内部的，作用域只限于本方法，称为局部内部类。

局部内部类在实际开发中应用很少。

/**
 * 测试局部内部类
 */
public class TestLocalInnerClass {
    public void show() {
        //作用域仅限于该方法
        class Inner3 {
            public void fun() {
                System.out.println("helloworld");
            }
        }
        new Inner3().fun();
    }
    public static void main(String[ ] args) {
        new TestLocalInnerClass().show();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

数组

数组的定义

数组是相同类型数据的有序集合。其中，每一个数据称作一个元素，每个元素可以通过一个索引（下标）来访问它们。数组的四个基本特点：

1. 长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
2. 其元素的类型必须是相同类型，不允许出现混合类型。
3. 数组类型可以是任何数据类型，包括基本类型和引用类型。
4. 数组变量属于引用类型，数组也是对象,数组中的元素相当于对象的属性！

注意事项

• 声明的时候并没有实例化任何对象，只有在实例化数组对象时，JVM才分配空间，这时才与长度有关。
• 声明一个数组的时候并没有数组真正被创建。
• 构造一个数组，必须指定长度。

数组有两种：

基本类型数组与引用类型数组

基本类型数组

引用类型数组

初始化

数组的初始化方式总共有三种：静态初始化、动态初始化、默认初始化。

1. 静态初始化

除了用new关键字来产生数组以外，还可以直接在定义数组的同时就为数组元素分配空间并赋值。

【示例】数组的静态初始化

int [ ] a = { 1, 2, 3 };// 静态初始化基本类型数组；
Man[ ] mans = { new Man(1, 1), new Man(2, 2) };// 静态初始化引用类型数组；
1
2

2.动态初始化

数组定义与为数组元素分配空间并赋值的操作分开进行。

【示例】数组的动态初始化

int[ ] a1 = new int[2];//动态初始化数组，先分配空间；
a1[0]=1;//给数组元素赋值；
a1[1]=2;//给数组元素赋值；
1
2
3

3.数组的默认初始化

数组是对象，它的元素相当于对象的属性；每个元素也按照属性的方式被默认初始化。

【示例】数组的默认初始化

int a2[ ] = new int[2]; // 默认值：0,0
boolean[ ] b = new boolean[2]; // 默认值：false,false
String[ ] s = new String[2]; // 默认值：null, null
1
2
3

数组常见操作

1. 遍历指的就是“通过循环遍历数组的所有元素”。
2. 拷贝指的是将某个数组的内容拷贝到另一个数组中.

注：实质上，后面学容器的扩容就是“数组的拷贝”。

数组的遍历

数组元素下标的合法区间：[0, length-1]。我们可以通过下标来遍历数组中的元素，遍历时可以读取元素的值或者修改元素的值。

参数：数组.length

for-each循环

for-each专门用于读取数组或容器中所有的元素。

注意事项

• for-each增强for循环在遍历数组过程中不能修改数组中某元素的值.
• for-each仅适用于遍历，不涉及有关索引（下标）的操作。

数组的拷贝

System.arraycopy（object src，int srcpos，object dest， int destpos，int length）

• System.arraycopy(s,0,sBak,0,s.length);

该方法可以将src数组里的元素值赋给dest数组的元素，其中srcpos指定从src数组的第几个元素开始赋值，length参数指定 将src数组的多少个元素赋给dest数组的元素。

java.util.Arrays类

Arrays类包含了：排序、查找、填充、打印内容等常见的数组操作。

• System.out.println(a); // 打印数组引用的值
• System.out.println(Arrays.toString(a)); // 打印数组元素的值；
• Arrays.sort(a); //对数组进行排序
• Arrays.binarySearch(a, 12) //使用二分法查找，必须先对数组进行排序
• Arrays.fill(a, 2, 4, 100); //将2到4索引的元素替换为100;

import java.util.Arrays;
public class Test {
    public static void main(String args[ ]) {
        int[ ] a = { 1, 2 };
        System.out.println(a); // 打印数组引用的值；
        System.out.println(Arrays.toString(a)); // 打印数组元素的值；
    }
}
1
2
3
4
5
6
7
8

菜鸟雷区

此处的Arrays.toString()方法是Arrays类的静态方法，不是前面讲的Object的toString()方法。

【示例】使用Arrays类实现二分法查找法

import java.util.Arrays;
public class Test {
    public static void main(String[ ] args) {
        int[ ] a = {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.sort(a);   //使用二分法查找，必须先对数组进行排序;
        System.out.println(Arrays.toString(a));
        //返回排序后新的索引位置,若未找到返回负数。
        System.out.println("该元素的索引："+Arrays.binarySearch(a, 12)); 
    }
}
1
2
3
4
5
6
7
8
9
10
11

示例】使用Arrays类对数组进行填充

import java.util.Arrays;
public class Test {
    public static void main(String[ ] args) {
        int[ ] a= {1,2,323,23,543,12,59};
        System.out.println(Arrays.toString(a));
        Arrays.fill(a, 2, 4, 100);  //将2到4索引的元素替换为100;
        System.out.println(Arrays.toString(a));
    }
}
1
2
3
4
5
6
7
8
9

多维数组

//动态初始化

import java.util.Arrays;
public class Test {
    public static void main(String[ ] args) {
        int[ ][ ] a = new int[3][ ];
        // a[0] = {1,2,5}; //错误，没有声明类型就初始化
        a[0] = new int[ ] { 1, 2 };
        a[1] = new int[ ] { 2, 2 };
        a[2] = new int[ ] { 2, 2, 3, 4 };
        System.out.println(a[2][3]);
        System.out.println(Arrays.toString(a[0]));
        System.out.println(Arrays.toString(a[1]));
        System.out.println(Arrays.toString(a[2]));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

//静态初始化

public class Test {
    public static void main(String[ ] args) {
        int[ ][ ] a = { { 1, 2, 3 }, { 3, 4 }, { 3, 5, 6, 7 } };
        System.out.println(a[2][3]);
    }
}
1
2
3
4
5
6
7
8

Object数组存储表格数据

雇员表

使用二维数组保存表格数据

import java.util.Arrays;
public class Test {
    public static void main(String[ ] args) {
        Object[ ] a1 = {1001,"高淇",18,"讲师","2-14"};
        Object[ ] a2 = {1002,"高小七",19,"助教","10-10"};
        Object[ ] a3 = {1003,"高小琴",20,"班主任","5-5"};
        Object[ ][ ]  emps = new Object[3][ ];
        emps[0] = a1;
        emps[1] = a2;
        emps[2] = a3;
        System.out.println(Arrays.toString(emps[0]));
        System.out.println(Arrays.toString(emps[1]));
        System.out.println(Arrays.toString(emps[2]));   
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

注意事项

• 此处基本数据类型1001，本质不是Object对象。JAVA编译器会自动把基本数据类型“自动装箱”成包装类对象。大家在下一章学了包装类后就懂了。

使用javabean和一维数组保存表格信息

import java.util.Arrays;
public class Test {
   public static void main(String[ ] args) {
      Emp[] emps = {
            new Emp(1001,"高淇",18,"讲师","2-14"),
            new Emp(1002,"高小七",19,"助教","10-10"),
            new Emp(1003,"高小八",20,"班主任","5-5")
      };


      for (Emp e:emps){
         System.out.println(e);
      }


   }
}


class Emp {
   private int id;
   private String name;
   private int age;
   private String job;
   private String hiredate;


   public Emp(int id, String name, int age, String job, String hiredate) {
      this.id = id;
      this.name = name;
      this.age = age;
      this.job = job;
      this.hiredate = hiredate;
   }


   @Override
   public String toString() {
      return "["+id+","+name+","+age+","+job+","+hiredate+"]";
   }


   public int getId() {
      return id;
   }


   public void setId(int id) {
      this.id = id;
   }


   public String getName() {
      return name;
   }


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


   public int getAge() {
      return age;
   }


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


   public String getJob() {
      return job;
   }


   public void setJob(String job) {
      this.job = job;
   }


   public String getHiredate() {
      return hiredate;
   }


   public void setHiredate(String hiredate) {
      this.hiredate = hiredate;
   }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

Comparable接口

多个对象做比较，就要有“比较规则”，然后实现排序。

事实上，java中排序算法的底层也依赖Comparable接口。

Comparable接口中只有一个方法：

public int compareTo(Object obj) obj为要比较的对象

方法中，将当前对象和obj这个对象进行比较，如果大于返回1，等于返回0，小于返回-1. (此处的1也可以是正整数，-1也可以是负整数)。 compareTo方法的代码也比较固定：

Arrays的sort底层依靠compareto返回值来进行排序

小了返回-1，等于返回0，大了返回1:升序

小了返回1，等于返回0，大了返回-1:降序

重写Man的toString，输出Arrays.toString(mans)即可输出排了序的mans

使用Arrays类对数组元素进行排序

import java.util.Arrays;
public class Test {
    public static void main(String[ ] args) {
        Man[ ] msMans = { new Man(3, "a"), new Man(60, "b"), new Man(2, "c") };
        Arrays.sort(msMans);
        System.out.println(Arrays.toString(msMans));
    }
}


class Man implements Comparable {
    int age;
    int id;
    String name;


    public Man(int age, String name) {
        super();
        this.age = age;
        this.name = name;
    }


    public String toString() {
        return this.name;
    }


    public int compareTo(Object o) {
        Man man = (Man) o;
        if (this.age < man.age) {
            return -1;
        }
        if (this.age > man.age) {
            return 1;
        }
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39