黑马程序员 java面向对象（二）

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

继承  extends

将共性内容提取出来单独描述 只要让学生和工人与单独描述的这个类有关系就可以了 
继承
·提高了代码的复用性
·让类于类之间产生了关系，有了这个关系才有了多态的特性

注意 ：

千万不要为了获取其他类的功能，简化代码而继承，必须是类与类之间有所属关系

java中只支持单继承 不支持多继承 
因为多继承能带来安全隐患
当多个父类中定义了相同功能但 功能内容不同时 子类不确定要运行哪一个
 但是java保持了这种机制，并用来另一种体现形式来完成表示多实现。
java支持多层继承。
也就是一个继承体系 
如何使用一个继承体系中的内容呢

想要使用体系 ，先查阅体系中父类的描述，因为父类中定义的是该体系中的共性功能，

通过了解共性功能就可以知道该体系的基本功能，那么这个体系已经可以基本使用。

那么在具体调用时要创建最子类的对象， 

为什么呢 一是因为有可能父类不能创建对象，如抽象类，二是创建子类对象可以使用更

多的功能 包括基本的也包括特有的。简单一句话就是查阅父类功能，创建子类对象使用功能。

聚合
球员是球队中的一个 球员跟球队的关系
 组合关系
组个比聚合联系更紧密 比如器官跟身体的关系
聚集关系
当继承出现后子父类之间的这些成员会出现什么变化呢

父类也叫超类
super 代表的是父类的引用，
子父类出现后 类成员的特点
类中的成员
1变量
2函数
3构造函数

1 变量
如果子父类中出现了非似有的成员变量时 子类要风闻本类中的
变量用this
子类要访问父类中的同名变量用super 
这俩词的使用几乎相同，this代表的是子类引用。
super代表的是父类的引用。

2  子父类中的函数
当子类出现和父类一模一样的函数时
当子类对象调用该函数，会运行子类函数的内容。
如同父类的函数被覆盖一样。
这种情况是函数的另一个特性：重写
当子类继承了父类，沿袭了父类的功能到子类中但是
子类随具备该功能，但是功能的内容却和父类不一致，这时
没有必要定义新功能 而是使用覆盖特性，保留父类的功能定义
并重写功能内容。

为了提高程序的扩展性 可以利用重写 扩展功能
不改动源码，继承之，在重写的方法里面添加功能
覆盖 
1 子类覆盖父类，必须保证子类权限大于父类权限，才可以
覆盖，否则编译失败
2 静态只能覆盖静态， 不能覆盖非静态，涉及加载内存的先后
默认权限介于似有和共有权限之间 

注意 ：
重载 只看同名函数的参数列表
重写 子父类方法要一模一样 包括返回值类型
子父类中的构造函数
在对子类对象进行初始化的时候 父类的构造函数也回运行 那是因为子类的构造函数 第一行有一条隐式的语句 super();
这个super（） 语句会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super();

为什么子类中必然会访问到父类中的构造函数呢 
当父类中的构造函数时隐式的时 子类中必须把super显示出来。

因为父类中的数据子类可以直接获取，所以子类对象在建立时候，需要先查询父类如何对这些数据进行初始化的，所以子

类在对象初始化的时候，要先访问以下父类中的构造函数

若果要访问父类中指定的构造函数，可以手动动super方式来指定。

注意 super语句一定定义在子类构造函数的第一行。

构造函数里面要么有this 要么有super 

结论  
子类的所有的构造函数默认都会访问父类中空参数的构造函数 因为子类每一个构造函数内的第一行都会有一个隐式的super函数。

当父类中没有空参数的构造函数时子类鼻血手动通过super或者this语句形式来指定要访问的构造函数 当然子类的构造函数第一行

也可以手动的指定this语句来访问本类的构造函数，子类中至少会有一个构造函数会访问父类的构造函数 

为什么this和super不能再同一行 
因为都是要写在第一行，为什么第一行 因为初始化动作要先做

final 关键字 
最终，作为一个修饰符 
1 可以修饰类 变量，函数，
2 被final修饰的类 不可以被继承 
为了避免被继承 被子类复写功能
3 被final修饰的方法不可以被复写

4 被final修饰的变量时一个常量 只能赋值一次，既可以修饰成员变量有可以修饰局部变量。当在描述事物时

一些数据的出现值是固定的，那么这是为了增强阅读星，都给这些值起个名字，方便阅读，而这个值不需要改

变所以加上final修饰 作为常量，常量的书写范围所有字母都大写，如果由多个单词组成，单词间通过下划线 _ 链接

5 内部类 定义在类中的局部位置时，只能访问该局部被final修饰的局部变量 
抽象类 
当多个类中出现相同的共能但是功能出题不同，这时可以进行向上抽取，这时只抽取功能定义，而不抽取主体 
修饰 abstract 抽象方法必须存在于抽象类中 
抽象类的特点，
1 抽象方法一定在抽象类中
2抽象方法和抽象类都必须被abstract关键字修饰

3抽象类不可以用new创建对象，因为调用抽象方法没意义，抽象类中的方法要被使用必须由子类复写其所有的抽象方

法后 建立子类对象调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类  

抽象类与一般类没有太大的不同 该如何描述事物就如何描述事物，只不过，该事物出现了一些看不懂的东西，这些不确

定的部分也是该事物的苟能，需要明确出来，但是无法定义主体。

抽象类比一般类多了抽象函数，就是在类中可以定义抽象方法，抽象类不可以实例化 
特殊，抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
模板方法模式
 

在定义功能的时候 功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将

不确定的部分暴露出去，由子类完成 

接口 
接口 初期理解可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的 那么该类可以通过接口的形式表示
class用于定义类
interface 用于定义接口 。 
接口定义时格式特点
1 接口冲常见定义，常量， 抽象方法
2 接口中的成员都有固定的修饰符 
常量 public static final 
方法 public abstract 
记住 接口中的成员都是public的  
接口与接口之间是实现关系
implements
接口是不能创建抽象类的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类
接口可以被类多实现 也是对多继承不支持的转换形式，java支持多实现。
一个类在继承一个类还能实现多个接口 
接口与接口之间是继承关系  还存在多继承 
类与接口是实现
类与类是继承
找到组织了 继承
组织里面干点副业 扩展了 

组织外面 接口来实现   

多态 
可以理解为 事物存在的多种体现形态 
1 多态的基本体现 
Animal c = new Cat();
多态在程序中的表现，父类的引用指向了自己的子类对象
父类的引用也可以接受子类的对象

2 多态的前提
必须是类于类之间有关系 要么是继承要么是实现；存在覆盖

3 多态的好处
大大的提高了程序的扩展性
弊端 
提高了扩展性  但是 只能使用父类的引用访问父类中的成员 

4 多态的应用

animal a = new cat();//向上转型 

cat c =(cat)a;// 强制将父类的引用转成子类类型 
千万不要出现这种情况 就是父类对象转成子类类型。
animal a = new animal(); cat c=（cat）a;
多态自始至终都是在子类做着变化
如果 a 是 cat 型的  if(a instanceof cat)
多态使用的注意事项
Fu f = new Zi()
f.method1;
f2.method2;
这个的运行结果是子类中的 1 2 俩方法，这个是父类指向了子类，但是运行的其实是子类的对象，相当于毕老师穿了毕姥爷的衣服但是讲的还是java
---
父类指向子类对象的时候
注意 

在多态中 非静态  成员函数的特点：
在编译时期参与应用性变量所属的类中是否有调用的方法，如果有编译通过，如果没有编译失败，在运行时期 参阅的是对象所属的类中是否有调用的方法

。（上题中编译的时候看父类是否有 1 2 3 方法都有则编译通过，有一个没有则不通过， 运行的时候是运行子类中的对应方法0）
简单总结就是，成员函数在多态调用时 编译看左边，运行看右边。
涉及到面试的环节
在多态中成员变量的特点，无论编译或者运行都参考左边（引用型变量所属的类型）
在多态中静态成员函数的特点，无论是编译还是巡行，都参考左边。

object

是所有对象的直接或者间接父类，传说中的上帝该类中定义的是所有对象都具备的功能。
     
object类中已经提供了对对象是否相同的比较方法，如果自定义类中也有比较相同的功能，

没有必要重新定义，只要沿袭父类中的功能，建立自己特有的比较内容即可，这就是覆盖。 
复写的时候如果用到了对象中的特殊句的话 要注意转型 向下转

内部类

常见情况 
 当你使用的方法中所使用的参数类型是一个借口类型时该借口中的方法不超过三个可以定义一个匿名内部类，

把该类做为参数传进去也行。（在 innerClassTest里面）
 内部类访问规则
1 内部类可以直接访问外部类中的成员，包括私有。这是因为内部类中持有了一个外部类的引用，格式 外部类名.this.  ;
2 外部类要访问内部类，必须要建立内部类对象。

访问格式，当内部类定义在外部类的成员上位置上，而且非私有，可以再外部其他类中。可以直接建立内部类对象格式

是 外部类名.内部类名 变量名 = 外部类对象.内部类对象；{Outer.Inner in = new Outer().new Inner;} 

3 当内部类在成员位置上，就可以被成员修饰符所修饰。
比如，private 将内部类在外部类中进行封装。
static 内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中static的成员，出现了访问局限。
在外部其他类中如何直接访问非静态内部类呢？
可以通过这种形式访问
new Outer.Inner().function();
在外部其他类中如何直接访静态内部类呢？这样 
Outer.Inner().function();
注意 当内部类中定义了静态成员，该内部类必须是静态的。
当外部类中的静态方法，访问内部类时，内部类也必须是静态的。

 内部类定义的原则
 当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在使用外部事物的内容
 匿名内部类 
静态是成员修饰符，不能定义在局部。
【非静态，没对象，不运行 】
内部类定义在局部时 
1 不能被成员修饰
2 可以直接访问外部类中的成员，因为还持有外部类中的引用。 但是不可以访问它所在的局部中的变量。

只能访问被final修饰的局部变量。
1 匿名内部类其实就是内部类的简写格式。
2定义匿名内部类的前提，内部类必须继承一个类或者实现接口
3 匿名内部类的格式 
new 父类或者接口(){定义子类的内容}
4 其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖可以理解为带内容的对象 
匿名对象只能对方法调用一次
5 匿名内部类中调用的方法最好不要超过三个
没有父类，也没有接口能用内部类不？
能

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

finally{一定要执行的语句}


3 对捕获的异常进行常见方法操作。
String getMessage()获取一场信息 
在函数上声明异常，便于提高安全性，让调用出进行处理，不处理编译失败。
对多异常的处理
1 声明异常的时候建议声明更为具体的异常这样处理的更具体。
2 对方声明几个异常，就对应有几个catch块，不要定义多余的catch块
如果多个catch块中的一场出现继承关系，父类一场catch块放在下面
建议在进行catch处理时，catch中一定要定有具体飞处理方式，不要简单一句e.ptintStackTrace();也不要简单的就书写一条输出语句。
自定义异常 
什么是自定义异常？

  因为项目中会出现特有的问题，而这些问题并未被java所描述，并封装对象，所以对这些特有的问题，可以按照java的对问题封装的思想，

将特有的问题，进行定义的一场封装，
当在函数内部出现了throw抛出异常对象，那么就必须要给对应的处理动作，要么在内部try catch 处理，要么在函数上声明让调用者处理
函数内出现异常，主函数一般要声明。
如何定义异常信息？
父类中已经把异常信息的操作都完成了，所以子类在构造时将异常信息传递给父类，通过super语句那么就可以直接通过getMassage信息获取一场信息了。 
自定义异常
必须是自定义类继承exception
继承exption的原因，
异常体系内有一个特点，异常类和异常对象都要抛出。他们都具备可抛性，这个可抛性是throwable这个体系中独有特点。只有这个体系中的成员才能被throw和throws这两个关键字操作。
throw 使用在函数内
throws使用在函数上
throws后面跟的一场类可以跟多个，用逗号隔开，
throw后面跟的是异常对象。
exception中有一个特殊的子类异常runtimeexception 运行时异常，如果在函数内容抛出该异常，函数上可以不用声明，编译一样通过，如果在函数上声明了异常，调用者可以不用进行处理，编译一样通过。
之所以不用在函数上声明，是因为不需要让调用者处理，当该异常发生的时候，希望程序停止，因为在运行时，出现了无法继续运算的情况，希望停止程序后，对代码进行修正。
自定义异常是，如果该异常的发生，无法继续进行运算，就让自定义异常继承runtimeexception 
对于异常分两种 
第一是编译时被检测的一场 
第二是编译时不被检测的异常 （运行时异常）runtimeException以及子类。
throw 单独出现的时候它下面的语句 执行不到的

异常 finally 
这里面存在的是一定被执行的句子 
当你程序里面有必须要执行的语句的时候可以用try和 finally来执行
finally啥用呢，
比如断开数据库的链接。对资源进行关闭
finally代码块，定义一定执行的代码，通常用于关闭资源。 
try 可以单独跟catch在一起，
try 可以跟catch 和finally在一起，
try 可以和finally  在一起
【问题再内部被解决了，就可以不用再函数上声明】
啥叫问题被解决， 有catch抓住就行。
注意一点，catch是用于处理异常，如果没有catch就代表异常没有处理过，如果该异常是检测异常，那么必须声明。

异常 覆盖时异常
异常在子类父类覆盖中的体现。
1子类在覆盖父类时 如果父类的方法，抛出异常，那么子类的覆盖方法只能抛出父类的异常或该异常的子类，或者不抛。
2如果父类方法抛出多个异常，那么子类在覆盖该方法时，只能抛出父类异常的子集。
3 如果父类湖综合接口的方法中，没有异常抛出，那么子类在覆盖方法时 也不可以抛出异常，如果子类方法发生了异常，就必须要try处理，绝对不能抛
A是父异常 B子异常 C是其他异常
如果在子类中出现了一个C异常，那必须try
异常的产生能让正常流程和问题处理代码相分离。
异常 总结 
异常是什么 
是对问题的描述 将问题进行对象的封装
异常体系
throwable
  |--error
  |--Exception
     |--RuntimeException
异常体系的特点，异常体系中所有类以及建立的对象都具有可抛性，也就是说可以被throw和throws关键字操作，只有异常体系具备这个特点
throw和throws的用法
throw定义在函数内，用于抛出异常对象。
throws定义在函数上，用于抛出异常类，可以抛出多个用逗号隔开。
当函数内容有throw抛出异常对象，并未进行try处理，必须要在函数上声明，否则编译失败，注意runtimeexception除外，也就是函数内如果抛出的runtimeexception异常，函数上可以不用声明。如果函数声明了异常，调用者需要进行处理，处理方式可以抛出可以try
异常有两种
编译时被检测异常
 该异常在编译时，如果没有处理（没有抛也没有try）编译失败 该异常被标示，代表可以被处理
运行时异常（编译时不检测）
 在编译时不需要处理，编译器不检查，该异常发生，建议不处理，让程序停止，让代码进行修正。
异常语句
try
{需要被检测的代码}
catch（）{处理异常的代码}
finally
{一定会执行的代码}
三种结合方式 
1try
{}
catch（）{}
finally
{}
2 try
{}
catch（）{}
3
try
{}
finally
{}
注意finally中通常定义的是 关闭资源代码，因为资源必须要释放。
finally只有一种情况不会执行，当执行到system.exit(0);finally不会执行
自定义异常
  定义类继承exception或者runtimeexception
1 为了让该自定义类具备可抛性
2让该类具备操作异常的共性方法
当要定义自定义异常的信息时，可以使用父类已经定义好的功能。
将异常信息传递给父类的构造函数 
自定义异常是 按照java的面向对象思想将程序中出现的特有问题进行封装。
异常的好处
1 将问题进行封装，
3 将正常流程代码和问题处理代码分离，方便于阅读
异常的处理原则 
1 处理方式有两种，try或者trowes
2 调用到抛出异常的功能时，如果抛出几个，就处理几个。 一个try对应多个catch。
3多个catch父类的catch放到最下面
4 catch需要定义针对性的处理放肆，不要简单行医输出语句，也不要不写
当捕获到异常本功能处理不了时，可以继续在catch中抛出
try{
 throw new Aexception();
}
catch (AException e)
{
  throw e ;
 }
如果该异常处理不了，但并不属于该功能出现的异常，可以讲异常转换后再抛出，和该功能相关的异常
或者异常可以处理，当需要将异常产生的和本功能相关的问题提供出去，让调用者知道并处理，也可以讲捕获异常处理后，转换新异常抛出
异常的 注意事项
 在子父类覆盖时
1 子类抛出的异常必须是父类的异常的子类或者子类集
2 如果父类或者接口没有异常抛出时，子类覆盖出现一场，只能try不能抛。
 
this 关键字的含义，final有哪些特点
this 代表本类对象，哪个对象调用this所在函数，this就代表哪个对象。
final
1 修饰类，变量（成员变量，静态变量，局部变量），函数。
2修饰的类不可以被继承，
3修饰的函数不可以被覆盖
4修饰的变量时一个常量，只能赋值一次
5 内部类只能访问局部中的final类型的变量
千万记住 throw单独存在的时候下面一定不要有语句 执行不到
包 总结
包与包之间进行访问，被访问的包中的类以及类中的成员，需要public修饰
 不同包中的子类可以访问父类中被protected权限修饰的成员。
 包与包之间能够使用的权限有两种， public 和protectd
权限问题
public protectd default private 
同一个类中
都可以
同一个包中
private不行其他三个都行
子类
public protectd 可以
不同包中
public可以 其他的不可以
一个java文件中不可以同时出现两个共有（public）类或者接口
为了简化类名的书写，使用一个关键字 import
import导入的是包中的类 
再用的时候不同包中有同名类必须得加上包名
建立包名不要重复，可以使用url来完成定义，url是唯一的
　-------android培训 、java培训、期待与您交流！ ----------