尚硅谷-IT精英计划_JavaSE内部学习笔记

【尚硅谷-IT精英计划】

JavaSE学习笔记

视频下载导航（Java学习路线图）

JavaEE学科体系：

Android学科体系：

--------------------------------------JavaSE学习目录------------------------------------

第1章：Java语言概述

第2章：基本语法

第3章：面向对象编程

第4章：高级类特性1

第5章：高级类特性2

第6章：异常处理

第7章：Java集合

【基础体系框架】

第8章：泛型

第9章：注解 & 枚举

第10章：IO流

第11章：多线程

第12章：Java常用类

第13章：Java反射

第14章：网络编程

--------------------------------第1章：Java语言概述 -------------------------------

1.1 基础常识

软件：系统软件和应用软件

人机交互方式：图形化界面和命令行方式

常用的DOS命令：

dir : 列出当前目录下的文件以及文件夹

md : 创建目录

rd : 删除目录

cd : 进入指定目录

cd.. : 退回到上一级目录

cd: 退回到根目录

del : 删除文件

exit : 退出 dos 命令行

---->学会如何在DOS命令下编译并运行java源程序（重点）：

1.2 Java语言概述

 了解语言的分代：第一代：机器语言 第二代：汇编语言 第三代：高级语

言（面向过程 & 面向对象）

1.3 Java程序运行机制及运行过程

Java语言的特点：①纯面向对象性：类&对象；面向对象的三大特性：封装性、

继承性、多态、（抽象）

②健壮性：----->Java的内存回收机制

③跨平台性：一次编译，到处运行。 ----->JVM

1.4 Java语言的环境搭建：掌握下载、安装JDK，并且配置环境变量（重点）

1）JDK 和 JRE 以及 JVM的关系

2）JDK的安装

3）配置path环境变量 path：window执行命令时所需要搜寻的路径。

将 D:Javajdk1.7.0_07bin复制在path环境变量下。

1.5 开发体验 — HelloWorld

public class HelloWorld{

}

1.6 小结第一个程序

1) Java源文件以“java”为扩展名。源文件的基本组成部分是类（class），如本类

中的HelloWorld类。

2) 一个Java源程序中可以存在多个class类，但是最多只能有一个类声明为public.

若存在声明为public的类，那么这个源程序文件的名字必须以此类的类名来命名

3) 程序的入口是public static void main(String[] args){} 称为主方法。它的写法是

固定的。

4) Java方法由一条条语句构成，每个语句以“；”结束。

5) Java语言严格区分大小写

6) 大括号都是成对出现的，缺一不可，用于表明类中成员的作用范围。

1.7 常见问题及解决方法

1.8 注 释

作用：提高了代码的阅读性；调试程序的重要方法。

三种注释：

当行注释：//注释的内容

多行注释:/*注释的内容*/

文档注释（Java所特有的，可以为javadoc命令所解析）：/** 注释的内容 */

1.9Java API文档： API:application programming interface

public static void main(String[] args){

}

n("HelloWorld!!");

--------------------------------第2章：基本语法 -------------------------------

2.1关键字 & 保留字

被Java语言赋予了特殊含义，用做专门用途的字符串（单词）

2.2标识符

凡是自己可以起名字的地方都叫标识符。

通常有：类名、变量名、方法名。。。。包名、接口名、。。。

规则：（必须按照如下的规则执行，一旦某规则不符合，编译运行时就会出问题）

由26个英文字母大小写，0-9 ，_或 $ 组成

数字不可以开头。

不可以使用关键字和保留字，但能包含关键字和保留字。

Java中严格区分大小写，长度无限制。

标识符不能包含空格。

命名的习惯：（如果不遵守，实际上程序编译运行也不会出问题）

包名：多单词组成时所有字母都小写：xxxyyyzzz

类名、接口名：多单词组成时，所有单词的首字母大写：XxxYyyZzz

变量名、方法名：多单词组成时，第一个单词首字母小写，第二个单词开始每个

单词首字母大写：xxxYyyZzz

常量名：所有字母都大写。多单词时每个单词用下划线连接：XXX_YYY_ZZZ

2.3变量

1.变量的分类

1）存在的位置的不同：成员变量（属性、Field）(存在于类内部，方法体的外部)

和局部变量(方法体的内部、

构造器的内部、代码块的内部、方法体或构造器的形参部分)

2）数据类型的不同：

基本数据类型（8种)

整型：byte(1个字节)、short、int（默认值类型）、long（后缀是l或L）。

浮点型：float（后缀是f或F）和double（默认值类型）。

布尔型：boolean （只有两个值：true和false，绝对不会取值为null）

字符型：char（1个字符）

引用数据类型：类（比如：String字符串类型）、接口、数组

2.如何声明：

变量的类型 变量的名字 初始化值（显式的初始化、默认初始化）

int i;

i = j + 12;

boolean b = false;

String str = "atguigu";

Customer c = new Customer();

3.变量必须先声明后使用

4.使用变量注意：

变量的作用域：一对{ }之间有效

初始化值

5.自动类型转化&强制类型转化（重点）（不包含boolean型，及String型）

1）强制类型转化时，可能会损失精度。

2.4进制

十进制

二进制

八进制

十六进制

1.进制之间的转化：

会将-128到127范围内的十进制转化为二进制 & 能将一个二进制数转换为十

进制数（延伸：十进制、二进制、八进制、十六进制）

2.对于几类基本类型的数据的某个具体值，能够用二进制来表示。同时，如果给

出一个数据的二进制，要能够会

转化为十进制！

正数：原码、反码、补码三码合一。

负数：原码、反码、补码的关系。负数在计算机底层是以补码的形式存储的。

2.5运算符

算术运算符

赋值运算符

比较运算符（关系运算符）

逻辑运算符

“&”和“&&”的区别：&：当左端为false时，右端继续执行

&&：当左端为false时，右端不再执行

“|”和“||”的区别：|：当左端为true时，右端继续执行

位运算符

<< >> >>> & | ^ ~

三元运算符

||：当左端为true时，右端不再执行

1.三元运算符与if-else语句的联系

1）三元运算符可以简化if-else语句

2）三元运算符一定要返回一个结果。结果的类型取决于表达式1和2的类

型。（表达式1和2是同种类型的）

3）if-else语句的代码块中可以有多条语句。

2.6流程控制

条件判断：

if(表达式1){

//执行语句

}else if(表达式2){

//执行语句

}else{

}

//执行语句

1.一旦执行条件判断语句，有且仅有一个选择“路径”里的代码块被执行。

2.如果多条表达式间是“互斥”关系，彼此是可以调换顺序。

如果多条表达式间存在“包含”关系，一定要将范围小的表达式写在范围大的

表达式对应的语句的上面。

3.选择判断语句可以“嵌套”

4.

若执行语句只有一句，那么对应的一对{}可以省略。

选择结构：switch-case

1.结构

2.表达式可以存放的数据类型：int byte short char String 枚举

3.表达式存放是数值或者说是离散的点所代表的常量，绝对不是取值范围。

t是可选的。default的位置也不是固定的，当没有匹配的case时，执行

default

在switch-case中的使用。当执行到某条case语句后，使用break可以跳

出当前的switch语句。

如果此case中没有break，那么，程序将依次执行下面的case语句，直至程序

结束或者遇到break。

【switch-case 与if-else if-else的联系】

1.表达式是一些离散的点，并且取值范围不是很大，要求是int byte short char

String 枚举类型之一。

建议使用switch-case。执行效率更高

2.如果表达式表示的是范围（或区间）、取值范围很大，建议使用if-else if-else

循环结构：①初始化条件②循环条件部分③循环体部分④迭代部分

循环

for(①;②;④){

}

执行顺序：①-②-③-④-②-③-④-…-②-③-④-②截止

//死循环：

for(;;){

}

循环

①

while(②){

}

//死循环：

while(1>0){

}

注意：for循环和while循环之间可以相互转化！

-while循环

①

//要循环执行的代码

③

④

//要循环执行的代码。

③

do{

③

④

}while(②);

//程序至少执行一次!

掌握：1.会使用for循环和while循环

2.能够实现for循环和while循环的相互转化。

循环可以相互嵌套

例题1.九九乘法表；

例题2.输入1-1000之间的所有质数

2.7 关键字：break & continue

break

1.使用范围：循环结构或switch-case结构中。

2.在循环结构中：一旦执行到break，代表结束当前循环。

continue

1.使用范围：循环结构

2.在循环结构中：一旦执行到continue,代表结束当次循环。

相同点：如果break或continue后面还有代码，那么这些代码将不会被执行。所

以当有代码，编译会出错！

如何使用标签，实现结束指定“层次”的循环。（理解）

例题：

class Test{

public static void main(String[] args){

for(int i = 1 ;i <= 100;i++){

}

}

}

if(i % 10 == 0){

}

n(i);

break;

//continue;

//下面不能写入任何代码

2.8数组

1.如何创建一维数组

1）数组的声明： int[] i ; String[] str; Animal[] animal;

2)数组的初始化：

①动态初始化：i = new int[4]; //i[0]开始，至i[3]结束。默认初始化值都为0;

i[0] = 12;i[1] = 34;....

②静态初始化：str = new String[]{"北京","尚硅谷","java0715班"};

//也是先有默认初始化赋值，然后显示的初始化，替换原来的默认初始化值

//对于引用数据类型来说，默认初始化值为null。

//对于基本数据类型来说: byte、short、int ：0 long :0L float : 0.0F double :

0.0 char :'u0000' boolean : false 引用类型：null

2.数组元素的下角标从0开始。

3. float[] f = new float[]{1.2F,3.4F,5.6F};

double[] d = new double[4]; d[1] = 3.4;.....

4.数组的长度: .length;

5.数组的遍历：（习惯使用for循环）

for(int i = 0 ;i < ;i++){

}

(f[i] + "t");

6.常见的异常：

1）ArrayIndexOutOfBoundsException :数组下标越界异常 下标从0 开始，到

length-1结束。如果下角标的取值不在此范围内，将报此异常

2）空指针异常(NullPointerException)

2.二维数组

1)

①动态初始化：

---> int[][] i = new int[3][]; i[0] = new int[2]; i[1] = new int[3]; i[1] = new int[4];

--->String[][] str = new String[2][4];

② 静态初始化：

int[][] i = new int[][]{{1,2,3},{3,4},{0}};

2)遍历（补充完整）

7.

数组常用的算法：最大值、最小值、和、平均数、排序（涉及数据结构中各

种排序算法）、复制、反转。

8. Arrays：操作数组的工具类

(数组类型形参); 可以对形参部分的数组进行排序，默认是从小到

大的顺序。

--------------------------------第3章：面向对象编程 -------------------------------

3.1面向过程与面向对象

1.面向过程关注于功能和行为

面向对象关注于功能和行为所属的对象。

语言，作为面向对象的语言，更多的关注于类的设计！

3.面向对象两大元素：类和对象

三大特性：封装、继承、多态、（抽象）

3.2类

的源程序是由一个一个的类构成的。

源文件名【类名】

class 类名1{

属性1

属性2

。。。

方法1(){

}

方法2(){

}

.....

}

class 类名2{

}

public class 类名3{

}

2.类的组成部分：1）属性 2） 方法 3）构造器 4）代码块 5）内部类

1）属性（Field、成员变量、字段）：定义在类内部，方法外部的变量。

①格式：修饰符(public private 缺省 protected) 数据类型 名字 = 初始化值

②属性的初始化值：如果不显式初始化的话，系统会根据属性的数据类型，

隐式初始化。

当你显式的给属性赋值，那么属性经过默认初始化-->显式初始化这样的

步骤。

③相对于成员变量，有局部变量

局部变量：在方法体内部（或在代码块内部或方法的形参部分）定义的

变量。

格式： 数据类型 名字 = 初始化值

初始化值：必须要显式的初始化。系统不会提供默认初始化值。

成员变量和局部变量的区别与联系：

* 相同点：1）变量，在声明的时候，都需要指定数据类型和变量名。

* 2）都有生命周期。

* 不同点：1）声明的位置不同

* 2）在内存中的加载不同：成员变量随着new Person()的加载，

而加载到堆空间中

* 局部变量是加载在栈空间。

* 3）初始化值：成员变量：有默认初始化值，当然也可以显式

的初始化

* 局部变量：除形参部分的局部变量外，必须显式的初始

化

* 4）访问修饰符： 成员变量：需要有访问修饰符.访问权限从大到

小有：public protected 缺省状态 private

* 局部变量：不需要有访问修饰符。实际上它的访问权

限由其所在的方法的权限所反映。

2）方法(method、函数、成员方法)

①格式：（写一个方法，从如下声明的4部分去考虑）

修饰符 返回值类型 方法名(形参1类型 形参1名字,形参2类型 形参2

的名字，。。。。){

//方法体

}

②说明：1.在方法内部，可以调用当前类的属性。（有一个例外：在static

声明的方法里，不能调用非static 的属性。）

2.方法内部，可以声明局部变量

3.方法内部可以调用其他方法，但是不能定义方法。

* 方法的返回值类型： 有返回值的 & 无返回值的

* 有返回值的：在方法声明时，指定返回值的类型。在方法体的里面需要return

+ 返回值类型的“实体”；

* 无返回值的：在方法声明的返回值类型位置写上void.此时不需要返回值，即

无return.

*

* 记忆：void 和 return 像是一对冤家，你出现，我就躲起来不出现。

3.3对象的创建

1. 创建对象的格式：

类名 类名的一个引用 = new 类对应的构造器;

比如：String str = new String("atguigu");

Person p = new Person();

创建类的多个对象，每个对象都在堆空间有独立的一块区域。对a对象的区域进

行的操作，并不影响b对象或其它对象区域的内容。

2.匿名对象的创建

不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。

如：new Person().shout();

使用情况：

如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。

我们经常将匿名对象作为实参传递给一个方法调用。

3.4方法的重载

方法的重载（overload）：

1.满足的条件：“两同一不同” 同一个类中，同一个方法名，参数列表不同（参

数类型，参数个数的不同）

注意： 至于方法的权限修饰符和返回值类型并不影响方法之间是否构成重载

参数名不作为是否构成方法重载的条件。

//返回两个整数的和

int add(int x,int y){return x+y;}

//返回三个整数的和

int add(int x,int y,int z){return x+y+z;}

//返回两个小数的和

double add(double x,double y){return x+y;}

3.5形参的参数传递

swap(int i ,int j)与swap(int[] arr,int i ,int j)的区别

m,n ar 0x1234

Java的实参值如何传入方法呢？

Java里方法的参数传递方式只有一种：值传递。 即将实际参数值的副

本（复制品）传入方法内，

而参数本身不受影响。

1.如果是基本数据类型：就将基本数据类型的值赋给方法的形参部分。

2.如果是引用数据类型：就将引用变量a的地址值赋给方法的形参部分b，这样，

方法的形参部分b和引用的变量a

就指向同一份堆空间的内存区域。

3.6可变形参

* 测试可变个数的形参。

* 1.是指方法的参数部分的指定类型的的参数个数是可变的。

* 2.个数可以从0个开始，到无穷多个

* 3.格式: method(数据类型 ... 数据的引用名){}

* 4.可变参数方法的使用与方法参数部分使用数组是一致的。并且这个两种参数

对应的方法名必须不同。

* 如：method2(String[] str){}与method2(String ... str){}不能同时出现在一个类中。

* 5.定义可变参数方法时，要将可变参数写在参数部分的最后。---->一个方法中，

最多有一个可变个数的形参！！

* 1(String ... str){}方法与method1(String str){}构成重载

public void method1(String str){

n(str);

}

public void method2(String[] str){

for(int i = 0;i < ;i++){

(str[i] + "t");

}

}

public void method1(String ... str){

for(int i = 0;i < ;i++){

(str[i] + "t");

}

}

3.7递归方法

方法递归：一个方法体内调用它自身。

方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须

循环控制。

例题：已知有一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),其中n是大于0的

整数，求f(10)的值。

递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

3.8构造器

1.构造器(constractor)的作用：1）创建类的对象 2）通过构造器的形参赋值，初

始化对象的属性

2.如果声明一个类的构造器

1）构造器与类同名，有修饰符，有形参，没有返回值也无void。

class A{

public A(){

//构造器内部代码

}

}

2）类内部可以声明多个重载的构造器。

3.构造器的说明：

1）Java语言中，每个类都至少有一个构造器

2）默认构造器的修饰符与所属类的修饰符一致

3）一旦显式定义了构造器，则系统不再提供默认构造器

4）一个类可以创建多个重载的构造器

5）父类的构造器不可被子类继承

3.9封装与隐藏

通过设置类的属性为private,使用public 的方法调用和修改类中private的属性。

它是封装和隐藏的一种表现形式。

public class Animal{

private int legs;//将属性legs定义为private，只能被Animal类内部访问

public void setLegs(int i){ //在这里定义方法 eat() 和 move()

if (i != 0 && i != 2 && i != 4){

n("Wrong number of legs!");

return;

}

legs=i;

}

public int getLegs(){

return legs;

}

}

3.10四种权限修饰符

public protected 缺省 private

3.11this

可以用来修饰属性、方法和构造器

1）this修饰属性和方法表示调用当前对象（或正在初始化的对象）的属性和方

法。

public void display(){ //调用display()方法的对象，即为当前对象

= "Lily";

(12);

}

public Person(String name,int age){ //此时this表示：正在初始化的对象

= name;

= age;

}

2）在类内部，构造器内，使用this（参数列表）的形式，调用本类重载的构造

器

要求：1）this（参数列表）一定要写在构造器的首行！

2）在类内部的构造器中，至少有一个构造器内部是没有this(参

数列表)的。

3.12 package & import

package :包。

写在源文件的第一行，声明源文件的“位置”。

package ;

import 引入

如: import r; 表示导入包下的某一个类，即Scanner类

import .*;表示导入包下的所有的类

然后，可以在程序中，直接使用。即: Scanner s = new Scanner();

1)如果需要导入的话，可以省略不写。

2）如果不显式的import的话，也可以。 r s = new

r();

3）像Date这样，既存在于包下，又存在于包下，如果在源程

序中同时出现了两个Date类，那么

只能是使用2）表示的方式。

import static 在JDK1.5引入的。表示导入某个类下的某个静态方法、属性或全部

的静态方法或属性

import static ;

import static .*;

--------------------------------第4章：高级类特性1 -------------------------------

4.1继承

1.继承的想法

2.继承的格式 class A extends B{

}

其中，A叫做子类，叫做父类

１）通过继承，子类Ａ就获得了父类Ｂ的属性和方法。在父类权限修饰符允许

的情况下，子类可以直接调用父类含有的

属性和方法。

２）子类不能继承父类的构造器。但是子类可以通过super（参数列表）的形式

调用父类的构造器

3）java中只能单继承

class C extends B{}

class Dextends A{}

4）在java语言中，所有类的根父类是类。

4.2方法的重写

1.重写的前提：一定要有继承；

2.重写的要求：1）返回值类型、方法名、形参列表（形参个数，形参类型）跟

父类相同

2）访问权限：子类重写方法的访问权限不能小于父类

被重写方法的访问权限

3）关于异常：子类跑出的异常不能大于父类被重写的

方法抛出的异常

4）关于static：重写和被重写的方法，必须同时为static

或者同时为非static修饰的。

【重载（overload）和重写（override）的区别】

1.答出重载与重写对方法声明的要求。

2.重载：在同一个类中。

重写：是在子类中，“重写”的父类的方法。

4.3super关键字

super ：对父类的方法、属性或构造器的引用。

class Person{

String name = "1";

}

class Student extends Person{

String name = "2";

public void display(){

n();

n();

}

public static void main(String[] args){

Student s = new Student();

y();

}

}

super 修饰构造器：在子类的构造器中，可以通过显示的调用super(参数列表）

的形式，调用指定父类的构造器。

如果不显式的调用的话，子类的构造器也会默认去调用父类的super()的构造器！！

4.4子类对象实例化的全过程

class Person{

String name = "1";

}

class Student extends Person{

String name = "2";

public void display(){

n();

n();

}

public static void main(String[] args){

Student s = new Student();

}

}

y();

4.5多态性

中多态的表现形式：

1）方法的重载(overload)和重写(override)。

2）对象的多态性 ——可以直接应用在抽象类和接口上

2.对象的多态性使用的前提：1）有继承关系 2）子类要重写父类的方法

程序分为编译时状态和运行时状态。

class Person{

public void method1(){

//方法体

}

}

class Student extends Person{

public void method1(){

//方法体，重写父类的method1()方法

}

public static void main(String[] args){

Student st = new Student();

Person p = new Student();//对象的多态：即将子类的对象new Student()

赋给父类的引用p。

//虚拟方法调用

1();//执行的是Student类中的重写的method1()方法！

//p....是无法调用Student类特有的属性和方法的！编译不通过。

//但是堆空间的对象中，是含有Student类所特有的属性和方法的！

//如何实现p可以调用Student类所特有的属性和方法呢？造型（或向下

转型、强转）。

//为了保证不报ClassCastException ，需要使用instanceof关键字进行转

型前的判断。

}

}

public class Test{

public void func(Person p){

1();

}

}

4.6Object类

1.只有一个构造器 public Object();每次我们创建任何一个类的对象的时候，都会

调用到Object类的无参的构造器！

2. public boolean equals(Object obj){}

Object类的原码：

public boolean equals(Object obj) {

return (this == obj);

}

2.1）对于JDK提供的String、包装类、Date等，已经重写了Object类的equals()

方法。

如：String类重写的equals(Object object)方法如下：

public boolean equals(Object anObject) {

if (this == anObject) {

return true;

}

if (anObject instanceof String) {

String anotherString = (String) anObject;

int n = ;

if (n == ) {

char v1[] = value;

char v2[] = ;

int i = 0;

while (n-- != 0) {

if (v1[i] != v2[i])

return false;

i++;

}

return true;

}

}

return false;

}

2.2）自定义类的话，如果需要使用equals方法，那么就必须重写Object类的

equals();

//自定义类重写了Object类的equals()方法

public boolean equals(Object obj) {

if (this == obj)//引用地址是一样的，指向同一块堆空间的区域

return true;

if (obj instanceof Person) {

Person p = (Person) obj;

return (() && == );

}

return false;

}

String toString(){

}

Object类的源码：

public String toString() {

return getClass().getName() + "@" + tring(hashCode());

}

n(p); 相当于 n(ng());

3.1)对于JDK提供的String、包装类、Date等，已经重写了Object类的equals()

方法。

3.2)自定义类的话，如果需要使用toString()方法，那么就必须重写Object类的

toString();

//自定义类重写了Object类的toString()方法

public String toString() {

return "Person [name=" + name + ", age=" + age + "]";

}

4.7包装类

//对于基本数据类型和对应的包装类来说，有自动装箱和拆箱

Integer i = 23;//自动装箱

Integer j1 = new Integer(34);

Integer j2 = new Integer("34");

Boolean b = new Boolean("true");

int j = j1;

int j3 = j2;//自动拆箱

j1 = null;

boolean boo = b;

n(boo);//false 注意：不会报异常！

String str = "123";

//将String类型转化成基本数据类型(或包装类) :使用Xxx包装类的

parseXxx(String str)方法

int k = nt(str);

n(k);

//基本数据类型(或包装类)转成String类

String str1 = f(boo);

n(str1);

String str2 = boo + "";

String str3 = ng(boo);

n(str3);

String str4 = ng();

--------------------------------第5章：高级类特性2 -------------------------------

5.1static关键字

:静态的 实现功能：随着类的加载而加载，要早于对象的出现

可以用来修饰：属性 、 方法、代码块、内部类

修饰属性（类属性）

1）随着类的加载而加载，而类的消亡而消亡

2）先于对象创建

3）可以直接用类来调用

4）在内存中存在于数据区，只有一份。不同的对象共同使用同一份static的

属性

5）当一个对象对static的属性进行修改，会导致其他对象调用此属性时，是

修改过的属性。

修饰方法：

1）随着类的加载而加载，而类的消亡而消亡

2）先于对象创建

3）可以直接用类来调用

4）在内存中存在于数据区，只有一份。不同的对象共同使用同一份static的

属性

5） 在static的方法内，只能调用static的属性或方法。

5.用static修饰属性或方法的利弊

利：可以直接通过类来调用，不用创建对象

弊：生命周期长，占用内存。

5.2单例模式

单例模式：要求类只能创建一个对象。

懒汉式 & 饿汉式（存在线程安全问题）

5.3main方法

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

5.4代码块（或初始化块）

代码块（初始化块）: 用来初始化对象。

1. 静态代码块 和 非静态代码块

*静态代码块：

* 1.代码块内可以有多条语句：输出语句，赋值语句（只能对static的属性赋值）

* 2.随着类的加载而加载

* 3.静态的代码块只被加载一次

* 4.静态代码块的执行要先于非静态的代码块

* 5.只能调用静态的变量或方法

*

* 非静态的代码块：

* 1.代码块内可以有多条语句：输出语句，赋值语句（对static的或非static的

属性赋值）

* 2.随着对象的创建才被加载

* 3.每次创建一个对象，非静态代码块都会被执行

* 4.非静态的代码块执行的先后顺序按程序中其出现的先后顺序来执行。

* 5.可以调用静态或非静态的属性和方法。

重难点：创建一个对象，那个对象实例化的全过程。

1）子类和父类的问题

2）子类来说，属性的默认/显式初始化，代码块（静态/非静态），构造器。。。

经典的代码：

class Root{

}

class Mid extends Root{

static{

}

{

}

public Mid(){

}

public Mid(String msg){

//通过this调用同一类中重载的构造器

this();

n("Mid的无参数的构造器");

n("Mid的普通初始化块");

n("Mid的静态初始化块");

static{

}

{

}

public Root(){

}

n("Root的无参数的构造器");

n("Root的普通初始化块");

n("Root的静态初始化块");

}

}

n("Mid的带参数构造器，其参数值："

+ msg);

class Leaf extends Mid{

}

public class TestLeaf{

}

public static void main(String[] args){

}

new Leaf();

new Leaf();

static{

}

{

}

n("Leaf的普通初始化块");

n("Leaf的静态初始化块");

public Leaf(){

}

//通过super调用父类中有一个字符串参数的构造器

super("atguigu");

n("执行Leaf的构造器");

5.5final关键字

* final:表示：最终的，可以用来修饰类、属性、方法

* 1.修饰类：修饰的类不能被继承。

*

* 2.修饰方法：这个方法不能被重写

*

* 3.修饰属性：这个属性值，不能被修改。即，此变量是一个常量。

* “哪里”可以为final的属性赋值：1.声明的时候 2.在代码块内部 3.构造

器中

*

* static final 修饰变量 ：全局常量。

5.6抽象类

abstract:抽象的，可以用来修饰类，修饰方法。

1.使用抽象类的前提：在类可以继承的基础上。

2.抽象类：abstract class 类名{} 表明此类不能被实例化。

2.1抽象类内部可以有构造器！

2.2抽象类内部不一定有抽象方法。

如：abstract class Person{

abstract void walk();

abstract void eat();

}

class Test{

public static void main(String[] args){

}

Person p = new Person();//不能被实例化

Person p1 = new Person(){

void walk(){

}

void eat(){

}

//方法体

//方法体

};

2.抽象方法：用abstract声明，同时，方法没有方法体！

如：public abstract void walk();

2.1抽象方法所属的类一定是抽象类。

2.2抽象方法只有被重写才有意义。（需要子类继承抽象类，然后重写抽

象方法）

3. abstract不能跟哪些关键字同时使用：final static private 构造器

4.设计模式：模板设计模式

5.7接口

接口：彻底的抽象类 ,不可以被实例化

声明： interface MyInterface{

//属性(全局常量)

public static final double PI =3.14；

int E = 2;

//方法（全部是抽象方法）

public abstract int getId();

void display();

}

1.格式： （abstract）class MyClass extends Object implements

MyInterface,Comparable{//可以实现多个接口

}

//重写（所有的/部分的）抽象方法

2.一个类可以实现多个接口。

3.类需要重写接口中的所有的抽象方法，方可实例化。如果不的话，那么此类仍

未抽象类

4.接口与接口间是可以继承的，而且可以多继承

5.设计模式：工厂设计模式、代理模式

5.8内部类

1.内部的分类：成员内部类（静态的/非静态的） & 局部内部类

class Person{

String name = "Tom";

}

class Bird{

}

static clas Dog{

}

String name = "小鸟";

//4的举例放在此处

2.成员内部类来说： 1）创建非静态内部类的实例：1.1创建外部类的实例 1.2

通过外部类的对象调用内部类的构造器

//1.

Person p = new Person();

//2.

b = Bird();

2）创建静态内部类的实例:直接通过外部类的类名来调用内部

类的构造器。

d = new ();

3.内部类作为类的一类成员，可以调用外部类的属性和方法。

注意：如果内部类是static的，那么只能调用外部类的static的属性和方法。

4.在内部类中调用的问题（尤其是当外部类的属性、内部类的属性、内部类的局

部变量名都相同）

举例：

public void display(String name){

}

5.局部内部类：在方法里面定义的类。

n(name);//黄鹂

n();//小鸟

n();//Tom

//与上面定义的get()方法是一样的。

6.匿名内部类

public Comparable get1(){

}

class MyComparable implements Comparable{

}

return new MyComparable();

public int compareTo(Object obj){

}

retrun 0;

5.9面向对象总结

1.面向对象“三条主线”

----->关注与类的创建

1.1 考虑类内部都可以有什么？

属性 方法 构造器 代码块 内部类

1.2 面向对象的特征是什么?

封装和隐藏(四个权限修饰符) 继承extends 多态

1.3 其他（几个重要的关键字、杂项）

几个重要的关键字：this super static final abstract interface package

import

杂项：Object类 包装类（包装类、基本数据类型、String间的转化） main

函数 可变形参 方法的参数传递（难点）

关键点：子类对象实例化的全过程（类的内部哪些部分可以给属性赋值，以及先

后顺序；子父类间的调用）

--------------------------------第6章：异常处理 -------------------------------

ion ： RuntimeException(运行时异常)和CheckedException(编译时异常）

1.1运行时异常：可以不显式的进行处理。如果出现异常，会将异常的

信息显式在控制台上。

几类常见的运行时异常：（4种）

1.2编译时异常：编译就不通过。必须要求程序员进行显式的处理！将编译

时异常转化为运行时异常。

2.如何处理异常（处理异常的方式）

2.1 try-catch

try{

//有可能出现异常的代码

} catch(Exception1 e1){

//如何处理的代码；

}catch(Exception1 e2){

}finally{

//一定会被执行的代码

}

说明：

1）try 中存放的是可能有异常的代码。如果try代码中发生异常，那么异

常代码之后的代码不会被执行。

try当中声明的变量，在出了try代码块后，将无效

2）catch语句将异常类型小的放在异常类型大的上面。

在{}中给出异常的处理意见: tackTrace() sysout(sage);

3)finally:不管是否发生异常，都会被执行：try中是否有异常；catch中是否

有异常；catch中是否有return

4)catch 和 finally是可选。

5)异常可以嵌套

2.2 throws :如果在方法中抛出了异常，但方法不知道如何处理，那么就通

过throws的形式，将异常往上抛,交给方法的调用者来处理。

举例： public void method() throws Exception{

//存在异常

}

3.异常，既可以是JDK提供给我们的异常类，也可以是我们自己定义的异常类。

3.1.1如果是JDK提供给我们的话，那么当出现异常的时候，程序会自动生

成一个对应异常类的对象，然后抛出此对象。

3.1.2如果是自定义的异常，需要在程序中显式的将这个异常对象抛出。如

何抛出？使用throw关键字

3.2 throw关键字：定义在方法内部，通过“throw 自定义异常类的对象”格

式，抛给方法。

3.3如何自定义异常类？①自定义异常类继承现有的异常类（一般情况下，

继承RuntimeException）②写几个重载的构造器

【典型例题】

class EcDef extends RuntimeException{

}

public class EcmDef {

public static void main(String[] args) {

try{

int i = nt(args[0]);

int j = nt(args[1]);

ecm(i,j);

static final long serialVersionUID = 9L;

public EcDef(String name){

}

super(name);

③static final long serialVersionUID = 948L;

}

}

}catch(NumberFormatException e){

n("数据类型转化的异常");

}catch(ArrayIndexOutOfBoundsException e){

n("数组下标越界的异常");

}catch(ArithmeticException e){

n("算术异常：/ by zero");

}catch(EcDef e){

n(sage());

}finally{

}

n("程序执行完毕！");

public static void ecm(int m,int n) throws RuntimeException{

}

if(m < 0 || n < 0){

throw new EcDef("不能输入负数！");

}else

n("两数相除的结果为：" + m/n);

--------------------------------第7章：Java集合 -------------------------------

1. 主要有Collection和Map接口 （体系里的实线表示extends关系，虚线表

示implements关系）

以及

7.1Connection接口的常用方法

7.2迭代器Iterator的使用：

1.用于实现集合（Set、List、Map）元素的遍历

2.通过集合类的iterator()方法返回一个Iterator实现类的对象，用来遍历调用

iterator()方法的集合的元素

3.步骤：

Colleciton coll = new HashSet();

()......//添加诸多个元素

Iterator iterator = or();

while(t()){

n(());

}

7.3 Connection的子接口：Set

1.存储的元素是无序的、不可重复的！类似于高中概念中的集合。

2.主要实现类：HashSet LinkedHashSet TreeSet

t 是Set的主要实现类 （可以添加null值，线程不安全的）

3.1 在不使用泛型的时候，创建HashSet可以用来存储任何数据类型的数据，

即add(Object obj);

3.2如何判断添加元素的不可重复性？（重点、难点）

标准：1.如果添加的JDK提供给我们的类的对象，会自动判断是否重

复

2.如果是添加自定义类的对象，自定义类一定要重写

equals()和hashCode()

注：当两个对象的 equals() 方法比较返回 true 时，这两个对象的

hashCode() 方法的返回值也应相等

4.添加元素的时候如何使用hashCode 和equals()方法的？

4.1 先调用hashCode方法获取对象的hash值。如果hash值跟之前的对

象值都不同，直接存储

4.2 如果hash值与之前的某个对象相同，那么再通过equals()方法进行

比较。如果equals返回true，添加不成功。返回false，添加成功

HashSet ①遍历时，是按照添加元素的顺序实现的。②是可以添加任何

数据类型的。③遍历时，效率比较高

t 存入的元素需要排序，遍历时，按照指定的顺序遍历。

关键点：TreeSet中只能添加相同类型的数据。

6.1 自然排序

1.对于自定义类，此类要实现Comparable接口，重写此接口的

CompareTo（Object obj）方法

2.创建TreeSet对象，使用add()方法添加元素即可

注意点：当需要把一个对象放入 TreeSet 中，重写该对象对应的 equals() 方法

时，应保证该方法与 compareTo(Object obj) 方法有

一致的结果：如果两个对象通过 equals() 方法比较返回 true，则通过

compareTo(Object obj) 方法比较应返回 0

6.2 定制排序

1.创建一个实现Comparator接口的匿名对象

2.将此对象作为形参传递给TreeSet的构造器形参部分

3.创建TreeSet对象，使用add()方法添加元素即可

注意点：此时添加对象如果是自定义的，无需再实现Comparable接口

7.4Connection的子接口：List

1.存储的数据是可重复的，是有序的。相当于可变长度的数组

2.实现类： ArrayList LinkedList（实现添加、删除、修改，效率高） Vector

（线程安全，但是是个古老的实现类，现在不常用了）

3.典型实现类 ： ArrayList （线程不安全的）

List list = new ArrayList();

4.常用的三个方法： ① add(Object obj) ② Object get(int index) ③ int

size()

5.使用Interator迭代器实现遍历

7.5Map接口及常用方法

1.存储的数据是以键值对（key-value）的形式存在的。类似于高中的函数

2.实现类： HashMap LinkedHashMap TreeMap Hashtable(古老类，将其子

类：Properties）

p 是Map接口的主要实现类 Map map = new HashMap();

4.常用方法： (key,value);添加一个元素

();获取键值对的个数

(key):获取指定key的value值

实现类的遍历（重点、难点）

Set keySet()

Collection values()

Set entrySet()

5.1遍历key集

Set set = ();

for(Object obj : set){

n(obj);

}

5.2遍历value集

Collection coll = ();

Iterator i = or();

while(t()){

n(());

}

5.3遍历key-value对集

（法一）

Set set1 = ();

for(Object obj : set1){

n(obj + "----->" + (obj));

}

（法二）

Set set2 = et();

for(Object obj : set2){

entry = ()obj;

n(() + ":" + ue());

}

HashMap：按添加的顺序实现遍历

p : 遍历时，按照添加元素时指定的顺序实现遍历。

要求，key是一个Set集合。要求key必须实现自然排序或

者是定制排序

ties: 常用来操作属性文件 。key和value都是String型的

7.6Collections工具类

集合的工具类

可以用来操作：Set List Map

1.对于集合元素的一般方法： reverse(list) sort(list) ..

2.保证线程安全的同步方法： synchronizedXxx()

ArrayList list = new ArrayList();

list = onizecList(list);

--------------------------------第8章：泛型 -------------------------------

泛型 ： JDK1.5新加入的特性

使用：1.在集合中使用泛型

（在集合中使用泛型的声明和初始化）

Collection coll = new ArrayList();

Collection