学习笔记6-面向对象

------- android培训、java培训、期待与您交流！ ----------

面向对象的设计原则

单一职责原则：一个类，只有一个引起它变化的原因，如果一个类有一个以上的职责，这些职责就耦合在了一起 

– 当一个职责发生变化时，可能会影响其它的职责 

– 多个职责耦合在一起，会影响复用性 

开闭原则：软件实体（类、模块、函数等）应该是可扩展的，但不可修改 

• 遵循开发-封闭原则设计的两个主要特征

– 对于扩展是开放的

– 对于更改是封闭的

• 好处

– 可复用性好 

• 软件完成以后，仍然可以对软件进行扩展，加入新的功能，非常灵活 。因此，这个软件系统就可以通过不断地增加新的组件，来满足不断变化的需求。 

– 可维护性好

• 由于对于已有的软件系统的组件，特别是它的抽象底层不去修改，因此，我们不用担心软件系统中原有组件的稳定性，这就使变化中的软件系统有一定的稳定性和延续性 

里氏代换原则 

• 子类必须能够替换掉它们的基类型 

• 里氏代换原则是对“开-闭”原则的补充

• 如果两个具体的类A，B之间的关系违反了LSP的设计 

– 创建一个新的抽象类C，作为两个具体类的超类，将A，B的共同行为移动到C中来解决问题 

– 从B到A的继承关系改为委派关系  

• 在进行设计的时候，我们尽量从抽象类继承，而不是从具体类继承 

• 长方形和正方形的例子不满足LSP

– OOD的IS-A关系是就行为方式而言的，行为方式是可以进行合理假设的，是客户程序设计所依赖的

依赖倒置原则

• 高层模块不应该依赖于底层模块，二者都应该依赖于抽象

• 抽象不应该依赖于细节。细节应该依赖于抽象 

• Hollywood原则: “Don‘t call us, we’ll call you”.程序中所有的依赖关系都应该终止于抽象类和接口针对接口而非实现编程 

• 依赖于抽象的启发式规则：

– 任何变量都不应该持有一个指向具体类的指针或引用

– 任何类都不应该从具体类派生

– 任何方法都不应该覆写他任何基类中的已经实现了的方法 

接口隔离原则

• 使用多个专门的接口比使用单一的总接口要好

• 一个类对另外一个类的依赖性应当是建立在最小的接口上的

• 一个接口代表一个角色，不应当将不同的角色都交给一个接口 

• 不应该强迫客户依赖于它们不用的方法。接口属于客户，不属于它所在的类层次结构 

• 满足接口隔离原则,调用者只能访问它自己的方法,不能访问到不应该访问的方法 

合成/聚合复用原则

• 合成（Composition）和聚合（Aggregation）都是关联（Association）的特殊种类。聚合表示整体和部分的关系，表示“拥有 ”；合成则是一种更强的“拥有”，部分和整体的生命周期一样 

• 在OOD中，有两种基本的办法可以实现复用

– 合成/聚合

– 继承 

• HAS-A而非IS-A

迪米特法则 

• 迪米特法则可以简单说成：talk only to your immediate friends 

• 一个软件实体应当尽可能少的与其他实体发生相互作用。每一个软件单位对其他的单位都只有最少的知识，而且局限于那些与本单位密切相关的软件单位 

• 迪米特法则的初衷在于降低类之间的耦合 

• 设计模式的门面模式（Facade）和中介模式（Mediator），都是迪米特法则应用的例子 

类、对象和方法高效设计原则

类与对象高效设计原则

• 避免创建重复对象

• 消除过期的对象引用

• 避免使用终结函数

• 为所有导出API的元素编写文档注释

• 使类和成员的可访问能力最小化

• 复合优先于继承

继承是复用的用力手段但不是最佳工具

• 对普通类跨包继承，是非常危险的

• 与方法调用不同，继承打破了封装性

• 使用复合的方式可以完全取代继承的复用。

复合类不依赖于原有类的实现细节，原有类修改不会影响到复合类

• 接口优先于抽象类

– 抽象类只允许单继承，作为类型定义受到了极大限制

已有的类可以很容易被更新，实现新的接口，并使得安全的增强一个类的功能成为可能

• 定义内部类：优先考虑静态成员类

方法高效设计

• 谨慎选择方法的名字，要简洁易懂

• 避免长长的参数列表

• 对于参数类型，优先使用接口而不是类

• 返回零长度数组而不是null

• 将局部变量的作用域最小化

– 第一次使用它的地方声明

– 几乎每一个局部变量的声明都应该包含一个初始化表达式

• for循环优先于while循环

• 使方法小而集中

Java环境

JDK&JRE

Java优势：简单、跨平台、面向对象、安全性高、分布式、多线程

JDK：Java开发工具集(Java Development Kit)

Ø JDK提供了Java的开发环境和运行环境，由java虚拟机、java应用编程接口(API ，就是java基础类库rt.jar)和开发工具（开发者用以编译、调试和运行Java程序的工具）组成

Ø Java开发人员可以通过它开发程序或调用java内容

Ø Sun公司认为JDK 1.5的发布是JAVA语言发展史上的又一里程碑事件。为了表示这个版本的重要性，JDK1.5又称为JDK 5.0

JDK安装目录： 

bin目录：存放JDK的工具程序是可执行文件;

lib目录：存放工具程序使用的Java类库文件;

include目录：存放用于本地方法的文件; 

demo目录：存放演示程序;

jre目录：存放Java运行环境文件;

bin目录及所提供的工具程序提供了一些开发Java程序时必备的工具程序。需将该目录添加到操作系统的系统环境变量PATH中。

 

JRE：

Ø Java Runtime Enviroment. JRE包含一方面与硬件交互，另一方面与程序交互的JVM。它是java程序运行时所必须的环境集合。主要由JVM、Java平台核心类、若干支持文件（类加载器、字节码校检器等）组成。

Ø 在程序运行时，JRE由类加载器负责查找和加载程序引用到的基本类库和其他类库。操作系统通过PATH环境变量来查找JRE并确定基础类库文件rt.jar的位置；其他类库由类加载器在环境变量CLASSPATH指定的路径中搜索。因此，在java程序启动前最好先把PATH和CLASSPATH环境变量设置好

JVM

JVM：Java虚拟机是一个虚构出来的计算机，可在实际的计算机中模拟各种计算机功能，是一个软件程序。JVM有自己完善的硬件架构，例如处理器、堆栈和寄存器等，还具有相应的指令系统。使用java.exe工具执行Java程序时，操作系统会自动寻找JRE环境

（1）类加载器：为程序的执行加载所需要的全部类。类加载器将本地文件系统的类名空间与来自远程网络源的类名空间相分离，本地类总是首选被加载，用来保证安全性。当全部类被加载后，可执行文件的存储器格式被确定，然后依照这些模板创建对象

（2）字节代码校验器：基于代码的规范包括语法语义的检查以及如上所述的安全性检查。

（3）JAVA运行时解释器：它是JVM的核心内容，实现把抽象的字节码指令映射到本地系统平台下的库引用或指令。  

JVM作用:

Ø JVM负责解析和执行Java程序。

Ø 可以运行在各种操作系统平台上。只要在任意操作系统装入JVM，java程序就有了可移植性。Java源码和字节码与机器无关，但JVM与机器相关，装有不同操作系统的机器上，需有专门为该操作系统开发的JVM

Ø 计算机受其存储单元的限制，只能表示和操作一些基本数据类型。对象模型中的类可看作是开发人员自定义的数据类型，jvm的运行时环境封装了把自定义数据类型映射到计算机的内置数据类型的过程，使得开发人员不受计算机内置数据类型的限制，对任意问题领域，都可以方便的根据“先识别对象，再进行分类”的思路来建立对象模型

Ø JVM在整个JDK的最底层，负责与操作系统的交互，用来屏蔽操作系统环境，提供一个完整的java运行环境。操作系统装入JVM是通过JDK中的java.exe来实现。

Ø 是java字节码执行的引擎，为java程序的执行提供必要的支持，程序员编写的程序最终都要在JVM上执行。它还能优化java字节码，使之转换成更高效率的机器指令。

JVM细节

Ø JVM实例对应了一个独立运行的java程序 它是进程级别 。JVM执行引擎实例则对应了属于用户运行程序的线程 它是线程级别的

Ø Java 源代码和字节码与机器无关，但JVM 是与机器相关的。装有不同操作系统的机器上，需要有专门为该操作系统开发的JVM

Ø JVM中类的装载由类加载器和它的子类来实现。ClassLoader是JAVA运行时一个重要的系统组件，负责在运行时查找和装入类文件的类。

Ø 不同平台对应不同的JVM,在执行字节码时，JVM负责将每一条要执行的字节码送给解释器，解释器再将其翻译成特定平台环境的机器指令并执行。使用JVM就是为了支持与操作系统无关，实现跨平台运行。

JVM生命周期

（1）JVM实例的诞生 

当启动一个Java程序时，一个JVM实例就产生了，任何一个拥有public static void main(String[] args)函数的class都可以作为JVM实例运行的起点 

    （2）JVM实例的运行 

main()作为该程序初始线程的起点，任何其他线程均由该线程启动。JVM内部有两种线程：守护线程和非守护线程，main()属于非守护线程，守护线程通常由JVM自己使用，java程序也可以标明自己创建的线程是守护线程。  

    （3）JVM实例的消亡 

    当程序中的所有非守护线程都终止时，JVM才退出；若安全管理器允许，程 序也可以使用Runtime类或者System.exit()来退出。

JVM体系结构

 

Ø 分为三部分：类装载器子系统、执行引擎、运行时数据区

类装载器

一、JVM两种类装载器包括：启动类装载器和用户自定义类装载器。启动类装 载器是JVM实现的一部分，用户自定义类装载器则是Java程序的一部分，必须是 ClassLoader类的子类。 

二、 主要分为以下几类： 

(1) Bootstrap ClassLoader 。这是JVM的根ClassLoader，它是用C++实现的，JVM启动时初始化此ClassLoader，并由此ClassLoader完成$JAVA_HOME中jre/lib/rt.jar（Sun JDK的实现）中所有class文件的加载，这个jar中包含了java规范定义的所有接口以及实现。 

(2) Extension ClassLoader 。JVM用此classloader来加载扩展功能的一些jar包 

(3) System ClassLoader 。JVM用此classloader来加载启动参数中指定的Classpath中的jar包以及目录，在Sun JDK中ClassLoader对应的类名为AppClassLoader。 

(4) User-Defined ClassLoader 。User-DefinedClassLoader是Java开发人员继承ClassLoader抽象类自行实现的ClassLoader，基于自定义的ClassLoader可用于加载非Classpath中的jar以及目录

三、ClassLoader抽象类提供了几个关键的方法： 

（1）loadClass此方法负责加载指定名字的类，ClassLoader的实现方法为先从已经加载的类中寻找，如没有则继续从parent ClassLoader中寻找，如仍然没找到，则从System ClassLoader中寻找，最后再调用findClass方法来寻找，如要改变类的加载顺序，则可覆盖此方法 

（2）findLoadedClass 此方法负责从当前ClassLoader实例对象的缓存中寻找已加载的类，调用的为native的方法。

（3）findClass 此方法直接抛出ClassNotFoundException，因此需要通过覆盖loadClass或此方法来以自定义的方式加载相应的类。

 (4) findSystemClass 此方法负责从System ClassLoader中寻找类，如未找到，则继续从Bootstrap ClassLoader中寻找，如仍然为找到，则返回null。

 (5)defineClass 此方法负责将二进制的字节码转换为Class对象 

 (6) resolveClass 此方法负责完成Class对象的链接，如已链接过，则会直接返回。

执行引擎

一、JVM通过执行引擎来完成字节码的执行，在执行过程中JVM采用的是自己的一套指令系统，每个线程在创建后，都会产生一个程序计数器（pc）和栈（Stack），其中程序计数器中存放了下一条将要执行的指令，Stack中存放Stack Frame，表示的为当前正在执行的方法，每个方法的执行都会产生Stack Frame，Stack Frame中存放了传递给方法的参数、方法内的局部变量以及操作数栈，操作数栈用于存放指令运算的中间结果，指令负责从操作数栈中弹出参与运算的操作数，指令执行完毕后再将计算结果压回到操作数栈，当方法执行完毕后则从Stack中弹出，继续其他方法的执行。 

        在执行方法时JVM提供了invokestatic、invokevirtual、invokeinterface和invokespecial四种指令来执行

        （1）invokestatic：调用类的static方法

        （2） invokevirtual： 调用对象实例的方法 

        （3） invokeinterface：将属性定义为接口来进行调用 

        （4） invokespecial： JVM对于初始化对象（Java构造器的方法为：<init>）以及调用对象实例中的私有方法时。

二、反射机制是Java的亮点之一，基于反射可动态调用某对象实例中对应的方法、访问查看对象的属性等，而无需在编写代码时就确定需要创建的对象，这使得Java可以实现很灵活的实现对象的调用，代码示例如下：

Class actionClass=Class.forName(外部实现类); 

Method method=actionClass.getMethod(“execute”,null); 

Object action=actionClass.newInstance(); 

method.invoke(action,null);

反射的关键：要实现动态的调用，最明显的方法就是动态的生成字节码，加载到JVM中并执行

（1）Class actionClass=Class.forName(外部实现类); 

         调用本地方法，使用调用者所在的ClassLoader来加载创建出Class对象； 

（2）Method method=actionClass.getMethod(“execute”,null); 

校验此Class是否为public类型的，以确定类的执行权限，如不是public类型的，则直接抛出 SecurityException；

（1） 调用privateGetDeclaredMethods来获取到此Class中所有的方法，在privateGetDeclaredMethods对此Class中所有的方法的集合做了缓存，在第一次时会调用本地方法去获取； 扫描方法集合列表中是否有相同方法名以及参数类型的方法，如有则复制生成一个新的Method对象返回； 如没有则继续扫描父类、父接口中是否有此方法，如仍然没找到方法则抛出NoSuchMethodException；

（3） Object action=actionClass.newInstance(); 

     一：校验此Class是否为public类型，如权限不足则直接抛出SecurityException；

             二：如没有缓存的构造器对象，则调用本地方法获取到构造器，并复制生成一个新的构造器对象，放入缓存，如没有空构造器则抛出InstantiationException；

             三：校验构造器对象的权限； 

             四：执行构造器对象的newInstance方法；构造器对象的newInstance方法判断是否有缓存的ConstructorAccessor对象，如果没有则调用sun.reflect.ReflectionFactory生成新的ConstructorAccessor对象； 

             五：sun.reflect.ReflectionFactory判断是否需要调用本地代码，可通过sun.reflect.noInflation=true来设置为不调用本地代码，在不调用本地代码的情况下，就转交给MethodAccessorGenerator来处理了； 

             六：MethodAccessorGenerator中的generate方法根据Java Class格式规范生成字节码，字节码中包括了ConstructorAccessor对象需要的newInstance方法，此newInstance方法对应的指令为invokespecial，所需的参数则从外部压入，生成的Constructor类的名字以：sun/reflect/GeneratedSerializationConstructorAccessor或sun/reflect/GeneratedConstructorAccessor开头，后面跟随一个累计创建的对象的次数；

             七：在生成了字节码后将其加载到当前的ClassLoader中，并实例化，完成ConstructorAccessor对象的创建过程，并将此对象放入构造器对象的缓存中；

             最后一步：执行获取的constructorAccessor.newInstance，这步和标准的方法调用没有任何区别。

三、执行技术。 主要的执行技术有:解释，即时编译，自适应优化、芯片级直接执行 

    （1）解释属于第一代JVM， 

    （2）即时编译JIT属于第二代JVM， 

    （3）自适应优化（目前Sun的HotspotJVM采用这种技术）则吸取第一代JVM和第二代JVM的经验，采用两者结合的方式    

    （4）自适应优化：开始对所有的代码都采取解释执行的方式，并监视代码执行情况，然后对那些经常调用的方法启动一个后台线程，将其编译为本地代码，并进行仔细优化。若方法不再频繁使用，则取消编译过的代码，仍对其进行解释执行。

配置环境变量

PATH与CLASSPATH:

Ø 操作系统通过PATH环境变量来查找并确定基础类库文件rt.jar的位置，通过CLASSPATH来查找并确定其他类库文件的位置

Ø 设置PATH变量是为了让操作系统找到指定的工具程序。设置CLASSPATH变量是为了让Java执行环境找到指定的Java程序对应的class文件以及程序引用到的其他class文件。JDK默认会在当前工作目录和JDK的lib目录下寻找所需class文件，因此若java程序在这两个目录中，不用设置CLASSPATH,但在其他目录下，必须设置CLASSPATH

Ø 安装好JDK后，还需设定好路径信息，以确保计算机能找到javac和java这两个文件

1.打开我的电脑--属性--高级--环境变量 
2.新建系统变量JAVA_HOME 和CLASSPATH 
   变量名：JAVA_HOME（让诸如Tomcat等应用软件找到你Java的安装路径, 因为他们需要用）
   变量值：C:\Program Files\Java\jdk1.7.0
   变量名：CLASSPATH 
   变量值：.%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;
3. 选择“系统变量”中变量名为“Path”的环境变量，双击该变量，把JDK安装路径中bin目录的绝对路径，添加到Path变。 
   量的值中，并使用半角的分号和已有的路径进行分隔

变量名：Path 
   变量值：%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;
   这是java的环境配置，配置完成后直接启动eclipse，它会自动完成java环境的配置

开发Java程序的步骤：

1． 创建java源程序

Java源程序是一个用java语言写成的一个文本文件。一般以.java作为扩展名

2． 编译源程序

Java编译器（javac程序）读取源程序并翻译成java虚拟机能明白的指令集，且以字节码的形式（.class）保存在文件中。编译一个.java文件时，我们会获得一个名字完全相同的输出文件（.class结尾）；但对于.java文件中的每个类，它们编译后都有一个.class扩展名

3． 运行字节码文件

Java解释器读取字节码文件，取出指令集并翻译成计算机能执行的代码，完成运行过程

Java语言运行机制

计算机高级编程语言按执行方式分为编译型和解释型语言

编译型语言：指使用专门的编译器，针对特定操作系统将源程序代码一次性翻译成计算机能识别的机器指令。如C、C++

在后续执行时，直接运行第一次编译的结果，减少了编译次数，提高了程序运行效率，但程序第一次编译时与系统平台相对应，因此移植性较差

解释型语言：指使用专门的解释器，将源程序代码逐条解释成特定平台的机器指令，解释一句执行一句，类似“同声翻译”。在程序每次运行时都要将源程序解释成当前系统平台相对应的机器指令，因此每次运行都要解释执行，效率较低，但移植性高

java是编译型和解释型语言的结合体。先采用通用的java编译器将源程序代码编译成与平台无关的字节码文件（即二进制的编码文件），然后由java虚拟机对字节码文件解释成特定平台的机器指令去执行。编译一次，到处运行

字节码文件:Javac.exe把.java源文件编译成.class文件,但.class文件并不是字节码文件。当类加载器把.class文件加载进内存时，会做一些比如安全检查等处理，处理完成后所得到的最终的二进制内容才是字节码文件。JVM的解析器能解析这种字节码

 

 

Ø 类加载过程

（1）装载。 把.class文件中的二进制数据加载到JVM的内存中，JVM通过类名、类所在的包名通过ClassLoader（以类名+包名+ClassLoader实例ID标识）来完成类的加载。 

（2）连接。 链接过程负责对二进制字节码的格式进行校验、初始化装载类中的静态变量以及解析类中调用的接口、类。

      在完成了校验后，JVM初始化类中的静态变量，并将其值赋为默认值。最后一步为对类中的所有属性、方法进行验证，以确保其需要调用的属性、方法存在，以及应具备的权限（例如public、private等）。可能会造成NoSuchMethodError、NoSuchFieldError等错误信息。

（3）初始化。 初始化过程即为执行类中的静态初始化代码、构造器代码以及静态属性的初始化，在四种情况下初始化过程会被触发执行：调用了new；反射调用了类中的方法；子类调用了初始化；JVM启动过程中指定的初始化类。

Ø 运行

java命令用于运行lava程序，它会启动一个java虚拟机进程（即启动Java虚拟机），该进程首先从classpath中找到相关的类文件，读取这个文件中的二进制数据，把该类的类型信息存放到运行时数据区的方法区中。接着JVM定位到方法区中该类的main()方法并执行下去

Java相关概念

API: API是Application Interface的简称。它是指一个软件系统对外提供的所有接口,就是系统对外提供的所有服务。

JAR文件： 

Ø JDK的Jar命令能把java应用中相关的class文件及资源文件打包成的一个文件

Ø java命令和javac命令会读取JAR文件中的java类

Ø JDK中的包和类主要在JDK的安装目录下的jre\lib\rt.jar文件中

Ø 只要在命令行中用以下命令就可以将一个包打成一个jar文件

      jar –cvf create.jar demo

        -c：创建新的存档

        -v：生成详细输出到标准输出上

        -f：指定存档文件名

        create.jar：是生成jar文件的名称

        demo：要打成jar文件的包  

GC：Garbage Collection。是 JVM中自动的对象内存回收机制

内存处理忘记或错的内存回收都会导致程序或系统的不稳定或崩溃。java为此提供了垃圾自动回收机制

Ø 在程序的运行时环境中，Java虚拟机提供了一个系统级的、低优先级的垃圾回收器线程，它负责自动回收无用对象所占用的内存

Ø java的内存管理其实就是对象的管理，包括对象的分配（new 对象）和释放（对象=null）。GC主要负责内存资源的管理。

Ø 当程序员创建对象时，GC就开始监控这个对象的地址、大小及使用情况，去辨别哪些对象不再被引用，然后释放其内存，以便供其他新的对象使用。

n 为了让GC运行更合理、高效，编程时应尽早释放无用对象的引用（置为null），特别是一些复杂的对象，如数组、集合、队列等。也要尽量少用finalize方法。该方法是java提供给程序员用来释放对象或资源的，但它会加大GC的工作量。也可以手动执行System.gc(),通知GC运行，但并不保证GC一定会执行

特点：

Ø 只有当对象不再被程序中的任何引用变量引用时，它的内存才可能被回收。

Ø 程序无法迫使垃圾回收器立即执行垃圾回收操作。

Ø 当垃圾回收器将要回收无用对象的内存时，先调用该对象的finalize方法，该方法有可能使对象复活，导致垃圾回收器取消回收该对象的内存。

好处：

Ø 把程序员从复杂的内存追踪、监测和释放等工作中解放出来，减轻程序员进行内存管理的负担。

Ø 防止系统内存被非法释放，从而使系统更加健壮和稳定。

Applet程序简介

Ø Applet程序是一个经过编译的Java程序，它既可以在Appletviewer下运行，也可以在支持Java的Web浏览器中运行。

Ø Applet程序可以完成图形显示、声音演奏、接受用户输入、处理输入内容等工作。Applet程序中必须有一个是Applet类的子类 

Ø Applet程序中使用的几个基本方法

1. public void init()

    init()方法是Applet运行的起点。当启动Applet程序时，系统首先调用此方法，以执行初始化任务

2. public void start() 

    start()方法是表明Applet程序开始执行的方法。当含有此Applet程序的Web页被再次访问时调用此方法

3. public void stop() 

    stop()方法使Applet停止执行，当含有该Applet的Web页被其他页代替时也要调用该方法 

4. public void destroy()

    destroy()方法收回Applet程序的所有资源，即释放已分配给它的所有资源。在Applet程序中，系统总是先调用stop()方法，后调用destroy()方法

5. paint(Graphics g) 

    paint(Graphics g)方法可以使Applet程序在屏幕上显示某些信息，如文字、色彩、背景或图像等

java基础

 

Java源文件的组成

Ø 每个Java源文件只能包含零个或一个包声明语句，零个或多个包引入语句，零个或多个类的声明，零个或多个接口声明，注释(空格除外)。每个Java源文件可包含多个类或接口的定义，但最多只有一个类或接口是public的，而且Java源文件必须以其中public类型的类的名字命名。

包：

Ø 包是类的容器，以分层方式保存，用于管理和区分Java类。为了防止不同模块间的名字冲突问题，Java提供了包机制，为每个类提供了唯一标识符。包名全部得小写，一般以因特网域名形式表明包名的惟一性

Ø 包名中一般包含类的创建者或拥有者的信息,类所属的软件项目的信息,类在具体软件项目中所处的位置。

Ø 包有助于实施访问权限控制。当位于不同包之间的类相互访问时，会受到访问权限的约束。

Ø Java用文件系统目录来存储包，将.class文件的位置路径编码到package的名字里。任何你声明的包中的类的.class文件被存储在一个包所指定的目录中。    

Ø 包声明语句用于把Java类放到特定的包中。最多包含一个package语句（package 包名）。package语句作为Java源文件的第一句，且必须在第一行（注释除外）

Ø 如果一个类访问了来自另一个包(( java.lang包除外)中的类，那么前者必须通过Import语句把这个类引入。

• 引入包：import java.lang .*; import java.util. Date; 

• 在每个程序文件的开头，必须声明import语句，以便引入在文件代码中需要用到的额外类。例外是java.lang包，它默认导入到每个java文件中，所以它的所有类不用import。

• import语句不会导致类的初始化,它并不意味着JAVA虚拟机刽把包中的类加载到内存中并对它们初始化。

注释：在java源代码的任意位置，都可以加入注释语句，编译器会忽视注释语句。java语言提供了3种形式的注释:

JavaDoc：

Ø 若文档与代码分离，那么每次修改代码时，都要修改相应的文档，麻烦又乏味，所以java将代码同文档放在同一文件内。

为使一切都整齐划一，还必须使用一种特殊的注释语法，以便标记出特殊的文档；另外还需要一个工具，用于提取这些注释，并按有价值的形式将其展现出来。这就是javadoc

Ø JavaDoc文档是供Java开发人员阅读的，他们通过JavaDoc文档来了解其他人员开发的类的用法。Java开发人员应该养成经常查阅JavaDac文档的良好习惯。

Ø 文档注释以“/**”开始，并以“*/”结束，里面可以包含普通文本、HTML标记和JavaDoc标记（如@author, @version, @see, @param，@return，@exception，@deprecated等; @see标记允许引用其他类里的文档）。

Ø javadoc能识别注释中用@标识的一些特殊标记。如果我们希望javadoc工具生成更详细的文档信息，则可利用javadoc标记

Ø javadoc命令不仅提取这些javadoc标记指示的信息，还处理类名、接口名、字段、构造方法、方法声明之前的注释。Javadoc就是用于从程序源码中抽取类、方法、成员等文档注释（/**…..*/），形成一个与源码配套的API帮助文档（HTML格式的文件）。注意：Javadoc只能为public和protected成员进行文档注释

Ø javadoc命令可对源文件、包来生成API文档，格式：javadoc选项Java源文件/包

Ø -d <directory>:该选项指定一个路径，用于将生成的API文档放到指定目录下。

Ø -windowtitle <text>:该选项指定一个字符串，用于设置API文档的浏览器窗口标题。

Ø doctitle<html-code>:该选项指定一个HTML格式的文本，用于指定概述页面的标题。

Ø -header <html-code>:该选项指定一个日下ML格式的文本，包含每个页面的页眉。

Ø 此外，javadoc命令还包含了大量其他选项，可以通过在命令行窗口执行j avadoc -help来查看javadoc命令的所有选项。

Ø 异常声明是接口(类中所有能被外部使用者访问的方法构成了类的接口）的一部分，JavaDoc文档中应描述方法可能会抛出某种异常的条件。根据异常声明，方法调用者了解到被调用方法可能抛出的异常，从而采取相应的措施:捕获并处理异常，或声明继续抛出异常。

1：面向对象
        定义：面向对象(Object Oriented,OO)是软件开过过程中使用一种思维方式 。

        特点：
是一种更符合人们思考习惯的思想。
可以将复杂的事情简单化。
将程序由执行者转换成了指挥者
       面向对象三大特征：
封装(encapsulation)
继承(inheritance)
多态(polymorphism)

2：类与对象——类

定义：具有相同特征（属性）和行为(功能)的一类事物的抽象。

类在Java中代码的体现形式：

定义格式：
 class 类名
 {
 
                 数据类型  成员变量名;
  
                        成员函数{ }

                  }

类与对象——类与对象的关系
对象：类的实体
如：人类是类的定义，张三李四便是人类的实体对象。

如：水果类是类的定义，苹果橘子是水果类的实体对象。

类与对象的关系：
类是抽象概念，对象是类的具体实例。

一个类可以有多个对象。一个对象只属于一个类。

对象创建格式：
数据类型 变量名(对象名) = new 数据类型(参数);
对象的使用：
成员变量的访问：
 
对象名.属性名
成员函数的调用
 
对象名.函数名(参数)

3：类与对象——成员变量与局部变量
成员变量
定义位置：类中，整个类中均可以访问。

内存：成员变量随着对象的建立而建立，存在于对象所在的堆内存中。

默认值：成员变量有默认值。

回收：随着对象的回收而回收。

局部变量
定义位置：定义域局部范围，如函数内，语句内等。

内存：局部变量存在于栈内存中。

默认值：没有默认值。

回收：随着作用域结束而回收，通常为语句或函数范围。

变量访问原则：就近原则
类与对象——匿名对象
匿名对象是对象的简化形式，即没有名字直接创建的对象。
匿名对象的使用：

对象方法只调用一次时。

作为实际参数传递时。

作为返回值返回时。
4：封装
定义：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

优点：
将变化隔离
便于使用
提高重用性
提高安全性
原则：
将不需要对外提供的内容都隐藏起来。
把属性都隐藏，提供公共方法对其访问。
封装——private关键字
是一个权限修饰符。

用于修饰成员(成员变量和成员函数)
被私有化的成员只在本类中有效。

常用方式：将成员变量私有化，对外提供对应的set ，get方法对其进行访问。提高对数据访问的安全性。

5：this关键字
定义：
this代表其所属对象的引用。
没有实例对象，this就没有意义。

this的使用：
当在函数内需要用到调用该函数的对象时，就用this
局部变量隐藏成员变量时，使用this区分。
构造函数中第一行，用来调用本类其他重载的构造函数

6：构造方法(掌握)
        用来创建实例对象
 创建同时可以给属性赋值
 (1)格式及特点
  格式：
   访问权限修饰符 类名(参数...){}

   访问权限修饰符:
    public,private
  特点：
   A:方法名和类名相同
   B:没有返回值类型
   C:没有具体的返回值
 (2)注意事项：
  A:如果你不给构造方法，jvm会自动给你一个无参构造方法。
  B:如果你给出了构造方法，那么，jvm将不再提供无参构造方法。
    这个时候，你如果要使用无参构造方法：只能自己提供

    推荐：永远手动给出无参构造方法。

7：this关键字(掌握)
 (1)是一个关键字。代表当前对象的引用。
  //简单记：在方法中，哪个对象调用方法，this就代表谁。
 (2)应用场景：
  解决局部变量隐藏成员变量问题。
  在构造方法中调用其他的构造方法(必须写在第一行)
  this();
  在其他方法中可以使用this.普通方法名()调用普通方法
  this.eat();

8：static关键字(理解)
 (1)是一个关键字。可以修饰成员变量和成员方法。
 (2)静态的特点：
  A:随着类的加载而加载
  B:优先于对象存在
  C:被类的所有对象共享
  D:可以通过类名调用
 (3)静态的注意事项：
  A:在静态方法中是没有this关键字的。
  B:静态方法只能访问静态的成员变量和静态的成员方法。
 (4)静态内容的调用：
  A:被对象调用
  B:被类名调用

  推荐被类名调用。
 (5)什么时候该用static呢?
  如果某个内容是所有对象共享的，就用静态修饰。
  举例：
   水杯和饮水机。
   厕所和人。
   老师和学生。
   对于传智学生都是热爱编程。