黑马程序员-基础知识梳理3

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

继承：1.提高代码的复用性。

2.让类与类之间产生关机，也就有了多态的特性

注意:必须是类与类之间有所属关系才能继承。

java类只支持单继承，不支持多继承；一个儿子只有一个爹；

因为多继承容易带来安全隐患：因为父亲中定义了相同功能，但功能的内容不同时，子类对象不确定要运行那个。

java支持多层继承

如何使用继承体系中的功能？

先查阅父类的描述，父类中定义的是该体系的共性功能，通过了解共性功能知道该体系基本功能

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

因为1.有可能父类能创建对象

2.创建子类对象能使用更多功能，基本+特有功能

概括：查阅父类功能，创建子类对象使用功能

super 代表是父亲对象的引用

final:最终，作为一个修饰符

1.修饰类，变量，函数

2.被final修饰的类不能被继承

3.被final修饰的方法不能被复写

3.被final修饰的变量是一个常量，只能被赋值一次，既可以修饰成员变量，有可以修饰局部变量

常量的书写规范： 所有字母都大写，用_连接单词

重写：保留父类功能的定义，并重写功能内容；

注意事项：1，子类覆盖父类，必须保证子类权限大于父类的权限才能覆盖，否则编译失败

如果不加修饰符，就是默认权限， 默认权限大于private 小于public。

2，静态只能覆盖静态

区别：重载：只看同名函数参数列表

重写：子父类方法要一模一样；

构造函数：在对子类的对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认的第一行有一条隐式语句super();

super()：会访问父类中的空参数的构造函数；

方法区,又叫共享区或数据区.用来存放类中的方法,,共享数据.

子类实例化过程：总结：子类所有的构造函数，默认都会访问父类中的空参数构造函数

而类中的加载顺序为:静态变量——静态块——成员变量——构造方法——静态方法（方法需要调用才会执行）

当父类中没有空参数的构造函数，子类必须手动通过super或者this语句形式来指定要访问的构造函数。

子类中至少有一个构造函数访问父类中的构造函数。

为什么this super 不能用在同一个构造函数中？因为他们都要卸载构造函数的第一行。为什么要写在第一行？因为初始化动作要先做。

抽象类的特点：

1、抽象方法一定定义在抽象类中，

2、抽象方法和抽象类必须被abstract关键字修饰

3、抽象类不可以用new创建对象

4、抽象类中的抽象方法被使用，必须由子类复写所有抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是个抽象类。

抽象类中可以不定义抽象方法，只为了不让该类建立对象

模版方法：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，将不确定的部分暴露出去。

用final避免复写，用abstract避免被创建对象。

接口：可以认为是一个特殊的抽象类。

当抽象类的方法都是抽象的。那么该类可以通过接口形式表示

class 定义类

interface 定义接口

常量：public static final

方法：public abstract

接口的成员都是public

interface {

public static final int NUM=3;

public abstract void show();

}

接口是不能创建对象的，因为有抽象方法，需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化，否则子类只是个抽象类；

接口可以被类多实现，这是对多继承不支持的转换形式；

java支持多实现

接口之间的关系：extends

接口与接口之间存在多继承；

对象的多态性：

1，多态的体现;

父类的引用指向自己的子类对象

父类的引用可以接收自己的子类对象

2，多态的前提

必须类与类之间有关系，要么继承要么实现；

3，多态好处

提高程序扩展性

4，弊端

只能使用父类引用访问父类中的成员

类型提升向上转型

Animal a = new Cat();

a.eat();

向下转型：

Cat c =(cat)a;

c.catchMouse();

如果要调用cat特有方法，强制将父类的引用，转成子类类型，这叫向下转型；

不能将父类对象转成子类类型

父类的引用只想了子类的对象时，该类可以被提升，亦可以被强制转换。

多态自始自终都是子类对象在作者变化。

在多态中函数的特点：

在编译时期：参阅引用类型变量所属的类中是否存在调用的方法。如果有，编译通过，如果无，失败。

在运行期间：参阅对象所属类中是否有调用的方法。

总结：成员函数在多态调用时，编译看左边，运行看右边。

class 父亲 extends 儿子；

 左边父亲右边儿子 

在多态中成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属的类);

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边；

object类：是所有对象的直接或者间接的父亲；

该类中定义的肯定是所有对象所具备的功能；

object类中提供了对象是否相同的比较方法

只要沿袭父类中的功能，简历自己特有比较内容即可，这就是覆盖。

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

之所以可以直接访问外部类，是因为内部类中持有一个外部累的引用，格式：外部类名.this;

2，外部累要访问内部类，必须建立内部类对象，

内部类能被私有修饰

Outer.Inner in =new Outer().new Inner;

in.function();

Class Outer{

int x=3;

class Inner;

{

int x=4;

void function();

{

system.out.println(Outer.this.x);//输出的是3；

}

}

}

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

格式：外部类.内部类名 变量名= 外部类对象.内部类对象

Outer.Inner in=new Outer().new Inner();

当内部类在成员位置上，就可以被成员修饰符修饰

比如private将内部类在外部类进行封装

static：内部类就具备static的特性，当内部类被static修饰后，只能直接访问外部累中的static成员，出现了访问局限。

在外部其他类中如何直接访问static内部类的非静态成员呢？

new Outer.Inner().function();

在外部类的其他类中，如何直接访问static内部类的静态成员？

Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的，当外部累中的静态方法访问了内部类时，内部类也必须是静态的。

内部类定义在局部时：

1，不可以被成员修饰符修饰

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。不可以访问他所在的局部中的变量，只能访问被final修饰的局部变量

匿名内部类

1.匿名内部类是内部类的简写格式

2.定义前提：内部类必须继承一个类或者实现接口；

3.匿名内部类定义：new 父类或接口(){定义子类的内容}

4.其实匿名内部类就是一个匿名子类对象，可以理解为带内容的对象；

5.你们内部类中定义的方法最好不超过3个

异常：

问题分2中：1种严重的问题；1种非严重的问题

严重的：java通过error类进行描述，对于error，一般不编写针对性的代码进行处理

非严重的：java通过Exception 类进行描述，对于Exception可以使用针对性的方式进行处理

异常处理：

try｛需要被检测的代码｝catch（异常类 变量）｛处理异常的代码（处理方式）｝finally{一定会执行的代码}

JVM默认的异常处理机制，就是在调用printStackTrace方法，打印异常的跟踪信息。

throws Exception ：在功能上通过throws的关键字声明了该功能有可能会出现问题。

自定义异常：

class FushuException extends Exception{

}

当在函数内部出现了throw抛出异常对象，那么就给队形的处理动作。

要么在内部try catch

要么在函数上声明，让调用者处理

如何定义异常信息？

子类在构造时，将异常数据传递给父类通过super语句。可以直接通过getMessage方法获取自定义的异常信息

继承Exception的原因：

异常体系特点：异常类和异常对象都被抛出。他们具有可抛性，这个可抛性是Throwable这个体系中独有特点。

只有这个体系中的类和对象猜可以被throws和throw操作。

对多异常的处理：

对方生命了几个异常美酒对应几个catch块，不可以定义多余的catch块，如果catch块的异常出现继承关系，父类异常catch块放在最下面

throw和throws的区别：

throws使用在函数上；

throw使用在函数内；

throws后跟异常类，可以跟多个，用逗号隔开

throw后跟异常对象

Exception 中特殊的子类异常：RuntimeException如果在函数内抛出该异常，函数上可以不用声明编译一样通过。如果函数上声明了该异常，调用者可以不进行处理。编译者一样通过。如果该异常的发生，无法在继续进行运算，就让自定义异常继承RuntimeException

异常分为2种：编译时被检测到的异常；编译时不被检测到的异常（运行是异常，RuntimeException以及其子类）；