黑马程序员-面向对象下

----------------------android培训、java培训、期待与您交流！
----------------------
继承是面向对象三大特征之一，也是实现软件复用的重要手段。java的继承具有但继承的特点，每个子类只有一个直接父类。java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类被称为父类，有的也称为基类、超类。父类和子类的关系是一种一般和特殊的关系。例如水果和苹果的关系，苹果继承了水果，苹果是水果的子类，则苹果是一种特殊的水果。

继承的特点：1.提高代码复用性；2.继承让类与类之间产生了关系，有了这个关系，才有了多态的特性。注意：千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系才可以继承。所属关系 is a。java语言中只支持单继承，不支持多继承。因为多继承容易带来安全隐患：当多个父类中定义了相同功能，但功能内容不同时，子类对象不确定要运行哪一个。但是java保留了这种机制，并用另一种体现形式来完成表示，多实现。java支持多层继承。也就是一个继承体系。如何使用一个继承体系中的功能呢？想要使用体系，先查阅体系父类的描述，因为父类中定义的是该体系中的共性功能，通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。那么在具体调用时，要创建最子类的的对象，为什么呢？一是因为有可能父类不能创建对象（抽象类）；二是创建子类对象可以使用更多的功能，包括基本的，也包括特有的。

//水果类

class Fruit

{

public double weight;

public void info()

{

System.out.println("我是一个水果！重"+weight+"g!");

}

}

//苹果类

class Apple extends Fruit

{

public static void main(String[] args)

{

//创建Apple的对象

Apple a=new Apple();

//Apple对象没有weight属性

//因为Apple的父类对象有weight属性，也可以访问Apple对象的属性

a.weight = 56;

//调用Apple对象的info方法

a.info();

}

}

------------------------------------------

super关键字：超级，当子类与父类成员名相同时在子类中访问父类的成员。1.变量：如果子父类中出现非私有的同名成员变量时，子类要冯文本类的变量，用this。子类要访问父类中的同名变量，用super。super和this的使用几乎一致，this代表的是本类对象的引用，super代表的是父类对象的引用。当子类出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样，这种情况是函数的另一特性：重写（覆盖）。当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。注意：1.子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则便以失败。2.静态只能覆盖静态。记住大家：重载只看同名函数的参数列表。重写：字父类方法要一模一样。3.子父类中的构造函数：在对子类对象进行初始化时，父类的构造函数也会运行，那是因为子类的构造函数默认第一行有一条隐式的语句
super()，super()会访问父类中空参数的构造函数。，而且子类中所有的构造函数默认第一行都是super()。为什么子类一定要访问父类中的构造函数？因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类对象初始化时，要先放我那父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。super语句一定要定义在子类构造函数的第一行。子类的实例化过程：结论：子类所有的构造函数默认都会访问父类中空参数的构造函数，因为子类每一个构造函数的第一行都有一句隐式的super（）；当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

------------------------------------------

final 关键字：最终，作为一个修饰符。1.可以修饰类，函数，变量。2.被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。3.被final修饰的方法不可以被复写。4.被final修饰的变量是一个常量，只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。当在描述事物时一些数据的出现只是固定的，那么为了增强阅读性，都给这些值起个名字，方便于阅读，而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。5.内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。修饰类：public，final，空。

------------------------------------------

抽象abstract：看不懂的。抽象类的特点：1.抽象方法一定定义在抽象类中。2.抽象方法都必须被abstract关键字修饰。3.抽象类不可以用new创建对象，因为调用抽象方法没有意义。4.抽象类中的抽象方法要被使用，必须有子类复写其所有的抽象方法后，建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。抽象类和一般类没有太大的不同，该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现，但是无法定义主体，通过抽象方法表示。抽象类比一般类多个抽象函数，就是在类中可以定义抽象方法，抽象类不可以实例化。特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

------------------------------------------

接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

class用于定义类，interface用于定义接口。接口定义时格式特点：1.接口常见定义：常量，抽象方法。2.接口中的成员都有固定修饰符。常量：public static final 方法：public abstract 。记住：接口中的成员都是 public的。类与接口是实现关系：implements。接口：是不可以创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则子类是一个抽象类。接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现。java中只有在接口与接口之间存在多继承。接口降级了耦合性。

------------------------------------------

多态： java引用变量有两种类型：一个是编译时的类型，一个是运行时的类型，编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态。其实多态就是父类的对象指向子类的对象，就是多态。也可以理解为事物存在的多种体现形态。

1.多态的基本体现：父类的引用指向了自己的子类对象。父类的引用也可以接收自己的子类对象。

2.多态的前提：必须是类与类之间有关系，要么继承，要么实现。通常还有一个前提：存在覆盖。

3.多态的好处：多态的出现大大的提高了程序的扩展性。

4.多态的弊端：提高了扩展性，但只能使用父类的引用访问父类中的成员。

5.多态的应用：如Fruit a=new Apple();

6.多态的出现代码中的特点（多态使用的注意事项）

Animal a=new Cat()//类型提升，向上转型。调用子类的特有方法，如何操作？强制将父类的引用转成子类类型。向下转型:Cat c=(Cat)a;千万不要出现这样的操作，就是将父类对象转成子类类型(Animal a=new Animal(); Cat c=(Cat)a)。我们能转换的是父类引用指向了自己的子类对象时，该引用可以被提升，也可以被强制转换。多态自始至终都是子类对象在做着变化。判断所属类型关键字：instanceof：if(a instanceof Cat)类型有限。Fu f=new zi();
f.method_3(子类特有方法)编译失败。在多态中成员函数的特点 ：在编译时期：参阅引用型变量多数的类中是否有调用的方法，如果有，编译通过，如果没有便以失败。在运行时期：参阅的是对象所属的类中是否有调用的方法。简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。在多态中成员变量的特点：无论编译和运行都参考左边（引用型变量所属的类）。在多态中静态函数的特点：无论编译和运行，都参考左边。只要引用在，就找引用型变量所属类中的内容。静态方法一进内存就已经绑定在该方法所属的类上了。

------------------------------------------

异常：就是程序在运行时出现的不正常情况。异常的由来：问题也是现实生活中一个具体的事物，也可以通过java的类的形式进行描述，并封装对象，其实就是java对不正常情况进行描述后的对象体现。对于问题的划分：两种：一种是严重的问题，一种是非严重的。严重的，java通过Error类进行描述。对于error一般不编写针对性的代码对其进行处理。对于非严重的，java通过Exception类进行描述。对于Exception可以使用针对性的处理方式进行处理。无论Error或者Exception都具有一些共性内容。比如：不正常情况的信息，引发原因等。

2.异常的处理。java提供了特有的语句进行处理。格式：

try

{ 需要被检测的代码 }

catch（异常类 变量）

{ 处理异常的代码;（处理方式）}

finally

{ 一定会执行的语句；}

3.对捕获到的异常对象进行常见方法操作：

String getMessage()：获取异常的信息。

printStackTrace();异常名称，异常信息，已成出现的位置。

class Dome

{

int div(int a,int b)throws Exception //在功能上通过天后挖的关键字声明了该功能有可能会出席那问题。

{

return a/b;

}

}

对多异常的处理。

1.声明异常时，建议声明更为具体的声明，这样处理的可以更具体。

2.对方声明几个异常，就对应几个catch块。不要定义多余的catch块。如果多个catch块中的异常出现继承关系，父类异常catch块放在最下面。建议在进行catch处理时，catch中一定要定义具体的处理方式，不要简单的定义一句 e.printStackTrace(),也不要简单的就书写一条输出语句。

------------------------------------------

自定义异常：当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作，要么在内部try catch处理。

一般情况在函数内出现异常，函数上需要声明。自定义异常并没有定义异常信息。如何定义异常信息呢？因为父类中已经把异常信息的操作都完成了，所以子类只要在构造时，将异常信息传递给父类通过super语句，那么就可以直接通过getMessage方法获取自定义的异常信息。自定义异常：必须是自定义类继承Exception。为什么要继承Exception：异常体系有一个特点：因为异常类和异常对象都需要被抛出。他们都具备可抛性，这个可抛性是Throwable这个体系中独有的特点。只有这个体系中的类和对象才可以被throws和throw操作。throws和throw的区别：throws使用在函数上。throw使用在函数内。

throws后面跟的是异常类，可以跟多个，用逗号隔开。throw后面跟的是异常对象。

Exception中有一个特殊的子类异常RuntimeException 运行时异常。如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过。如果在函数上声明了该异常，调用者可以不用进行处理，编译一样通过。之所以不用在函数上声明，是因为不需要让调用者处理，当该异常发生，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。 自定义异常时：如果该异常的发生，无法再继续进行运算时，就让自定义异常继承RuntimeException。对于异常分两种：

1.编译时被检测的异常。

2.编译是不被检测的异常（运行时的异常，RuntimeException以及其子类）

finally代码块 中存放的是一定会被执行的代码。通常用于关闭资源。记住一点：catch是用于处理异常，如果没有catch就代表异常没有被处理过，如果该异常是检测异常，必须声明。

异常在子父类覆盖中的体现：

1.子类在覆盖父类时，如果父类的方法抛出异常，那么子类的覆盖方法只能抛出父类的异常或者该异常的子类或者不抛。

2.如果父类方法抛出多个异常，那么子类在覆盖该方法时只能抛出父类异常的子集。

3.如果父类或者接口的方法中没有异常抛出，那么子类在覆盖方法时，也不可以抛出异常。如果子类方法发生了异常，就必须要进行try处理，绝对不能抛。（重要）

------------------------------------------

异常总结：

异常是什么？是对问题的描述，将问题进行对象的封装。

------------------------------------------

异常体系：

Throwable

|--Error

|--Exception

|--RuntimeException

异常体系的特点：异常体系中的所有类以及建立的对象都具备可抛性。也就是说可以被throw和throws关键字多操作。只有异常体系具备这个特点。

------------------------------------------

throw和throws的用法：

throw定义在函数内，用于抛出异常对象。

throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。

当函数内容有throw抛出异常对象，并进行try处理，必须在函数上声明，否则便以失败。注意，RuntimeException除外，也就是说，函数内如果抛出的是RuntimeException异常，函数上可以不用声明。

------------------------------------------

如果函数声明了异常，调用者需要进行处理，处理方法可以throws也可以try。

异常有两种：1.编译时被检测异常。该异常在编译时，如果没有处理（没有抛也没有try），编译失败。该异常被标识，代表着异常可以被处理。

2.运行时异常（编译不检测）。在编译时，不需要处理，编译器不停止。该异常发生，建议不处理，让程序停止，需要对代码进行修正。

异常处理的语句：

try

{

需要被检测的代码；

}

catch

{

处理异常的代码；

}

finally

{

一定会执行的代码；

}

注意 1.finaly中定义的通常是 关闭资源代码，因为资源必须要释放。2.finally只有一种情况不会执行，当执行到System.exit(0)时，finally不会执行。

------------------------------------------

自定义异常：定义类继承Exception或者RuntimeException。

1.为了让自定义类具备可抛性。2.让该类具备操作异常的共性方法。

当要定义自定义异常的信息时，可以使用父类已经定义好的功能。将异常信息传递给父类的构造函数。

class MyException extends Exception

{

MyException(String message)

{

super(message);

}

}

自定义异常：按照java的面向对象思想，将程序中出现的特有问题进行封装。

------------------------------------------

异常的好处：

1.将问题进行封装。2.见正常流程代码和为题处理代码相分离，方便阅读。

异常处理原则：

1.处理方式有两种：try或者throws。2.调用到抛出异常的功能时，抛出几个，就处理几个。一个try对应多个catch。

3.多个catch，父类的catch放到最下面。

3.catch内，需要定义针对性的处理方式，不要简单的定义printStackTrace，输出语句，也不要写。当捕获到的异常，本功能处理不了时，可以积雪catch中抛出。

try

{

throw new AException();

}

catch

{

throw e;

}

如果该异常处理不了，但并不属于该功能出现的异常，可以将异常转换后，在抛出和该功能相关的异常。

或者异常可以处理，当需要将异常产生的本功能相关的问题提供出去，让调用者知道，并处理，也可以将捕获异常处理后，转换新的异常。

try

{

throw new AException();

}

catch

{

//对异常AException处理。

rhrow new BException();

}

异常的注意事项：

在子父类覆盖时;

1.子类抛出的异常必须是父类的异常的子类或者子集。

2.如果父类或者接口没有异常抛出时，子类覆盖出现异常，只能try不能抛。

----------------------------------

包：package。

总结：包与包之间进行访问被访问的包中的类以及类中的成员需要被public修饰。不同包中的子类还可以直接访问父类中被protected权限修饰的成员。

public protected default private

同一个类中 可以 可以 可以 可以

同一个包中 可以 可以 可以 不可以

子类 可以 可以 不可以 不可以

不通报中 可以 不可以 不可以 不可以

----------------------
android培训、java培训、期待与您交流！ ----------------------
详细请查看：http://edu.csdn.net/heima