java基础学习笔记(一)JDK安装--变量--数据类型--运算符--控制语句--方法--类的定义--内存分析--垃圾回收--继承--封装--多态

Java 程序的运行机制

 

计算机高级语言的类型主要有编译型和解释型两种，而 Java 语言是两种类型的结合。Java 首先利用文本编辑器编写 Java 源程序，源文件的后缀名为.java；再利用编译器（javac）将源程序编译成字节码文件，字节码文件的后缀名为.class； 最后利用虚拟（解释器，java）解释执行。如图所示。

JVM、JRE 和 JDK

 

JVM(Java Virtual Machine) 就是一个虚拟的用于执行 bytecode 字节码的”虚拟计算机”。他也定义了指令集、寄存器集、结构栈、垃圾收集堆、内存区域。JVM 负责将 Java字节码解释运行，边解释边运行，这样，速度就会受到一定的影响。

不同的操作系统有不同的虚拟机。Java 虚拟机机制屏蔽了底层运行平台的差别 ，实现了“一次编译，随处运行”。 Java 虚拟机是实现跨平台的核心机制。

 

 

Java Runtime Environment (JRE) 包含： Java 虚拟机、库函数、运行 Java 应用程序所必须的文件。

Java Development Kit (JDK)包含：包含 JRE，以及增加编译器和调试器等用于程序开发的文件。

 

JDK、JRE 和 JVM的关系如图所示。

---

Java 开发环境搭建

 

JDK 下载和安装

1. 下载地址，点击进入： www.oracle.com/technetwork/java/javase/downloads/index.html

点击下载 JDK，会出现下载列表界面。首先，点击”Accept License Agreement”，然后选择对应的版本，下载即可。

 

2. 安装过程和普通软件安装没什么区别，过程中会让你选择 JDK 安装目录，采用默认即可。也就是说，通通点击“下一步”就能完成安装。

 

环境变量的配置

 

环境变量是在操作系统中一个具有特定名字的对象， 它包含了一个或者多个应用程序所将使用到的信息。

Path 是一个常见的环境变量，它告诉操作系统，当要求系统运行一个程序而没有告诉它程序所在的完整路径时，系统除了在当前目录下寻找此程序外，还应到哪些目录下寻找。

1. 右键计算机 ——> 属性 ——> 高级系统设置，单击环境变量按钮，进入环境变量操作主界面：

 

单击新建按钮，新建 JAVA_HOME 变量（用于说明 JDK 的安装目录）

修改系统环境变量 Path，添加 %JAVA_HOME%\bin。

 

classpath 配置问题

如果使用 JDK1.5 以上就不需要配置这个环境变量！JRE 会自动搜索当前路径下的类文件及相关 jar 文件。

 

测试 JDK 安装成功

进入命令行窗口，开始菜单搜索框输入“cmd”即可，如图 1-18 所示。在窗口中输入命令“java -version ”，回车。出现如下结果，则说明 JDK 安装成功。

 

---

变量和数据类型和运算符

1.注释

为了方便程序的阅读，Java 语言允许程序员在程序中写上一些说明性的文字，用来提高程序的可读性，这些文字性的说明就称为注释。注释不会出现在字节码文件中，即 Java 编译器编译时会跳过注释语句。在 Java 中根据注释的功能不同，主要分为单行注释、多行注释和文档注释。

单行注释:  单行注释使用“//”开头，“//”后面的单行内容均为注释

多行注释: 多行注释以“/*”开头以“*/”结尾，在“/*”和“*/”之间的内容为注释，

我们也可以使用多行注释作为行内注释。但是在使用时要注意，多行注释不能嵌套使用。

 

文档注释: 文档注释以“/**”开头以“*/”结尾，注释中包含一些说明性的文字及一些JavaDoc 标签（后期写项目时，可以生成项目的 API）

 

2.标识符

 

标识符是用来给变量、类、方法以及包进行命名的，如 Welcome、main、System、age、name、gender 等。标识符需要遵守一定的规则：

标识符必须以字母、下划线_、美元符号$开头。

标识符其它部分可以是字母、下划线“_”、美元符“$”和数字的任意组合。

Java 标识符大小写敏感，且长度无限制。

标识符不可以是 Java 的关键字。

 

标识符的使用规范

表示类名的标识符：每个单词的首字母大写，如 Man, GoodMan

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

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

 

3.变量

变量本质上就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什 么值不确定。我们可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。

Java 是一种强类型语言，每个变量都必须声明其数据类型。 变量的数据类型决定了变量占据存储空间的大小。 比如，int a=3; 表示 a 变量的空间大小为 4 个字节。

变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储空间。

 

变量的声明:

double salary; 
long earthPopulation; 
int age;

//声明变量的同时初始化
int age = 18; 
double e = 2.718281828;

4.变量的分类和作用域

从整体上可将变量划分为局部变量、成员变量(也称为实例变量)和静态变量。

局部变量(local variable):

方法或语句块内部定义的变量。生命周期是从声明位置开始到到方法或语句块执行完毕为止。局部变量在使用前必须先声明、初始化(赋初值)再使用。

 

成员变量（也叫实例变量 member variable）:

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

 

静态变量（类变量 static variable）:

使用 static 定义。 从属于类，生命周期伴随类始终，从类加载到卸载。如果不自行初始化，与成员变量相同会自动初始化成该类型的默认初始值

 

常量(Constant):

常量通常指的是一个固定的值，例如：1、2、3、’a’、’b’、true、false、”helloWorld”等。

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

public class TestConstants { 
    public static void main(String[ ] args) { 
        final double PI = 3.14; 
        // PI = 3.15; //编译错误，不能再被赋值！ 
        double r = 4; 
        double area = PI * r * r; 
        double circle = 2 * PI * r; 
        System.out.println("area = " + area); 
        System.out.println("circle = " + circle); 
    } 
}

5.基本数据类型

Java 是一种强类型语言，每个变量都必须声明其数据类型。 Java 的数据类型可分为两大类：基本数据类型（primitive data type）和引用数据类型（reference data type）。

 

Java 中定义了 3 类 8 种基本数据类型:

  数值型－ byte、 short、int、 long、float、 double

  字符型－ char

  布尔型－boolean

 

引用数据类型:数组,类,接口< 引用数据类型的大小统一为 4 个字节，记录的是其引用对象的地址！>

 

整型

整型用于表示没有小数部分的数值，它允许是负数。整型的范围与运行 Java 代码的机器无关，这正是 Java 程序具有很强移植能力的原因之一。与此相反，C 和 C++程序需要针对不同的处理器选择最有效的整型。

 

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

十进制整数，如：99, -500, 0

八进制整数，要求以 0 开头，如：015

十六进制数，要求 0x 或 0X 开头，如：0x15

二进制数，要求 0b 或 0B 开头，如：0b01110011

 

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

long 类型常数的写法及变量的声明:

long a = 55555555; //编译成功，在 int 表示的范围内(21 亿内)。 
long b = 55555555555;//不加 L 编译错误，已经超过 int 表示的范围。 

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

浮点型

带小数的数据在 Java 中称为浮点型。浮点型可分为 float 类型和 double 类型。

 

 

float 类型又被称作单精度类型，尾数可以精确到 7 位有效数字，在很多情况下，float类型的精度很难满足需求。而 double 表示这种类型的数值精度约是 float 类型的两倍，又被称作双精度类型， 绝大部分应用程序都采用 double 类型。

 

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

//float 类型常量的写法及变量的声明 

float f = 3.14F;//float 类型赋值时需要添加后缀 F/f 
double d1= 3.14; 
double d2 = 3.14D;

 

/*浮点类型 float，double 的数据不适合在不容许舍入误差的金融计算领域。如果需要进 行不产生舍入误差的精确数字计算，需要使用 BigDecimal 类。*/

float f = 0.1f; 
double d = 1.0/10; 
System.out.println(f==d);//结果为 false

float d1 = 423432423f; 
float d2 = d1+1; 
if(d1==d2){ 
    System.out.println("d1==d2");//输出结果为 d1==d2 
}else{
    System.out.println("d1!=d2"); 
}

/*
运行以上两个示例，发现示例1的结果是“false”，而示例2的输出结果是“d1==d2”。 这是因为由于字长有限，
浮点数能够精确表示的数是有限的，因而也是离散的。 浮点数一 般都存在舍入误差，很多数字无法精确表示
(例如0.1)，其结果只能是接近， 但不等于。二 进制浮点数不能精确的表示0.1、0.01、0.001这样10的负次
幂。并不是所有的小数都能可 以精确的用二进制浮点数表示。 java.math 包下面的两个有用的类：
BigInteger 和 BigDecimal，这两个类可以处理任 意长度的数值。BigInteger 实现了任意精度的整数运
算。BigDecimal 实现了任意精度的浮点运算。

*/

不要使用浮点数进行比较！很多新人甚至很多理论不扎实的有工作经验的程序员也会犯这个错误！需要比较请使用 BigDecimal 类

 

public class Main { 
    public static void main(String[ ] args) { 
        BigDecimal bd = BigDecimal.valueOf(1.0); 
        bd = bd.subtract(BigDecimal.valueOf(0.1)); 
        bd = bd.subtract(BigDecimal.valueOf(0.1)); 
        bd = bd.subtract(BigDecimal.valueOf(0.1)); 
        bd = bd.subtract(BigDecimal.valueOf(0.1)); 
        bd = bd.subtract(BigDecimal.valueOf(0.1)); 
        System.out.println(bd);//0.5 System.out.println(1.0 - 0.1 - 0.1 - 0.1 - 0.1 - 
0.1);//0.5000000000000001 
    } 
}

字符型

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

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

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

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

 

boolean 型

boolean 类型有两个常量值，true 和 false，在内存中占一个字节或 4 个字节，不可以使用 0 或非 0 的整数替代 true 和 false ，这点和 C 语言不同。boolean 类型用来判断逻辑条件，一般用于程序流程控制。

在《Java 虚拟机规范》一书中的描述：“虽然定义了 boolean 这种数据类型，但是只对它提供了非常有限的支持。在 Java 虚拟机中没有任何供 boolean 值专用的字节码指令，Java 语言表达式所操作的boolean 值，在编译之后都使用 Java 虚拟机中的 int 数据类型来代替，而 boolean 数组将会被编码成 Java 虚拟机的 byte 数组，每个元素 boolean 元素占 8 位”。也就是说 JVM 规范指出 boolean 当做 int 处理，也就是 4 字节，boolean 数组当做 byte 数组处理，这样我们可以得出 boolean 类型占了单独使用是 4 个字节，在数组中是确定的 1 个字节。

运算符(operator)

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java 也提供了一套

丰富的运算符来操作变量。

 

6.运算符(operator)

计算机的最基本用途之一就是执行数学运算，作为一门计算机语言，Java 也提供了一套丰富的运算符来操作变量。

算术运算符中+，-，*，/，%属于二元运算符，二元运算符指的是需要两个操作数才能完成运算的运算符。其中的%是取模运算符，就是我们常说的求余数操作。

二元运算符的运算规则：

 

整数运算：

如果两个操作数有一个为 long, 则结果也为 long。

没有 long 时，结果为 int。即使操作数全为 short，byte，结果也是 int。

 

浮点运算：

如果两个操作数有一个为 double，则结果为 double。

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

 

取模运算：

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

 

赋值及其扩展赋值运算符:

 

关系运算符 :

 

逻辑运算符

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

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

位运算符

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

 

 条件运算符:

x ? y : z

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

 

运算符优先级的问题

 

7.数据类型的转换

我们讲解了八种基本数据类型，除了 boolean 类型之外的七种类型是可以自动转化的。甚至，我们也可以使用“强制类型转换”将数据类型变成我们所需要的。本节详细讲解关于类型转换的细节。

 

自动类型转换

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

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

 

强制类型转换

 

强制类型转换，又被称为造型（cast），用于强制的转换一个数值的类型。在有可能丢失信息的情况下进行的转换是通过造型来完成的，但可能造成精度降低或溢出。

(type)var  运算符“()”中的 type 表示将值 var 想要转换成的目标数据类型。

double x = 3.94; 
int nx = (int)x; //值为 3 

char c = 'a'; 
int d = c+1; 
System.out.println(nx); //值为3
System.out.println(d);  //值为98
System.out.println((char)d);  //值为b

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

 

int x = 300; 
byte bx = (byte)x; //值为 44

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

 

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

 

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);

---

简单的键盘输入和输出

为了我们能写出更加复杂的程序，可以让我们的程序和用户可以通过键盘交互，我们先学习一下简单的键盘输入和输出。

//使用 Scanner 获取键盘输入 
import java.util.Scanner; 
public class Welcome2 { 
    public static void main(String[ ] args) { 
        // 将输入的一行付给 string1 String string1 = scanner.nextLine(); 
        Scanner scanner = new Scanner(System.in); 
        
        // 将输入单词到第一个空白符为止的字符串付给 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 条件判断结构

在还没有知道 Java 选择结构的时候，我们编写的程序总是从程序入口开始，顺序执行每一条语句直到执行完最后一条语句结束，但是生活中经常需要进行条件判断，根据判断结果决定是否做一件事情，这就需要选择结构。

选择结构用于判断给定的条件，然后根据判断的结果来控制程序的流程。主要的条件判断结构有：if 结构和 switch 结构。而 if 结构又可以分为 if 单分支结构、if-else 双分支结构、if-else if-else 多分支结构。

 

1.1 if 单分支结构

if 语句对布尔表达式进行一次判定，若判定为真，则执行{}中的语句块，否则跳过该语句块。

 

1.2 if-else 双分支结构

当布尔表达式为真时，执行语句块 1，否则，执行语句块 2。也就是 else 部分。

 

条件运算符有时候可用于代替 if-else

 

1.3 if-else if-else 多分支结构

 

2 switch 语句

switch (表达式) { 
    case 值 1: 
        语句序列 1; 
        [break]; 
    case 值 2: 
        语句序列 2; 
        [break];
     … … … … … 
    [default: 
        默认语句;
    ] 
}

switch 语句会根据表达式的值从相匹配的 case 标签处开始执行，一直执行到 break语句处或者是 switch 语句的末尾。如果表达式的值与任一 case 值不匹配，则进入 default语句（如果存在 default 语句的情况）。

根据表达式值的不同可以执行许多不同的操作。 switch 语句中 case 标签在 JDK1.5之前必须是整数（long 类型除外）或者枚举，不能是字符串，在 JDK1.7 之后允许使用字符串(String)。

大家要注意，当布尔表达式是等值判断的情况，可以使用 if-else if-else 多分支结构或者 switch 结构，如果布尔表达式区间判断的情况，则只能使用 if-else if-else 多分支结构。

 

3 循环结构(while)

3.1 while 循环

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

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

//while 循环结构：求 1 到 100 之间的累加和 

public class Test7 { 
    public static void main(String[ ] args) { 
        int i = 0; 
        int sum = 0; // 1+2+3+…+100=? 
        while (i <= 100) { 
            sum += i;//相当于 sum = sum+i; 
            i++; 
        }    
        System.out.println("Sum= " + sum); 
    } 
}

3.2 do-while 循环

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

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

 

3.3循环结构(for)

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

for 循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
for 循环在 第一次反复之前要进行初始化，即执行初始表达式；
随后，对布尔表达式进行判定，若判定 结果为 true，则执行循环体，否则，终止循环；
最后在每一次反复的时候，进行某种形式 的“步进”，即执行迭代因子。 
初始化部分设置循环变量的初值 
条件判断部分为任意布尔表达式 
迭代因子控制循环变量的增减 
for 循环在执行条件判定后，先执行的循环体部分，再执行步进。

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

 

初始化变量的作用域

public class Test13 { 
    public static void main(String[] args) { 
        for(int i = 1; i < 10; i++) { 
            System.out.println(i+"、"); 
        }
        System.out.println(i);//编译错误，无法访问在 for 循环中定义的变量 i 
    } 
}

4 嵌套循环

在一个循环语句内部再嵌套一个或多个循环，称为嵌套循环。while、do-while 与 for循环可以任意嵌套多层。一般工作中多见的就是两层。

//使用嵌套循环实现九九乘法表 

public class Test15 { 
    public static void main(String args[ ]) { 
        for (int i = 1; i < 10; i++) { 
            // i 是一个乘数 
            for (int j = 1; j <= i; j++) { 
                // j 是另一个乘数 
                System.out.print(j + "*" + i + "=" + (i * j < 10 ? (" " + i * j) : i * j) +
 " "); }
            System.out.println(); 
        } 
    } 
}

5 break 语句和 continue 语句

在任何循环语句的主体部分，均可用 break 控制循环的流程。break 用于强行退出循环，不执行循环中剩余的语句。

continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句，接着进行下一次是否执行循环的判定。

continue 用在 while，do-while 中，continue 语句立刻跳到循环首部，越过了当前循环的其余部分。

continue 用在 for 循环中，跳到 for 循环的迭代因子部分。

 

//把 100~150 之间不能被 3 整除的数输出，并且每行输出 5 个 
public class Test17 { 
    public static void main(String[ ] args) { 
        int count = 0;//定义计数器 
        for (int i = 100; i < 150; i++) { 
            //如果是 3 的倍数，则跳过本次循环，继续进行下一次循环 
            if (i % 3 == 0){ 
                continue; 
            }
            //否则（不是 3 的倍数），输出该数 
            System.out.print(i + "、"); 
            count++;//没输出一个数，计数器加 1 
            //根据计数器判断每行是否已经输出了 5 个数 
            if (count % 5 == 0) { 
                System.out.println(); 
            } 
        } 
    } 
}

6 方法

 

语句块

语句块（有时叫做复合语句），是用花括号扩起的任意数量的简单 Java 语句。块确定了局部变量的作用域。块中的程序代码，作为一个整体，是要被一起执行的。块可以被嵌套在另一个块中，但是不能在两个嵌套的块内声明同名的变量。语句块可以使用外部的变量，而外部不能使用语句块中定义的变量，因为语句块中定义的变量作用域只限于语句块。

 

方法

方法(method)就是一段用来完成特定功能的代码片段，类似于其它语言的函数 (function)。

方法用于定义该类或该类的实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

方法的详细说明

形式参数： 在方法声明时用于接收外界传入的数据。

实参： 调用方法时实际传给方法的数据。

返回值： 方法在执行完毕后返还给调用它的环境的数据。

返回值类型： 事先约定的返回值的数据类型，如无返回值，必须指定为 void。

 

实参的数目、数据类型和次序必须和所调用的方法声明的形式参数列表匹配。

return 语句终止方法的运行并指定要返回的数据。

Java 中进行方法调用中传递参数时，遵循值传递的原则(传递的都是数据的副本)：

基本类型传递的是该数据值的 copy 值。

引用类型传递的是该对象引用的 copy 值，但指向的是同一个对象。

 

方法的重载

方法的重载是指一个类中可以定义多个方法名相同，但参数不同的方法。 调用时，会根据不同的参数自动匹配对应的方法。

重载的方法，实际是完全不同的方法，只是名称相同而已！

构成方法重载的条件：

不同的含义：形参类型、形参个数、形参顺序不同

只有返回值不同不构成方法的重载

如：int a(String str){}与 void a(String str){}不构成方法重载

只有形参的名称不同，不构成方法的重载

如：int a(String str){}与 int a(String s){}不构成方法重载

 

7 递归结构

递归是一种常见的解决问题的方法，即把问题逐渐简单化。递归的基本思想就是“自己调用自己”，一个使用递归技术的方法将会直接或者间接的调用自己。

利用递归可以用简单的程序来解决一些复杂的问题。比如：斐波那契数列的计算、汉诺塔、快排等问题。

递归结构包括两个部分：

定义递归头 。解答：什么时候不调用自身方法。如果没有头，将陷入死循环，也就

是递归的结束条件。

递归体 。解答：什么时候需要调用自身方法。

public class Test22 { 
    public static void main(String[ ] args) { 
        long d1 = System.currentTimeMillis(); 
        System.out.printf("%d 阶乘的结果:%s%n", 10, factorial(10)); 
        long d2 = System.currentTimeMillis(); 
        System.out.printf("递归费时：%s%n", d2-d1); //耗时：32ms 
    }

    /** 求阶乘的方法*/ 
    static long factorial(int n){ 
        if(n==1){
            //递归头 
            return 1; 
        }else{
            //递归体 
            return n*factorial(n-1);//n! = n * (n-1)!
        } 
    } 
}

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

---

1. 类的定义

属性（field 成员变量）:

属性用于定义该类或该类对象包含的数据或者说静态特征。属性作用范围是整个类体。在定义成员变量时可以对其初始化，如果不对其初始化，Java 使用默认的值对其初始化。

 

 

方法:

方法用于定义该类或该类实例的行为特征和功能实现。 方法是类和对象行为特征的抽象。方法很类似于面向过程中的函数。面向过程中，函数是最基本单位，整个程序由一个个函数调用组成。面向对象中，整个程序的基本单位是类，方法是从属于类和对象的。

 

构造方法:

构造器也叫构造方法(constructor)，用于对象的初始化。构造器是一个创建对象时被自动调用的特殊方法，目的是对象的初始化。构造器的名称应与类的名称一致。Java 通过 new 关键字来调用构造器，从而返回该类的实例， 是一种特殊的方法。

构造器 4 个要点：

  构造器通过 new 关键字调用！！

  构造器虽然有返回值，但是不能定义返回值类型(返回值的类型肯定是本类)，不能在构造器里使用 return 返回某个值。

  如果我们没有定义构造器，则编译器会自动定义一个无参的构造方法。如果已定义则编译器不会自动添加！

 构造器的方法名必须和类名一致！

 

对象的创建完全是由构造方法实现的吗？

不完全是。构造方法是创建 Java 对象的重要途径，通过 new 关键字调用构造器时，构造器也确实返回了该类对象，但这个对象并不是完全由构造器负责创建的。创建一个对象分为如下四步：

1. 分配对象空间，并将对象成员变量初始化为 0 或空

2. 执行属性值的显式初始化

3. 执行构造方法

4. 返回对象的地址给相关的变量

---

 

2.面向对象的内存分析

 

从属于线程的内存区域(栈、计数器)

JVM 的内存划分中，有部分区域是线程私有的，有部分是属于整个 JVM 进程；我们将这部分归为一类。

1. 程序计数器（Program Counter Register)，在 JVM 规范中，每个线程都有自己的程序计数器。这是一块比较小的内存空间，存储当前线程正在执行的 Java 方法的 JVM 指令地址，即字节码的行号。如果正在执行 Native 方法，则这个计数器为空。

2. Java 虚拟机栈(Java Virtal Machine Stack)，同样也是属于线程私有区域，每个线程在创建的时候都会创建一个虚拟机栈，生命周期与线程一致，线程退出时，线程的虚拟机栈也回收。虚拟机栈内部保持一个个的栈帧，每次方法调用都会进行压栈，JVM 对栈帧的操作只有出栈和压栈两种，方法调用结束时会进行出栈操作。该区域存储着局部变量表，编译时期可知的各种基本类型数据、对象引用、方法出口等信息。

3. 本地方法栈（Native Method Stack）与虚拟机栈类似，本地方法栈是在调用本地方法时使用的栈，每个线程都有一个本地方法栈。

 

堆（heap）

堆（Heap）,几乎所有创建的 Java 对象实例，都是被直接分配到堆上的。堆被所有的线程所共享，在堆上的区域，会被垃圾回收器做进一步划分，例如新生代、老年代的划分。Java 虚拟机在启动的时候，可以使用“Xmx”之类的参数指定堆区域的大小。

 

方法区（Method Area)

方法区与堆一样，也是所有的线程所共享，存储被虚拟机加载的元（Meta）数据，包括类信息、常量、静态变量、即时编译器编译后的代码等数据。

 

运行时常量池（Run-Time Constant Pool)(方法区中)

这是方法区的一部分。常量池主要存放两大类常量：

1. 字面量（Literal），如文本字符串、final 常量值。

2. 符号引用，存放了与编译相关的一些常量，因为 Java 不像 C++那样有连接的过程，因此字段方法这些符号引用在运行期就需要进行转换，以便得到真正的内存入口地址。

 

直接内存（Direct Memory）

直接内存并不属于 Java 规范规定的属于 Java 虚拟机运行时数据区的一部分。Java 的NIO 可以使用 Native 方法直接在 java 堆外分配内存，使用 DirectByteBuffer 对象作为这个堆外内存的引用

 

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

1. 栈描述的是方法执行的内存模型。每个方法被调用都会创建一个栈帧（存储局部变量、操作数、方法出口等）

2. JVM 为每个线程创建一个栈，用于存放该线程执行方法的信息（实际参数、局部变量等）

3. 栈属于线程私有，不能实现线程间的共享！

4. 栈的存储特性是“先进后出，后进先出”

5. 栈是由系统自动分配，速度快！栈是一个连续的内存空间！

堆的特点如下：

1. 堆用于存储创建好的对象和数组(数组也是对象)

2. JVM 只有一个堆，被所有线程共享

3. 堆是一个不连续的内存空间，分配灵活，速度慢！

 

方法区（又叫静态区,也是堆）特点如下：

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

i. JDK7 以前是“永久代”

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

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

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

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

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

 

public class Person { 
    String name; 
    int age; 
    public void show(){ 
        System.out.println("姓名："+name+",年龄："+age); 
    } 
}


public class TestPerson { 
    public static void main(String[ ] args) { 
        // 创建p1对象 
        Person p1 = new Person(); 
        p1.age = 24; p1.name = "张三"; p1.show(); 
        // 创建p2对象 
        Person p2 = new Person(); 
        p2.age = 35; p2.name = "李四"; p2.show(); 
    } 
}

可以得出如下结论：

同一类的每个对象有不同的成员变量存储空间。

同一类的每个对象共享该类的方法。

 

参数传值机制

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

 

基本数据类型参数的传值

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

 

引用类型参数的传值

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

 

public class User { 
    int id; //id 
    String name; //账户名 
    String pwd; //密码
    public User(int id, String name) { 
        this.id = id; this.name = name; 
    }

    public static void main(String[ ] args) { 
        User u1 = new User(100, "高小七"); 
        User u3 = u1; 
        System.out.println(u1.name); 
        u3.name="张三"; 
        System.out.println(u1.name); 
    } 
}

//输出高小七,张三

---

 

3.垃圾回收机制

1. 垃圾回收原理和算法
   1. 内存管理

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

      对象空间的分配： 使用 new 关键字创建对象即可

      对象空间的释放： 将对象赋值 null 即可。垃圾回收器将负责回收所有”不可达”对象 的内存空间
   2. 垃圾回收过程

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

      1. 发现无用的对象

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

      垃圾回收机制保证可以将“无用的对象”进行回收。无用的对象指的就是没有任何变量 引用该对象。Java 的垃圾回收器通过相关算法发现无用对象，并进行清除和整理。
   3. 垃圾回收算法
      1. 引用计数法
      堆中的每个对象都对应一个引用计数器，当有引用指向这个对象时，引用计数器加1，而当指向该对象的引用失效时（引用变为 null），引用计数器减 1，最后如果该对象的引用计算器的值为 0 时，则 Java 垃圾回收器会认为该对象是无用对象并对其进行回收。优点是算法简单，缺点是“循环引用的无用对象”无法识别。

      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; 
          } 
      }

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

       

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

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

2. 通用的分代垃圾回收机制

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

   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：

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

    

    
3. JVM 调优和 Full GC
   在对 JVM 调优的过程中，很大一部分工作就是对于 Full GC 的调节。有如下原因可能
   导致 Full GC：
   1. 年老代（Tenured）被写满
   2. 持久代（Perm）被写满
   3. System.gc()被显式调用
   4. 上一次 GC 之后 Heap 的各域分配策略动态变化

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

   创建大量无用对象

   比如，我们在需要大量拼接字符串时，使用了 String 而不是 StringBuilder。

   静态集合类的使用

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

    

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

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

    

   监听器的使用不当

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

5. 其它要点

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

---

this、static 关键字

this 关键字

 

1. 对象创建的过程和 this 的本质:

构造方法是创建 Java 对象的重要途径，通过 new 关键字调用构造器时，构造器也确实返回该类的对象，但这个对象并不是完全由构造器负责创建。创建一个对象分为如下四步：

1. 分配对象空间，并将对象成员变量初始化为 0 或空

2. 执行属性值的显式初始化

3. 执行构造方法

4. 返回对象的地址给相关的变量

this 的本质就是“创建好的对象的地址”！ 由于在构造方法调用前，对象已经创建。因此，在构造方法中也可以使用 this 代表“当前对象”。

 

2. this 最常的用法：

在程序中产生二义性之处，应使用 this 来指明当前对象；普通方法中，this 总是指向调用该方法的对象。构造方法中，this 总是指向正要初始化的对象。

使用 this 关键字调用重载的构造方法，避免相同的初始化代码。但只能在构造方法中用，并且必须位于构造方法的第一句。

this 不能用于 static 方法中。

 

static 关键字

在类中，用 static 声明的成员变量为静态成员变量，也称为类变量。 类变量的生命周期和类相同，在整个应用程序执行期间都有效。它有如下特点：

1.为该类的公用变量，属于类，被该类的所有实例共享，在类被载入时被显式初始化。

2.对于该类的所有对象来说，static 成员变量只有一份。被该类的所有对象共享！！

3.一般用“类名.类属性/方法”来调用。（也可以通过对象引用或类名（不需要实例化）访问静态成员。）

4.在 static 方法中不可直接访问非 static 的成员。

---

包机制(package、import)

导入类 import

如果我们要使用其他包的类，需要使用 import 导入，从而可以在本类中直接通过类名来调用，否则就需要书写类的完整包名和类名。import 后，便于编写代码，提高可维护性。

Java 会默认导入 java.lang 包下所有的类，因此这些类我们可以直接使用。

如果导入两个同名的类，只能用包名+类名来显示调用相关类：

java.util.Date date = new java.util.Date();

import java.sql.Date; 
import java.util.*;//导入该包下所有的类。会降低编译速度，但不会降低运行速度。 

public class Test{ 
    public static void main(String[ ] args) { 
        //这里指的是java.sql.Date Date now; 
        //java.util.Date因为和java.sql.Date类同名，需要完整路径 
        java.util.Date now2 = new java.util.Date(); 
        System.out.println(now2);
        //java.util包的非同名类不需要完整路径 
        Scanner input = new Scanner(System.in); 
    } 
}

静态导入

静态导入(static import)是在 JDK1.5 新增加的功能，其作用是用于导入指定类的静态属性和静态方法，这样我们可以直接使用静态属性和静态方法。

package cn.sxt; 
//以下两种静态导入的方式二选一即可 
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. 方便建模

 

1 继承的实现

继承让我们更加容易实现类的扩展。 比如，我们定义了人类，再定义 Boy 类就只需要扩展人类即可。实现了代码的重用，不用再重新发明轮子(don’t reinvent wheels)。

从英文字面意思理解，extends 的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。比如：

 

上图中，哺乳动物继承了动物。意味着，动物的特性，哺乳动物都有；在我们编程中，如果新定义一个 Student 类，发现已经有 Person类包含了我们需要的属性和方法，那么 Student类只需要继承 Person 类即可拥有 Person 类的属性和方法。

 

2 instanceof 运算符

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

 

3 继承使用要点

1. 父类也称作超类、基类。子类：派生类等。

2. Java 中只有单继承，没有像 C++那样的多继承。多继承会引起混乱，使得继承链

过于复杂，系统难于维护。

3. Java 中类没有多继承，接口有多继承。

4. 子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。

5. 如果定义一个类时，没有调用 extends，则它的父类是：java.lang.Object。

 

4 方法的重写 override

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

 

继承和组合

我们可以通过继承方便的复用已经定义类的代码。还有一种方式，也可以方便的实现“代码复用”，那就是：“组合”。

“组合”不同于继承，更加灵活。

“组合”的核心就是“将父类对象作为子类的属性”，然后，“子类通过调用这个属性来获得父类的属性和方法”。

public class Test{ 
    public static void main(String[ ] args) {
        Student s = new Student("微微",172,"Java"); 
        s.person.rest(); //s.rest(); 
        s.study(); 
    } 
}

class Person { 
    String name; 
    int height; 
    public void rest(){ 
        System.out.println("休息一会！"); 
    } 
}

class Student /*extends Person*/ { 
    Person person = new Person(); 
    String major; //专业 
    public Student(String name,int height,String major) { 
        //天然拥有父类的属性 
        this.person.name = name; //this.name = name; 
        this.person.height = height; //this.height = height;
         this.person.rest(); 
        this.major = major; 
    } 

}

---

Object 类详解

 

1 Object 类基本特性

Object 类是所有 Java 类的根基类，也就意味着所有的 Java 对象都拥有 Object 类的属性和方法。如果在类的声明中未使用 extends 关键字指明其父类，则默认继承 Object 类。

 

IDEA 快捷键和相关操作：

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

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

3. 查看类的关系：鼠标放到类名上，右键-->Diagram-->show Diagram

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

5. 鼠标悬停显示提示（重新设置：File-->Setting-->Editor-->general）

 

2 toString 方法

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

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

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

3 ==和 equals 方法

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

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

Object 的 equals 方法默认就是比较两个对象的 hashcode，是同一个对象的引用时返回 true 否则返回 false。但是，我们可以根据我们自己的要求重写 equals 方法。

 

4 super 关键字

super“可以看做”是直接父类对象的引用。可以通过 super 来访问父类中被子类覆盖的方法或属性。

使用 super 调用普通方法，语句没有位置限制，可以在子类中随便调用。

在一个类中，若是构造方法的第一行代码没有显式的调用 super(...)或者 this(...);那么Java 默认都会调用 super(),含义是调用父类的无参数构造方法。这里的 super()可以省略。

---

封装

封装是面向对象三大特征之一。对于程序合理的封装让外部调用更加方便，更加利于写作。同时，对于实现者来说也更加容易修正和改版代码。

未进行封装的代码演示 

class Person { 
    String name; 
    int age; 
    public String toString() { 
        return "Person [name=" + name + ", age=" + age + "]"; 
    } 
}

public class Test { 
    public static void main(String[ ] args) { 
        Person p = new Person(); 
        p.name = "小红"; 
        p.age = -45;//年龄可以通过这种方式随意赋值，没有任何限制 
        System.out.println(p); 
    } 
}

//我们都知道，年龄不可能是负数，也不可能超过 130 岁，但是如果没有使用封装的话，便可以给年龄赋值成
任意的整数，这显然不符合我们的正常逻辑思维。

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

 

Java 是使用“访问控制符”来控制哪些细节需要封装，哪些细节需要暴露的。 Java中 4 种“访问控制符”分别为 private、default、protected、public，它们说明了面向对象的封装性，所以我们要利用它们尽可能的让访问权限降到最低，从而提高安全性。

 

1. private 表示私有，只有自己类能访问

2. default 表示没有修饰符修饰，只有同一个包的类能访问

3. protected 表示可以被同一个包的类以及其他包中的子类访问

4. public 表示可以被该项目的所有包中的所有类访问

 

2.封装的使用细节

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

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

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

 

---

多态

1 多态概念和实现

多态指的是同一个方法调用，由于对象不同可能会有不同的行为。 现实生活中，同一个方法，具体实现会完全不同。 比如：同样是调用人的“休息”方法，张三是睡觉，李四是旅游，高淇老师是敲代码，数学教授是做数学题； 同样是调用人“吃饭”的方法，中国人用筷子吃饭，英国人用刀叉吃饭，印度人用手吃饭。

多态的要点：

1. 多态是方法的多态，不是属性的多态（多态与属性无关）。

2. 多态的存在要有 3 个必要条件：继承，方法重写，父类引用指向子类对象。

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

class Animal { 
    public void shout() { 
        System.out.println("叫了一声！"); 
    }
}

class Dog extends Animal { 
    public void shout() { 
        System.out.println("旺旺旺！"); 
    }
    public void seeDoor() { 
        System.out.println("看门中...."); 
    } 
}

class Cat extends Animal { 
    public void shout() { 
        System.out.println("喵喵喵喵！"); 
    } 
}

public class TestPolym { 
    public static void main(String[ ] args) { 
        Animal a1 = new Cat(); // 向上可以自动转型 
        //传的具体是哪一个类就调用哪一个类的方法。大大提高了程序的可扩展性。 
        animalCry(a1); 
        Animal a2 = new Dog(); 
        animalCry(a2);//a2 为编译类型，Dog 对象才是运行时类型。 
        /*编写程序时，如果想调用运行时类型的方法，只能进行强制类型转换。 
        * 否则通不过编译器的检查。*/ 
        Dog dog = (Dog)a2;//向下需要强制类型转换 
        dog.seeDoor(); 
}

// 有了多态，只需要让增加的这个类继承 Animal 类就可以了。 
static void animalCry(Animal a) { 
    a.shout(); 
}
/* 如果没有多态，我们这里需要写很多重载的方法。 
* 每增加一种动物，就需要重载一种动物的喊叫方法。非常麻烦。 
static void animalCry(Dog d) { 
    d.shout(); 
}
static void animalCry(Cat c) { 
    c.shout(); 
}
*/ 
}

由此，我们可以看出多态的主要优势是提高了代码的可扩展性，符合开闭原则。但是多态也有弊端，就是无法调用子类特有的功能，比如，我不能使用父类的引用变量调用 Dog类特有的 seeDoor()方法。

那如果我们就想使用子类特有的功能行不行呢？行！这就是我们下一章节所讲的内容：对象的转型。

 

2 对象的转型(casting)

父类引用指向子类对象，我们称这个过程为向上转型，属于自动类型转换。

向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它运行时类型的方法。这时，我们就需要进行类型的强制转换，我们称之为向下转型！

在向下转型过程中，必须将引用变量转成真实的子类类型(运行时类型）否则会出现类型转换异常 ClassCastException。

为了避免出现这种异常，我们可以使用所学的 instanceof 运算符进行判断