黑马程序员——第三章 面向对象

------<a href="http://www.itheima.com" target="blank">Java培训、Android培训、iOS培训、.Net培训</a>、期待与您交流！ -------

1.什么是面向对象

面向对象（OrientedObject Programming）是一种常见的程序结构设计方法，简称OOP。

面向过程：强调过程，执行者，强调的是功能行为。

面向对象：强调对象，指挥者，将功能封装进对象，强调具备了功能的对象，面向对象是基于面向过程的。

 

2.面向对象三大特征

封装(encapsulation)

继承(inheritance)

多态(polymorphism)

开发的过程：其实就是不断的创建对象，使用对象，指挥对象做事情。

设计的过程：其实就是在管理和维护对象之间的关系。

 

3.类和对象的关系

类是一组相同属性行为的对象的抽象。

对象即是该类事物实实在在存在的个体。

理解：类是一组事物的抽象总体描述，对象是该类的具体实例体现。

类和对象的建立：

//创建类Person

class Person {

   String name;

   int age;

   public void speak() {

       System.out.println("姓名:" + name + ",年龄:" + age);

    }

}

Person p = new Person();//创建Person一个对象p

 

4.匿名对象

定义：没有名字的对象。

使用：1，当对对象功能只执行一次

2，用于作为实际参数进行传递。

例：new Person();

 

5.面向对象之封装

  定义：隐藏对象的属性和实现细节，对外提供公共访问方式。

  好处：隔离变化，提高安全性、重用性，方便使用。

原则：隐藏不需要对外提供的内容，提供公共方法对其访问。

程序的一种体现：私有化(private)类中成员变量，对外提供（setXxx,getXxx）方法访问该变量(xxx)。

 

6.访问修饰符

public：公共访问权限，任何地方都可以访问，能继承到子类，修饰的类必须和文件名一致。

private：类访问权限，本类内部可以访问，不能继承到子类，不能修饰局部。

default：不写修饰符，默认情况下，包访问权限，本类内部可以访问，同包其他类也可以访问，同包可继承。

protected：子类访问权限，本类内部可以访问，同包其他类也可以访问，不同包的子类也可以访问，能继承到子类。

 

7.构造方法

用途：用于给对象中属性进行初始化。

特点：

方法名与类名相同，不写也默认有构造方法：类名(){}；

不用定义返回值类型，不能写void。

没有具体的返回值，不能写return。

 

多个构造函数是以重载的形式存在的。

例：

Person(){}

Person(int age,String name){}

Person(int age){}

Person(String name,int age){}

 

8.this关键字

 定义：表示本类对象的引用。

 用途：1，区分成员变量和局部变量重名的情况。

2，this( )语句,可以在构造方法之间进行调用，但必须放在第一行。

 

9.static关键字

  修饰符，用于修饰成员（成员变量和成员函数）。

静态和非静态的区别：

静态：是对象共享数据，随着类的加载而存在于方法区中，优先于对象存在，可以直接被类名调用和通过对象调用，随着类的消失而消失，生命周期较长，只能直接访问静态。

 

非静态：是对象特有数据，随着对象的建立而存在于堆内存中，只能通过对象调用，随着对象的消失而消失，生命周期较短，可以直接访问静态和非静态。

注意

静态方法只能直接访问静态。

静态方法中不能写this，super关键字。原因：静态优先于对象存在。

主函数是静态的。

 

10.main方法

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

 public：公共权限，被JVM调用

 static：类名调用，不需要对象

 void：没有返回值，但是方法体结尾默认有return

 main：规定好的名字，不能改

 String[]：有可能需要传入参数

args：字符串数组的名字,只要符合标识符的命名规则可以随便起。

 

11.帮助文档的制作

javadoc -d(指定文档存储的位置如果写.代表当前目录,也可以定义一个文件夹)

@author(提取作者内容)

@version(提取版本内容)

javadoc -d 指定的文件目录 -author -version ArrayTool.java

@param 参数名称//形式参数的变量名称@return函数运行完返回的数据

制作工具说明书:代码中有文档注释,用javadoc解析。

 javadoc -d . myAPI -author -versionArrayTool.java

 -d 后面跟目录, . 代表当前目录

 javadoc: 错误 - 找不到可以文档化的公共或受保护的类。

 改用public修饰一下即可

 

12.代码块

  局部代码块：写在方法中，限制变量的生命周期。

  构造代码块：对所有对象进行统一初始化，写在类中，每创建一次对象就执行                            一次，优先于构造方法。

  静态代码块：对类属性进行初始化，写在类中，加上static, 仅在类加载时运行一次。

执行顺序：按照顺序加载类静态成员，构造代码块，构造方法，非静态成员。

13.面向对象之继承

定义：把多个类中的相同属性和行为抽取到单独一个类中，这些类无需再定义这些属性和行为，只要继承那个类即可。

多个类可以称为子类，单独这个类称为父类或者超类。

子类与父类之间是所属(" is a " )关系。

子类可以直接访问父类中的非私有的属性和行为。

通过 extends 关键字让类与类之间产生继承关系。

例：class Ziextends Fu{}//子类Zi继承父类Fu

 

继承的体系结构：

就是对要描述的事物进行不断的向上抽取，就出现了体系结构。

顶层最共性功能，底层最多功能。

学习继承体系的时候，学习顶层类，建立底层类的对象。

 

继承的好处：

提高了代码的复用性，简化程序，扩展程序。

让类与类之间产生了关系，提供了多态的前提。

 

特点

java只支持单继承。

java支持多层继承(继承体系)，object是每个类的超类，实现树形结构。

 

14.super关键字

定义：表示父类对象的引用。

用途：1，区分父类和子类成员重名的情况。

2，调用父类的构造方法，但必须放在子类构造器第一行。

注意：

不写，子类构造方法第一行也默认有super( ){}

this( )和super()不能同时出现在同一个构造方法中,也不能出现在static中。

 

15.方法的重写(override)

子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

父类的私有方法不能被重写。

在子类重写方法中，继续使用被重写的方法可以通过super.方法名获取。

注意事项：

重写时，子类方法权限一定要大于等于父类方法权限

静态只能重写静态。

应用：

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，即沿袭了父类的功能，又定义了子类特有的内容。

 

方法重写和方法重载的区别：

重写：继承时子父类之间出现，重写方法和被重写方法要具有相同的方法名称、参数列表和返回值类型。

重载：同一个类中出现，重载方法和被重载方法要具有相同的方法名称和不同的参数列表。

16.final关键字

final是可以修饰类、方法、变量的修饰符。

final修饰的类不可以被继承。

final修饰的方法不可以被重写。

final修饰的变量是一个常量，只能被赋值一次。

（定义时赋值或构造方法赋值，默认值不算）

（变量名按常量名的命名规范书写）

内部类只能访问被final修饰的局部变量。

String类默认被final修饰。

 

17.面向对象之多态

定义：多态是指同一个实例可以具有多种形态。

好处：扩展了程序，提高了后期可维护性。

例：Class Ziextends Fu

Zi z = new Zi( );//创建一个子类对象

Fu f = new Zi( );//也可以用父类的引用句柄指向子类的对象，这就形成了多态

成员变量、静态成员变量、静态成员方法编译和运行都看父类。

只有非静态的成员方法，编译时看父类，运行时看子类。

多态时用对象调用子类特有非静态成员方法时要强转为子类类型引用。

例：Zi z = (Zi)f;//把f强转为子类类型引用

   JVM有动态绑定和静态绑定机制，多态中的机制，除了非静态的成员方法以外，JVM都会静态的绑定在父类的引用中，只有在运行非静态的成员方法，JVM会动态的绑定到子类的对象中。

 

18.抽象类

抽象方法：具有共性的内容，但说不清楚具体，没有方法体的方法，需用abstract修饰。

  例：abstract void method( );//抽象方法method

抽象类：包含抽象方法的类，不能被实例化，需用abstract修饰。

抽象类的用法：

     1，子类继承抽象类，重写所有抽象方法，建立子类的对象。若子类只重写部分抽象方法，或没重写抽象方法，子类还是一个抽象类。

     2，类名直接调用抽象类中的静态成员方法。

 

抽象类的特点：

抽象类有构造方法，第一行默认super( )，为了让子类实例化的时候使用。

抽象类中，可以没有抽象方法，但也不能创建这个类的对象。

 

abstract关键字不能和以下修饰符并存：

private，抽象就是为了子类重写，私有权限，子类无法继承和重写。

final，抽象就是为了子类重写，final修饰，方法不能被重写。

static，可以直接类名调用，但抽象方法没有方法体。

 

19.设计模式

  设计模式：人们用程序解决现实中问题的一种思维方法。Java中的所有设计模式，都是基于面向对象思想，一共有23种设计模式。

  总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

 

结构型模式，共七种：适配器模式、装饰模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

 

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

 

我们学习：模板方法模式，单例设计模式，适配器模式，装饰模式。

模板方法设计模式

  引用领域：如果你去实现一个功能，发现功能一部分清楚，一部分不清楚，不清楚的部分写成抽象方法，等待子类重写实现，就使用模板方法设计模式。

 

装饰设计模式

  出现意义，增强原有对象的功能。

 BufferedReader，BufferedWriter 装饰类，装饰流。

 BufferedReader出现的目的，增强原有流对象Reader的功能。

  装饰设计在Java的IO中，使用的最广泛。

  继承重写和装饰区别：

  装饰设计模式比继承重写的继承体系简单整洁，适合学，适合开发。

 

单例设计模式

保证一个类在内存中的对象唯一性。 

思想： 

1，  不让其他程序创建该类对象，私有化 本类构造函数。

2，  在本类中创建私有并静态的本类对象 。

3，对外提供公有并静态的方法，让其他程序获取这个对象。 

//饿汉式 

class Single{ 

private Single(){}              //私有化构造函数。 

private static Single s = new Single();    //创建私有并静态的本类对象。

public static Single getInstance(){ //定义公有并静态的方法，返回该对象。 

return s; 

} 

} 

//懒汉式:延迟加载方式。

class Single {

       //构造函数私有化

       privateSingle() {

       }

       //先不创建对象

       privatestatic Single s = null;

       //定义一个方法可以获取到该对象

       publicstatic Single getInstance() {

              // 方法被调用时才判断s是否为null，是否创建对象，起延时作用

              if (s == null)

                     //双重判断，加synchronized同步解决线程的安全问题

                     synchronized(Single.class) {

                            if (s == null)

                                   //创建一个本类对象

                                   s= new Single();

                     }

              return s;

       }

}

 

适配器模式

将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

 适用性

   1.你想使用一个已经存在的类，而它的接口不符合你的需求。

   2.你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作。

    3.（仅适用于对象Adapter）你想使用一些已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口。

 

20.接口

  当一个抽象类中，如果所有方法都是抽象方法，这个特殊的抽象类就可以定义为接口。

接口定义格式：interface接口名

例：interfaceRunner//定义了一个接口Runner

接口中的内容，固定格式：

   定义成员变量固定写法:  public static final 数据类型 变量名 = 值;

   定义成员方法固定格式： public abstract 返回值类型 方法名();

成员变量前默认：publicstatic final

成员方法前默认：publicabstract

 

接口的使用方式

  1，接口可以继承(extends)接口。

  2，抽象类实现(implements)接口，重写部分抽象方法。

  3，实现类(可称为子类)实现(implements)接口，重写全部抽象方法。

  例：class Cat implements Runner//定义了一个接口Runner的实现类Cat

 

接口的多实现：解决了java中只能单继承的问题。

  一个类可以同时继承一个类，实现多个接口。

例：

//定义一个Animal的子类Dog同时实现接口Runner1和接口Runner2

class Dogextends Animal implements Runner1，Runner2

 

接口和接口之间的关系

  类和类之间是继承关系，单继承

  类和接口之间是实现关系，多实现

  接口和接口之间是什么关系，继承关系，接口支持多继承

  面试题：问Java中支持多继承吗，类单继承，接口之间多继承

 

接口的特点

  接口是对外暴露的规则

  接口是程序的功能扩展

  接口降低了程序的耦合性。

 

接口和抽象类的区别

  定义上

    抽象类，可以有抽象，可以非抽象。

    接口，全部抽象。

 

  使用上

    抽象类，单继承，子类继承重写抽象方法。

    接口，多实现，实现类重写抽想法。

 

  继承体系上

    抽象类，继承体系最共性内容，是 is a关系

接口，是继承体系的扩展内容，是 like a关系

 

21.内部类

  将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

访问特点：

内部类可以直接访问外部类中的成员，包括私有成员。

而外部类要访问内部类中的成员必须要建立内部类的对象。

    class A{

        class B{}

     }

注意：非静态内部类中，不允许出现静态声明的

局部内部类

  将内部类写在外部类的方法中，不能使用成员修饰符(private和static)。

调用局部内部类方法，只能通过外部类的方法实现。

  局部内部类只能调用加final的局部变量，加final是为了解决生命周期问题。

 

成员内部类

在外部类里,在外部类的成员方法外定义。

直接调用内部类方法的三种格式

 

  第一种格式：内部类是非静态的，内部类的方法也是非静态

     外部类.内部类  变量 = new 外部类对象().new内部类对象()

 

  第二种格式：内部类，内部类的方法都是静态修饰

     静态类名调用，外部类.静态成员(内部类).内部类方法

 

  第三种格式：内部类是静态修饰，内部类的方法是非静态的

     外部类.内部类变量 = new 外部类.内部类对象()

 

匿名内部类：

定义没有名字的内部类，简化了内部类的写法，没有构造方法。

前提：内部类继承或实现一个外部类或者接口。

格式：

 new 接口或者父类(){

        重写抽象方法

};

简单理解：就是建立一个带内容的外部类或者接口的子类的匿名对象。

匿名内部类几种常用方式

1，继承式的匿名内部类

2，接口式(也可以叫实现式)的匿名内部类

3，参数式的匿名内部类

通常在使用方法是接口类型参数，并该接口中的方法只有一个时，可以将匿名内部类作为参数传递。

 

22.包package

给类提供多层命名空间。有包后，包名.类名

写在程序文件的第一行。

类名的全称的是  包名.类名。

包也是一种封装形式。

 

对类文件进行分类管理

Java中已经将自己的类，进行了分类管理。

常用的有：

java.lang核心包

java.util工具包

java.io输出输入流包

java.awt图形界面包

java.net网络程序包

java.lang.reflect反射包

对类提供了多层命名空间，有包后，全类名：包名.类名

定义包，必须是程序的第一行。

包也是一种封装形式。

定义包，使用关键字package 包名(全小写)。

带包编译，编译后，包自动生成。格式：javac -d . XXX.java

运行带包的类：java 包名.类名

 

导入包

 import 关键字，导入包，实际导入的是包中的类。

 import 包名.类名; 写在定义包的后面，定义类的前面。

 

jar包

java中的压缩包，和Windows中的压缩包意思几乎一样

好处：方便携带，方便使用，使用的数据库驱动程序，SSH源代码，都是以Jar压缩文件提供的。

通过jar.exe工具对jar的操作。

创建jar包

jar -cvf  mypack.jar 

查看jar包

jar -tvf  mypack.jar  

解压缩

jar -xvf  mypack.jar

自定义jar包的清单文件

jar –cvfm mypack.jar