使用Java实现面向对象编程

第1章             对象和封装

1.创建类和对象：

Ø  类和对象的概念：类（class）和对象（object）是面向对象的两个核心概念。类是对某一类事物的描述，是抽象的，概念上的定义。对象是实际存在的，具体的事物个体。

Ø  类名，属性名，方法名及常量名的命名规范：

l  类名有一个或几个单词组成，每个单词的第一个字母大写。

l  属性名和方法名由一个或几个单词组成，第一个单词首字母小写，其他单词首字母大写。

l  常量名由一个或几个单词组成，所有字母大写。

二、使用面向对象进行设计

面向对象设计的过程就是抽象的过程，分三步来完成：

1.找出它的种类

2.找出它的属性

3.找出它的行为

三、类名、属性名、方法名以及常量名的命名规则：

1.类名由一个或几个单词组成，每个单词的第一个字母大写，如Dog、StringBuffer

2.属性名和方法名由一个或几个单词组成，第一个单词首字母小写，其他单词首字母大写，例如health,stuName,println(),getMessage()。

3.常量名由一个或几个单词组成，所有字母大写，如PI，SEX_MALE

四、静态常量

1.static可以用来修饰属性、方法和代码块

2.static修饰的属性和方法称为类属性（类变量）、类方法

3.不使用static修饰的属性和方法，属于单个对象，通常称为实例属性（实例变量）、实例方法

4.static修饰的变量和方法可以通过类名和对象名访问，而不用static修饰的变量和方法只能通过对象名访问

static、非private修饰	非static、private修饰
属性	类属性、类变量	实例属性、实例变量
方法	类方法	实例方法
调用方式	类名.属性 类名.方法() 对象.属性 对象.方法()	对象.属性 对象.方法()
归属	类	单个对象

 

5.final可以用来修饰属性、方法和类

6.用final修饰的变量成为常量，其值固定不变

五.构造方法及其重载：

Ø  构造方法的名称和类名相同，没有返回值。构造方法的主要作用就是在创建对象时执行一些初始化操作，如给成员属性赋值。

Ø  如果同一个类中包含了两个或两个以上的方法，它们的方法名相同，方法参数的个数或参数类型不同，则称该方法被重载了，这个过程成为方法重载。

Ø  方法重载的判断依据：

u  必须在同一个类里。

u  方法名相同。

u  参数列表（方法参数的个数或参数类型）不同。

u  与方法返回值和方法修饰符没有任何关系。

Ø  在使用this调用自身的其他构造方法时，只能作为第一条语句。

 

六.封装：

Ø  封装是面向对象的三大特征之一，就是将类的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法来实现对隐藏信息的操作和访问。

Ø  封装的具体步骤：修改属性的可见性来限制对属性的访问；为每个属性创建一对赋值（setter）方法和取值（getter）方法，用于对这些属性的存取，在赋值方法中，加入对属性的存取控制语句。

Ø  封装的好处：隐藏类的实现细节；让使用者只能通过程序规定的方法来访问数据；可以方便的加入存取控制语句，限制不合理操作。

七、This的使用

因为this是在对象内部指代自身的引用，所以this只能调用实例变量、实例方法和构造方法

this不能调用类变量和类方法。

this也不能调用局部变量。

八．访问修饰符

1.private：成员变量和方法只能在其定义类被访问，具有类的可见性

2.默认：成员变量和方法只能被同一个类访问，具有类的可见性

3.protected:可以被同一个包中的类访问，被同一项目中的子类访问（父类，子类）

4.public：可以被同一个项目中的所有类访问，具有项目可见性，这是最大的访问权限

 

第二章 继承

一、使用继承

1.编写父类

 Class Pet {

   //公共的属性和方法

}

2.编写子类，继承父类

  Class Dog extends Pet {

    //子类特有的属性和方法

  }

Class Penguin extends Pet {

}

继承：

Ø  通过extends关键字来实现。

Ø  继承是面向对象的三大特征之一，是Java中实现代码重用的重要手段之一。Java中只支持单继承，即每个类只能有一个父类。继承表达的是 is a 的关系，或者说是一种特殊和一般的关系。

Ø  Java中，子类可以从父类继承到哪些东西：

n  继承public和protected修饰的属性和方法，无论子类和父类是否在同一个包里。

n  继承默认权限修饰符修饰的属性和方法，但子类和父类必须在同一个包里。

n  无法继承private修饰的属性和方法。

n  无法继承父类的构造方法。

二、理解继承

1.重写父类方法：

Ø  子类对父类继承的方法进行重新编写，称为方法的重写或方法的覆盖。方法重写必须满足如下要求：

u  重写方法和被重写方法必须具有相同的方法名。

u  重写方法和被重写方法必须具有相同的参数列表。

u  重写方法的返回值类型必须和被重写方法的返回值类型相同或是其子类。

u  重写方法不能缩小被重写方法的访问权限。

Ø  super代表对当前对象的直接父类对象的默认引用。在子类中可以通过super关键字来访问父类的成员。

u  super必须出现在子类（子类的方法和构造方法）中，而不是其他位置。

u  可以访问父类的成员，如父类的属性，方法，构造方法。

 

位置	方法名	参数表	返回值	访问修饰符
方法重写	子类	相同	相同	相同或是其子类	不能比父类更严格
方法重载	同类	相同	不相同	无关	无关

 

访问修饰符	本类	包	子类	其他
private	√
默认(friendly)	√	√
protected	√	√	√
public	√	√	√	√

 

 

 

2.继承关系中的构造方法：

Ø  继承条件下的构造方法的调用规则如下：

u  如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，有没有“super();”语句，效果是一样的

u  如果子类的构造方法中通过super显示调用父类的有参构造方法，则将执行父类相应的构造方法，而不执行父类无参构造方法。

u  如果子类的构造方法中通过this显示调用自身的其他构造方法，则在相应的构造方法中应用以上两条规定。

u  特别注意的是，如果存在多级继承关系，则在创建一个子类对象时，以上规则会多次向更高一级父类应用，一直到执行顶级父类Object类的无参构造方法为止。

3.有些父类成员不能继承

 1）private成员

 2）子类与父类不在同包，使用默认访问权限的成员

 3）构造方法

4.Java中，继承(Inheritance)通过extends关键字来实现，其中SubClass称为子类，SuperClass称为父类、基类或超类。

5.在子类中可以根据需求对从父类继承的方法进行重新编写，称为方法的重写或方法的覆盖。

6.构造方法不能被继承因此不能被重写。

7.抽象类和抽象方法：

Ø  抽象类和抽象方法的特点：

u  抽象类和抽象方法都通过abstract关键字来修饰。

u  抽象类不能实例化。抽象类中可以没有，有一个或多个抽象方法，甚至全部方法都可以是抽象方法。

u  抽象方法只有方法声明，没有方法实现。有抽象方法的类必须声明为抽象类。子类必须重写所有的抽象方法才能实例化，否则子类还是一个抽象类

8.final修饰符

Ø  用final修饰的类，不能再被继承。

Ø  用final修饰的方法不能被子类重写。

Ø  用final修饰的变量（包括成员变量和局部变量）将变成常量，只能赋值一次。

9.abstract:

>不能和private同时修饰一个方法

>不能和static同时修饰一个方法

>不能和final同时修饰一个方法或类

第三章多态

1.多态的概念:多态(polymorphism)是具有表现多种形态的能力的特征.更专业话的说法:同一个实现接口,使用不同的实例而执行不同的操作.

2.子类到父类的转换(向上转型):

Ø  将一个父类的引用指向一个子类对象,成为向上转型,自动进行类型转换.

Ø  此时通过父类引用变量调用的方法是子类覆盖或继承父类的方法,不是父类的方法.

Ø  此时通过父类引用变量无法调用子类特有的方法.

3.使用父类作为方法形参实现多态

      优势:使用父类作为方法形参优势明显,或者说使用多态的优势明显:可以减少代码量,提高代码的可扩展性和可维护性.

总结:实现多态的三个条件:

Ø  继承的存在(继承是多态的基础,没有继承就没有多态).

Ø  子类重写父类的方法(多态下调用子类重写后的方法).

Ø  父类引用变量指向子类的对象(子类到父类的类型转换)

4.实现多态的两种形式:

n  使用父类作为方法形参实现多天

n  使用父类作为方法返回值实现多态

5.父类到子类的转换(向下转型)

      概念:将一个指向子类对象的父类引用赋给一个子类的引用,称为向下转型,此时必须进行强制类型转换.

6.instanceof运算符

Ø  语法:  对象  instanceof  累或接口

Ø  该运算符用来判断一个对象是否属于一个类或者实现了一个接口,结果为true或false.

Ø  在进行引用类型转换时,先通过instanceof运算符进行类型判断,再进行相应的强制类型转换,这样可以有效的避免出现类型转换异常.

第四章 接口

一．接口的基础知识

1.接口利于代码的扩展和维护

  语法：[修饰符] interface 接口名 extends 父接口1，父接口2…{

                    //常量定义

                    //方法定义

         }

  语法：class 类名 extends 父类名 implements 接口1，接口2，…{

                     //类成员

}

2.说明：>接口名的命名规则与类相同。如果修饰符的public，则该接口在整个项目中可见；如果省略修饰符，则该接口只在当前包可见

>接口中可以定义常量，不能定义变量，接口中的属性都会自动用public static final修饰，即接口的属性都是全局静态常量。接口中的常量必须在定义时指定初始值

>接口中所有方法都是抽象方法。接口中方法都会自动用public abstract修饰，即接口中只有全局抽象方法

>和抽象类一样，接口也不能实例化，接口中不能有构造方法

>接口之间可以通过extends实现继承关系，一个接口可以继承多个接口，但接口不能继承类

>接口的实现类必须实现接口的全部方法，否则必须定义为抽象类

3.一个类只能有一个直接父类，但可以通过implements实现多个接口。当类在继承父类的同时又实现了多个接口时，extends关键字必须位于implements关键字之前

三．接口表示一种能力

四．接口表示一种约定

接口体现了约定和实现相分离的原则，通过面向对象接口编程，可以降低代码之间的耦合性，提高代码的可扩展性，和可维护性。面向接口编程就意味着：可发系统时，主体构架使用接口构成系统的骨架，这样就可以通过更换实现接口的类来实现更换系统

五．在C#中使用接口

1.使用C#实现打印机打印功能

  语法：[修饰符] interface 接口名 : 父接口1,父接口2, …… {

属性定义

方法定义

}

  语法：class 类名 :父类名,接口1,接口2, …… {

              类成员

}

2.>接口之间可以通过冒号来实现继承关系，一个接口可以继承多个接口，但接口不能继承类。类只能继承一个父类，但可以实现多个接口，使用冒号来继承并实现接口

>接口定义零个或多个成员，成员主要是方法属性和 索引器。接口中不能包含常量或构造方法，也不能包含任何静态成员

>接口中成员访问权限是public；定义接口时显式指定任何修饰符都是非法的

>按照惯例，C#中接口的名称以大写字母“I”开头

六．Java与C#中接口区别

>Java中接口通过extends来继承父类接口，类通过implements来实现接口；

C#中通过冒号“：”来实现这个功能

>Java中接口的成员变量（属性）都是常量，自动用publicstatic final 修饰；

C#接口中不允许存在成员变量，但可以有属性

>Java接口中属性和方法都可以使用public修饰；

C#中默认为public，但不允许显式使用public修饰

>Java接口中可以定义静态常量和方法

C#接口中不允许包含任何静态成员

Java接口	C#接口
定义	interface	interface
实现	implements	:
静态成员	常量	无
public	可以显示使用	不能显示使用

 

第五章 异常

一．单词

二．异常概述

1.if-else语句进行异常处理的机制主要有以下缺点：

>代码臃肿，加入了大量的异常情况判断和处理代码

>程序员把相当多的精力放在了处理异常代码上，放在了“堵漏洞”上，减少了编写业务代码的时间，必然影响开发效率

>很难穷举所有的异常情况，程序员仍旧不健壮

>异常处理代码和业务代码交织在一起，影响代码的可读性，加大日后程序的维护难度

三．异常处理

1.try-catch代码（3种）

 ●try块中所有语句正常执行完，不发生异常，那catch块中的所有语句都将会被忽略

 ●try语句中在执行中遇到异常，并且这个异常与catch中声明的异常类型相匹配，那try块中其余剩余的代码都将被忽略，并且相应的catch块将会被执行。匹配是指catch所处理的异常类型与所生成的异常类型完全一致或是它的父类

 ●try语句块在执行过程中遇到异常，而抛出的异常在catch块里面没有被声明，那么程序立即退出

a.被调用异常对象的方法输出异常信息：常见2种

           ○void printStackTrace():输出异常的堆栈信息

○String getMessage():返回异常信息描述字符串，该字符串描述异常，产生的原因是printStackTrace()中的信息一部分

异常类型	说明
Exception	异常层次结构的父类
ArithmeticException	算术错误情形，如以零作除数
ArrayIndexOutOfBoundsException	数组下标越界
NullPointerException	尝试访问null 对象成员
ClassNotFoundException	不能加载所需的类
InputMismatchExceptiom	欲得到的数据类型与实际输入类型不匹配
IllegalArgumentException	方法接收到非法参数
ClassCastException	对象强制类型转换出错
NumberFormatException	数字格式转换异常，如把"abc"转换成数字

2.try-catch-finally块（2种）

 ●如果try块中所有语句正常执行完毕，那finally块就会被执行

 ●如果try语句块在执行过程中碰到异常，无论这种异常能否被catch块捕获到，都将执行finally块中的代码

3.多重catch块

    在使用多重catch块时，catch块的排列顺序必须是从。子类到父类，最后一个一般都是Exception类

4.异常声明——throws:可同时声明多个异常之间用逗号隔开

四．抛出异常

1.抛出异常——throw:由于在当前环境中无法解决参数问题，因此在方法内通过throw抛出异常，把问题交给调用者去解决

 throw和throws区别:

>作用不同：throw用于程序中抛出异常；

                throws用于声明在该方法内抛出异常

>使用位置不同：throw位于方法体内部，可以作为单独语句使用;

throws必须跟在方法参数的后面，不能单独使用

>内容不同：throw抛出异常对象，并且只能一个；

            throws后面跟着异常类，并且可以跟多个异常类

2.异常分类：五种

 ●Throwable类：所有异常类型都是Throwable类的子类，它派生两个子类，即Error与Exception

 ●Error类：表示仅靠程序本身无法恢复的严重错误

 ●Exception类：由于java应用程序抛出和处理的非严重错误

 ●运行时异常：包括RuntimeExcetion及其所有子类，不要求程序必须对它们做出处理

 ●checked异常（非运行时错误）：除了运行时异常外其他由Exception继承来的异常类。程序必须捕获或者声明抛出这种异常，否则会出现编译错误，无法通过编译，处理方法包括两种：

>try-catch在当前位置捕获并处理异常

>通过throws声明抛出异常，交给上一级调用方法来处理

五．开源日志记录工具log4j

1.MyEclipse中使用log4j所使用的JAR文件

●在项目中加入log4j所使用的JAR文件

  ●创建log4j.properties文件

  ●编写log4j.properties文件，配置日志信息

  ●在程序中使用log4j记录日志信息

2.日志及分类

  ●日志主要用于记录系统运行过程中的一些重要的操作信息，便于监视系统运行情况，帮助用户提前发现和避开可能出现的问题，或者出现问题后根据日志找到发现的原因

  ●日志根据内容的不同：3类

>SQL日志 ：记录系统执行的SQL语句

>异常日志：记录系统运行中发生的异常事件

>业务日志：记录系统运行过程，如用户登录，操作记录

  ●log4j,可以控制日志的输出级别，以及日志信息输送的目的地（如控制台，文件等），还可以控制每一条日志的输出格式

  ●log4j是Apache的一个开源项目

     官网：http：//logging.apache.org/log4j

     下载：http: //logging.apache.org/log4j/1.2/download.html

>log4j的JAR包：apache-log4j-1.2.17\log4j-1.2.17.jar

>使用手册（manual）：apache-log4j-1.2.17\site\manual.html

>JavaDoc（AplDocs）:apache-log4j-1.2.17\site\apidocs\index.html

  ●Logger对象是用来替代System.out或者System.err的日志记录器，供程序员输出日志信息，它提供了一系列方法来输出不同级别的日志文件

>public voiddebug(Object msg)

>public voiddebug(Object msg,Throwablet)

>publicvoid info(Object msg)         

>publicvoid info(Object msg,Throwablet) 

>publicvoid warm(Object msg)         

>publicvoid warm (Object msg,Throwablet) 

>publicvoid error(Object msg)         

>publicvoid error (Object msg,Throwablet) 

>publicvoid fatal(Object msg)         

>publicvoid fatal (Object msg,Throwablet) 

3.log4j配置文件

  ●输出级别

         log4j.rootLogger=debug,stdout,logfile

          其中，debug指的是日志记录器（Logger）的输出级别，主要输出级别及含义如下

>fatal:指出严重的错误事件将会导致应用程序的退出

>error:指出虽然发生错误时间爱你，但仍然不影响系统的继续 运行

>warm:表明会出现潜在错误的情形

>info:在粗粒度信息事件，对调试应用程序是非常有帮助的

              各级别优先级

Fatal>error>warm>info>debug

                 日志记录器将只输出那些级别高于或等于它的信息

  ●日志输出目的地Appender

Log4j.rootLogger=debug,stdout,logfile

        其中，stdout、logfile指的是日志输出目的地的名字

         log4j允许记录器日志到多个输出目的地，一个输出目的地被称为一个Appender，log4j中最常用的Appender有以下两种

>ConsoleAppender:输出日志事件到控制台。通过Target属性配置输出到System.out或System.err,默认的目标是System.out

>FileAppender:输出日志事件到一个文件。

                      通过File属性配置文件的路径及名称

  ●日志布局类型Layout

         Appender必须使用一个与之相关关联的布局类型Layout，用来指定它的输出格式。Log4g中最常见的layout有以下三种：

>HTMLLayout:格式化日志输出为HTML表格

>SimpleLayout:以一种非常简单的方式化日志输出它输出级别Level，然后跟着一个破折号“—”最后是日志消息

>PatternLayout:根据指定的转换模式格式化日志输出，从而支持丰富多样的输出格式，需要配置layout.ConversionPattern属性，若没有配置该属性，则使用默认的转换模式

  ●转换模式ConversionPattern

        对于PatternLayout，需要配置layout.ConversionPattern属性，常用的配置参数含义如下：

>%d:用来设置输出日志的日期和时间，默认格式为lSO8601。也可以在其后指定格式

>%m:用来输出代码中指定的消息

>%n:用来输出一个回车换行符

>%l:用来输出日志事件的发生位置，包括类名、发生的线程，以及在代码中的行数

>%P:用来输出优先级，即debug.info等

>%F:用来输出文件名

第6章 集合框架

一．单词

二．集合框架概述java.util

1．Java集合框架是为表示和操作集合而规定的一种统一的标准体系结构

2.集合框架都包含三大块内容：对外的接口、接口的实现和对集合运算的算称

>接口：表示集合的抽象数据基础

>实现：集合框架中接口的具体实现

>算法：在一个实现了某个集合框架中的接口的对象身上完成某种有用的计算的方法，如：查找、排序等

3.Java集合框架中的两大类接口：Collection和Map。共同都是集合接口，都可以用来储存很多对象

>Collection接口存储一组不唯一（允许重复）、无序的对象

>Set接口继承Collection接口，储存一组唯一（不允许重复）、无序的对象

>List接口继承Collection接口，存储一组不唯一（允许重复）、有序(以元素插入的次序来放置元素，不会重新排序的对象)

>Map接口存储一组成对的键—值对象，提供Key(键)到Value（值）的映射。Map中的Key不要求有序，不允许重复。Value同样不要求有序，但允许重复。

>Iterator接口是负责定义访问和遍历元素的接口

三．List接口

1.实现List接口的常用类：ArrayList和LinkedList

都容纳所有类型的对象，包括null、允许重复，并且都保证元素的存储顺序

>ArrayList对象数组进行了封装，实现长度的数组

>LinkedList采用链表存储方式，优点在于插入删除元素时效率比较高，提供了额外的addFirst()、addLast()、removeFirst()和removeLast()等方法，可以在LinkedList的首部和尾部进行插入或删除操作，这些方法使得LinkedList可被用作堆栈或者队列

2.ArrayList集合类

 List接口中定义的各种常用方法

 

方法名	说    明
boolean add(Object o)	在列表的末尾顺序添加元素，起始索引位置从0开始
void add(int index,Object o)	在指定的索引位置添加元素。索引位置必须介于0和列表中元素个数之间
int size()	返回列表中的元素个数
Object get(int index)	返回指定索引位置处的元素。取出的元素是Object类型，使用前需要进行强制类型转换
boolean contains(Object o)	判断列表中是否存在指定元素
boolean remove(Object o)	从列表中删除元素
Objectremove(int index)	从列表中删除指定位置元素， 起始索引位置从0开始

3.LinkedList集合类

LinkedList的一些特殊方法

方法名	说    明
void  addFirst(Object o)	在列表的首部添加元素
void  addLast(Object o)	在列表的末尾添加元素
Object  getFirst()	返回列表中的第一个元素
Object  getLast()	返回列表中的最后一个元素
Object  removeFirst()	删除并返回列表中的第一个元素
Object  removeLast()	删除并返回列表中的最后一个元素

四．Map接口

1.HashMap集合类

Map接口定义的常用方法（同时是HashMap）

方法名	说    明
Object put(Object key, Object val)	以“键-值对”的方式进行存储
Object get (Object key)	根据键返回相关联的值，如果不存在指定的键，返回null
Object remove (Object key)	删除由指定的键映射的“键-值对”
int size()	返回元素个数
Set keySet ()	返回键的集合
Collection values ()	返回值的集合
boolean containsKey (Object key)	如果存在由指定的键映射的“键-值对”，返回true
boolean isEmpty()	若不存在键-值映射关系，则返回true
voidclear()	从此映射中移除所有映射关系

五．迭代器Iterator

1.所有集合接口和类都没有提供相应的遍历方法，而是把遍历交给迭代器Iterator完成，Iterator为集合而生，专门实现集合的遍历。它隐藏了各种集合实现类的内部细节，提供了遍历集合的统一编程接口

 ●Collection接口的Iterator()方法返回一个Iterator,然后通过Iterator接口的两个方法即可方便的实现遍历

>boolean hasNext():判断是否存在另一个可访问的元素

>Object next():返回要访问的下一个元素

2.使用Iterator遍历集合类

●JDK1.5加入增强for循环：foreach语句

格式：for（元素类型t元素变量x：数组或集合对象）{

//引用了x的语句

}

●Iterator迭代名 =集合.iterator()；

while(迭代名.hasNext()){

对象 对象名 =（对象类型转换）迭代名.next();

    //打印输出

}

六．泛型集合

1.JDK1.5引入泛型（Generic）

使用泛型集合在创建集合对象时指定集合中元素的类型，从集合中取出元素时无须进行强制转换，并且如果把非制定类型对象放入集合，会出现编译错误

2.泛型集合的应用<E>，<K,V>是List和Map类型形参

接口 List<E>

所有超级接口：

Collection<E>,Iterable<E>

——Java API中List接口

接口 Map<K,V>

类型参数：

K-此映射所维护的键的类型

       V-映射值的类型

——Java API中Map接口

3.包装类

●Java中共八个包装类：Byte，Short，Integer，Long，Float，Double，Boolean，Character

●包装类常用的构造方法

语法：public Type(typevalue)

注:Type表示包装类，type代表基本类型，一旦创建了某个包装类对象，该对象所代表的值就不能变了

●常用的类型转换

>包装类→基本类型

语法：public type typeValue()

>字符串→基本类型

语法：publicstatictypeparseType(String type)

第七章 多线程

一．单词

二．线程概述

1.进程的特点

>进程是系统运行系统的基本单位

>每个进程都有自己独立的一块内存空间、一组系统资源

>每个进程的内部数据和状态都是完全独立的

2.线程是进程中执行运算的最小单位，可完成一个独立的顺序控制流程

3.多线程的好处

>充分利用CPU的资源

>简化编程模型

>带来良好的用户体验

三、在Java中实现多线程

1.Thread类及其常用方法提供Java.lang.Thread类支持多线程编程

构造方法	说明说明
Thread（）	分配新的Thread对象
Thread(Runnable target)	分配新的Thread对象
Thread(Runnable target,Stringname)	分配新的Thread对象，traget为run()方法，被调用的对象，name为新线程的名称
void run()	执行任务操作的方法
void start()	使该线程开始执行，Java虚拟机调用该线程的run()方法
voidsleep(long millis)	在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）
String getName()	返回线程的名称
int getPriority()	返回线程的优先级
static Thread currentThread()	返回当前正在执行的线程
Boolean isAlive()	测试线程是否处于活动状态
void join()	等待该线程停止
void interrupt()	中断线程
void yield()	暂停当前正在执行的线程对象，并执行其他线程

2.主线程

●重要性体现在以下两方面

>它是产生其他子线程的线程

>通常它必须最后完成执行，因为它执行各种关闭动作

●尽管主线程在程序启动时创建，但它可以由一个Thread对象控制

为此，需要调用方法currentThread()获得它的一个引用，currentThread()方法是Thread类的公用的静态成员。它的通常形式如下：

staticThreadcurrentThread()

该方法返回一个调用它的线程的引用。一旦获得主线程的引用，就可以像控制其他线程那样控制主线程

●使用线程的过程，可以分为四个步骤：

>定义一个线程，同时指明这个线程所要执行的代码，即期望完成的功能

>创建线程对象

>启动线程

>终止线程

3.继承Thread类创建线程

步骤：>定义MyThread类继承Thread类

>重新定义run()方法，在run()方法中实现数据输出

>创建线程对象，调用start()方法启动线程

4.实现Runnable()接口创建线程 定义在java.lang包中

步骤：>定义MyRunnable类实现Runnable接口，并实现Runnable接口的run()方法，在run()方法中实现输出数据

>创建MyRunnable类的对象myRunnable

>创建一个Thread类的对象myThread,将myRunnable对象作为Thread类构造方法的参数传入

四.线程的状态

1.创建状态 2.就绪状态 3.运行状态 4.阻塞状态 5.死亡状态

五．线程的调度

1.线程的优先级

>每个线程优先级介于Thread.MIN-PRIORITY和Thread.MAX-PRIORITY之间

2.线程的休眠

>sleep()方法定义语法以下.

     public staticvoid sleep(long millis)

>sleep()方法会让当前线程休眠(停止执行)millies毫秒，线程由运行中的状态进入不可运行的状态，睡眠时间过后线程会再次进入可运行状态。调用sleep()方法需处理InterruptedException异常

3.线程的强制运行

>join()方法使当前线程暂停执行，等待调用方法的线程结束后，再结束执行本线程。三种重载方法，语法如下：

         publicfinal void join()

         publicfinal void join(long millis)

         publicfinal void join(long millis,int nanos)

与sleep()方法一样，调用join()方法需要处理，InterruptedException异常

4.线程的礼让

●yield()方法定义的语法如下：

          publicstatic void yield()

>yield()方法可暂停当前线程执行，允许其他具有相同优先级的线程获得运行机会，该线程仍处于就绪状态，不转为阻塞状态，此时，系统选择其他相同或更高优先级线程执行，若无其他或更高优先级线程，则该线程继续执行

六．线程的同步

1.实现

●同步方法

>通过在方法声明中加入synchronized关键字来声明同步方法

语法:访问修饰符 synchronized 返回类型方法名(参数列表){

//省略方法体

}

或者 synchronized 访问修饰符 返回类型 方法名(参数列表){//省略}

>在语法中：

>synchronized是同步关键字

>访问修饰符是指public,private等

>同步方法的缺陷

如果将一个运行时间比较长的方法声明成synchronized将会影响效率

●同步代码块即使用{}括起来的一段代码，使用synchronized关键字修饰的代码块，称为同步代码块

其语法如下:synchronized(syncObject){

                         //需要同步的代码

}

            Synchronized块中的代码必须获得对象syncObject的锁才能执行，具体机制与同步方法一致。由于可以针对任意代码块，并且可以任意指定上锁的对象，因此灵活性更高

>synchronized是为当前的线程声明一个锁，获得这个锁的线程可以执行代码块里的指令，其他的线程只能等待获取锁。然后才能执行相同的操作

2.线程安全的类型

●ArrayList对象中添加数据，由两步来完成

>将索引值加一，即为集合扩容，确保可装入新元素

>在新增位置存放数据

      add()方法是非线程同步的

●对比Hashtable和HashMap

>继承关系不同

两者实现了Map接口，Hashtable继承Dictionary类，HashMap继承AbstractMap类

>是否线程安全

      Hashtable类型是线程安全的，其中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的，在多线程开发的环境下可以直接使用Hashtable,如果使用HashMap就要自行增加同步处理

>是否允许出现null值

在HashMap中，null可以作为键，也可以作为值，而Hashtable中的键和值都不允许为null，否则将会出现NullPointException异常

>效率比较

由于Hashtable是线程安全的，其方法是同步的，而HashMap是非线程安全的，重速度，较安全。当只需单线程时，使用HashMap执行速度要高于Hashtable

3.比较StringBuffer和StringBuilder

StringBuffer和StringBuilder都可用存储字符串变量，是可变的对象。它们的区别是StringBuffer是线程安全的，而StringBuilder是非线程安全的。因此在单线程环境中，StringBuilder的执行效率较高

 

第八章 FileI/O

一．单词

二．操作文件或目录的属性

1.使用File类操作文件或目录属性

①java.io包提供了一些接口和类，对文件进行基本的操作，包括对文件和目录属性的操作，对文件读写的操作等。

②创建一个File对象的语法格式如下：

       File file=new File(String pathName);

注:分隔符使用正斜杠“/”或者反双斜杠“\\”

>File类常用方法

方法名称	说      明
boolean exists( )	判断文件或目录是否存在
boolean isFile( )	判断是否是文件
boolean isDirectory( )	判断是否是目录
String getPath( )	返回此对象表示的文件的相对路径名
String getAbsolutePath( )	返回此对象表示的文件的绝对路径名
String getName( )	返回此对象表示的文件或目录的名称
boolean delete( )	删除此对象指定的文件或目录
boolean createNewFile( )	创建名称的空文件，不创建文件夹
long  length()	返回文件的长度，单位为字节, 如果文件不存在，则返回 0L

 

 

注:需要时，查API即可

三．Java的流

1.流具有明确的方向性，当向一个流写入数据时，这个流称为输出流

2.在Java.io包中封装了许多输入/输出流的API

在程序中，这些输入/输出流的类的对象称为流对象

3.数据源分为源数据和目标数据源，输入流联系的是源数据流，输出流则是目标数据源

4.按照不同的分类的方式，可以将流分为不同的类型

a.按照流的流向进行划分，可以分为输入流和输出流

 b.按照所操作的数据单元的不同，流又可划分成字节流和字符流

字节流：i.字节输入流InputStream基类

             ii.字节输出流OutputStream基类

字符流：i.字符输入流Reader基类

              ii.字符输出流Writer基类

四．读写文本文件

1.使用字节流读取文本文件

①字节输入流InputStream的作用就是将文件中的数据输入到内部存储器（简称内存）中

>读取数据的常用方法

方法名称	说明
int read( )	读取一个字节数据
int read(byte[] b)	将数据读取到字节数组中
int read(byte[] b,int off,int len)	从输入流中读取len长度的字节保存到字节数组中b中，保存位置从off开始
void close( )	关闭输入流
int available()	返回输入流读取的估计字节数

 

 

 

 

》无参的read()方法从输入流读取一个八位的字节，把它转换为0~255的整数返回

》有参的两个read()方法从输入批量读取若干个字节

2.字节输入流FileInputStream类

①FileInputStream(File file),file指定文件数据源

File file =new File(“C:\\test.txt”);

        InputStreamfileObject =new FileInputStream(file);

②FileInputStream(String name),name指定文件数据流，包含路径信息

InputStreamin =new FileInputStream(“C:\\test.txt”);

③使用FileInputStream读取文件

>引入相关类

         Importjava.io.IOException;

         Importjava.io.InputStream;

         Importjava.io.FileInputStream;

>创建一个文件输入流对象

InputStreamfileObject =newFileInputStream(“C:\\test.txt”);

>利用文件输入流的方法读取文本文件的数据

        fileObject.available();  //可读取的字节数

fileObject.read();    //读取文件的数据

>关闭文件输入流对象

        fileObject.close();

注:(1)read()方法返回整数，若读取的是字节符，则需强制类型转换

      (2)流对象使用完毕后需要关闭

3.使用字节流写文本文件

①字节输入流OutputStream类

字节输入流OutputStream类的作用是把内存中的数据输出到文件

    OutputStream类的常用方法：

方法名	说明
void write(int c)	写入一个字节数据
void write(byte[] buf)	写入数组buf的所有字节
void write(byte[] b,int off,int len)	将字节数组中从off位置开始，长度为len的字节数据输入到输出流中
void close( )	关闭输出流

 

 

 

 

②字节输出流FileOutputStream类

常用的构造方法有三个：

>FileOutputStream (Filefile),file指定文件目标数据源

         File file =new File(“C:\\test.txt”);

          FileOutputStream fos =newFileOutStream(file);

>FileOutputStream(Stringname),name指定文件目标数据源

         FileOutputStream fos =newFileOutputStream(“C:\\test.txt”);

>FileOutputStream(Stringname,Boolean append)

name指定文件目标数据源，包含路径信息

       append表示是否在文件末尾添加数据，若设置为true,则在文件末尾添加数据源

FileOutputStream fos=new FileOutStream(“C:\\test.txt”,true);

③使用FileOutputStream写文本文件

>引入相关类

         Importjava.io.IOException;

         Importjava.io.OutputStream;

         Importjava.io.FileOutputStream;

>构造一个文件输出流对象

        OutputStream fos =new FileOutStream(“C:\\test.txt”);

>利用文件输出流的方法把数据写入文本文件中

         Stringstr=“好好学习Java”；

         Byte[]words =str.getBytes();

//利用write方法将数据写入文件中去

fos.write(words,o,words.length);

>关闭文件输出流

         Fos.close();

4.使用字符流读取文本文件

>字符输入流Reader类 →抽象类

Reader类常用方法

方法名称	说明
int read()	从输入流中读取单个字符
int read(byte[] c)	从输入流中读取c.length长度符，保存到字符数组c中，返回实际读取的字符数
read(char[] c,int off,int len)	从输入流中读取最多len的长度字符，保存到字符数组c，保存的位置从off位置开始，返回实际读取的字符长度
Void close()	关闭流

 

 

 

 

>字符输入流FileReader类

FileReader类是Reader的子类，常用构造方法格式如下：

FileReader(String fileName);

其中，fileName是指要从中读取数据的文件的名称

          Reader fr =new fileReader(“C:\\test.txt”);

>使用FileReader读取文件

a．引入相关类

         Importjava.io.Reader;

         Importjava.io.FileReader;

         Importjava.io.IOException;

       b.创建一个FileReader对象

Reader fr =new FileReader(“C:\\test.txt”);

        c.利用FileReader类的方法读取文本文件的数据

         intread();  //读取单个字符

d.关闭相关的流对象

>字符输入流BufferedReader类 →Reader类子类

与FileReader类的区别在于，BufferedReader类带缓冲区

常用的构造方法格式如下：

              BufferedReader(Reader in);

使用此构造方法创建字符输入对象如下：

Reader fr = new FileReader(“C:\\nytest.txt”);

                BufferedReader br = new BufferedReader(fr);

其中，br就是创建的一个使用默认大小输入缓冲区的缓冲字符输入流

>使用FileReader和BufferedReader读取文本文件

a．引入相关类

 Import java.io.FileReader;

 Import java.io.BufferedReader;

Import java.io.IOException;

b.创建一个BufferedReader对象

Reader fr =new FileReader(“C:\\nytest.txt”);

             BufferedReaderbr =new BufferedReader(fr);

           c.利用BufferedReader类的方法读取文本文件的数据

           br.readLine();    //读取一行数据，返回字符串

           readLine()方法是BufferedReader类特有的方法，用来按行读取内容

d.关闭相关的流对象

br.close();

 fr.close();

5.使用字符流写文本文件

①字符输出流Writer类

Write类是向文件写入数据的字符流，它提供了常用的方法

方法名	说明
write(String str)	将str字符串里包含的字符输出到指定的输出流中
write(String str,int off,int len)	将str字符串从off位置开始长度为len的字符输出到输出流中
void close()	关闭输出流
void flush()	刷新输出流

②字符输出流FileWriter类

FileWriter类Reader的子类，常用构造方法格式如下：

FileWriter(StringfileName);

其中，fileName表示与系统有关的文件名，使用此构造方法创建字符输出对象如下：

Writerfr=new FileWriter(“C:\\nytest.txt”);

③使用FileWriter写文本文件

a．引入相关类

       Importjava.io.FileWriter;

 Import java.io.IOException；

    b.创建一个FileWriter对象

Writerfw =new fileWriter(“C:\\nytest.txt”);

c.利用FileWriter类的方法写文本文件

       br.write(“Hello”);

d.相关流对象的清空和关闭

      br.flush();  //刷新该流的缓冲

      fw.close();  //关闭此流

④字符输出流BufferedWriter类

>BufferedWriter是Writer类的子类，BufferedWriter与BufferedReader的流方向正好相反，BufferedWriter是把一批数据写到缓冲区，当缓冲区满的时候，再把缓冲区的数据写到字符输出流中。

>BufferedWriter类的常用构造方法如下：

       BufferedReader(Writer out);

>使用此构造方法创建的使用默认大小输出缓冲区的缓冲字符输出流

⑤使用BufferedWriter和FileWriter写文本文件

a．引入相关类

         Importjava.io.FileWriter;

         Importjava.io.BufferedWriter;

         Importjava.io.IOException;

b.构造一个BufferedWriter对象

FileWriter fw =new FileWriter(C:\\myTest.txt);

         BufferedWriter bw =new BufferedWriter(fw);

      c.利用BufferedWriter类的方法写文本文件

        bw.write(“Hello”);

      d.相关流对象的清空和关闭

bw.flush();  //刷新该流的缓冲

fw.close();  //关闭此流

五．二进制文件的读写

1.使用字节流类DataInputStream读二进制文件

DataInputStream类是FileInputStream的子类，它是FileInputStream类的扩展

具体步骤：

a．引入相关类

Import java.io.FileInputStream;

Import java.io.DataInputStream;

b．构造一个数据输入流对象

FileInputStream fis =newFileInputStream(“C:\\HelloWorld.class”);

         DataInputStream dis =new DataInputStream(fis);

c．利用数据输入流类的方法读取二进制文件的数据

dis.read();  //读取数据节

d．关闭数据输入流

dis.close();  //从关闭数据输入流

2．使用字节流类DataOutputStream写二进制文件

DataOutputStream类是FileOutputStream的子类，它是FileOutputStream类的扩展

具体步骤：

a．引入相关类

Import java.io.FileOutputStream;

Import java.io.DataOutputStream;

b．构造一个数据输出流对象

FileOutputStreamoutFile=newFileOutputStream(“C:\\temp.class”);

         DataOutputStreamout =new DataOutputStream(outFile);

c．利用数据输出流类的方法写二进制文件的数据

out.write();  //将指定字节数据写入二进制文件

d．关闭数据输入流

out.close();  //关闭数据输出流