------- android培训、java培训、期待与您交流！ ----------
继承
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继那个类即可
多个类可以称为子类，单独这个类称为父类或者超类
子类可以直接访问父类中的非私有的属性和行为
过 extends 关键字让类与类之间产生继承关系
好处：
1：提高了代码的复用性。
2：让类与类之间产生了关系，提供了另一个特征多态的前提
- super和this的用法相像
- this代表本类对象的引用
- super代表父类的内存空间引用
super()和this()不可以同时出现的构造函数中：两个语句只能有一个定义在第一行，因为super()或者this()都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成
继承的使用：
- 当子父类出现同名成员时，可以用super进行区分
- 子类要调用父类构造函数时，可以使用super语句
不要仅为了获取其他类中某个功能而去继承判断所属关系，如果继承后，被继承的类中的功能，都可以被该子类所具备，那么继承成立；如果不是，不可以继承函数覆盖(Override)子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写； 父类中的私有方法不可以被覆盖在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取使用注意事项：
1：子类覆盖父类时，必须要保证，子类方法的权限必须大于等于父类方法权限可以实现继承。否则，编译失败
2：覆盖时，要么都静态，要么都不静态。 (静态只能覆盖静态，或者被静态覆盖)
覆盖的应用：当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容
class Tel { void show() { System.out.println("number"); } } class NewTel extends Tel { void show() { //System.out.println("number"); super.show();//复写父类方法 System.out.println("name"); System.out.println("pic"); } }一个对象实例化过程：
Person p = new Person();
1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
并会先加载Person的父类(如果有直接的父类的情况下).
2，在堆内存中的开辟空间，分配地址。
3，并在对象空间中，对对象中的属性进行默认初始化。
4，调用对应的构造函数进行初始化。
5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6，父类初始化完毕后，在对子类的属性进行显示初始化。
7，在进行子类构造函数的特定初始化。
8，初始化完毕后，将地址值赋值给引用变量.
finall关键字：final修饰的类不可以被继承
final修饰的方法不可以被覆盖
final修饰的变量是一个常量，只能被赋值一次
内部类只能访问被final修饰的局部变量
抽象类
在不断抽取过程中，将共性内容中的方法声明抽取，但是方法不一样，没有抽取，这时抽取到的方法，并不具体，需要被指定关键字abstract所标示，声明为抽象方法
抽象类特定：
1： 抽象方法所在类一定要标示为抽象类，也就是说该类需要被abstract关键字所修饰
2： 抽象方法只有方法声明，没有方法体，定义在抽象类中。
格式：修饰符abstract返回值类型 函数名(参数列表);
3：抽象类不可以被实例化，也就是不可以用new创建对象。原因如下：
抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例（如：犬科是一个抽象的概念，真正存在的是狼和狗),而且抽象类即使创建了对象，调用抽象方法也没有意义。
抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类
抽象关键字abstract不可和final 、 private 、 static共存
模板方法设计模式：
当功能内部一部分实现时确定，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现
abstract class GetTime{ public final void getTime(){ //此功能如果不需要复写，可加final限定 long start = System.currentTimeMillis(); code(); //不确定的功能部分，提取出来，通过抽象方法实现 long end = System.currentTimeMillis(); System.out.println("毫秒是："+(end-start)); } public abstract void code(); //抽象不确定的功能，让子类复写实现 } class SubDemo extends GetTime{ public void code(){ //子类复写功能方法 for(int y=0; y<1000; y++){ System.out.println("y"); } } }接口（interface）
接口中包含的成员，最常见的有全局常量、抽象方法。
接口的出现将“多继承”通过另一种形式体现出来，即“多实现”
注意：接口中的成员都有固定的修饰符。全为public
成员变量：public static final
成员方法：public abstract
interface Inter{
publicstatic final int x = 3;
publicabstract void show();
}
类与类之间存在着继承关系，类与接口中间存在的是实现关系。
继承用extends ；实现用implements
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
接口与接口之间可以有继承关系
接口与抽象类比较：
共性 都是不断抽取出来的抽象的概念
区别 抽象类体现继承关系，一个类只能单继承
接口体现实现关系，一个类可以多实现
区别 抽象类是继承，是 "is a "关系
接口是实现，是 "like a"关系
区别 抽象类中可以定义非抽象方法，供子类直接使用
接口的方法都是抽象，接口中的成员都有固定修饰符
多态
函数本身就具备多态性，某一种事物有不同的具体的体现
体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = newCat(); 向上转型。将子类型隐藏。就不用使用子类的特有方法
多态的好处：提高了程序的扩展性
多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)
多态的前提：
1：必须要有关系，比如继承、或者实现。
2：通常会有覆盖操作
以前是创建对象并指挥对象做事情。有了多态以后，我们可以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即通过操作父类或接口实现
内部类
将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）
如果A类需要直接访问B类中的成员，而B类又需要建立A类的对象。这时,为了方便设计和访问，直接将A类定义在B类中。就可以了。A类就称为内部类
访问特点：
内部类可以直接访问外部类中的成员，包括私有成员；而外部类要访问内部类中的成员必须要建立内部类的对象
class Outer{
int a = 4;
class Inner {
void show(){
System.out.println("innershow run "+num);
}
}
public void method(){
Inner in = newInner();//创建内部类的对象
in.show();//调用内部类的方法
}
}
内部类定义在成员位置上
可以被private static成员修饰符修饰
被static修饰的内部类只能访问外部类中的静态成员
内部类定义在局部位置上
也可以直接访问外部类中的成员
同时可以访问所在局部中的局部变量，但必须是被final修饰的
匿名内部类：没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。
定义前提：内部类必须继承一个类或者实现接口
格式：new外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}
使用场景：
当函数的参数是接口类型引用时，如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递
其实就是在创建匿名内部类时，该类中的封装的方法不要过多，最好两个或者两个以内异常
就是不正常。程序在运行时出现的不正常情况。其实就是程序中出现的问题。这个问题按照面向对象思想进行描述，并封装成对象
--------java.lang.Throwable：
Throwable：可抛出的
Throwable中的方法：
getMessage() ：获取异常信息，返回字符串
toString() ：获取异常类名和异常信息，返回字符串
printStackTrace() ：获取异常类名和异常信息，以及异常出现在程序中的位置，返回值voidprintStackTrace(PrintStream s) ：通常用该方法将异常内容保存在日志文件中，以便查阅--Error：错误，一般情况下，不编写针对性的代码进行处理，通常是jvm发生的，需要对程序进行修正。
--Exception：异常，可以有针对性的处理方式
错误和异常共有特点的特点：可抛性（类和对象都可以被throws和throw两个关键字所操作）
在出现错误和异常时，就必须要处理，否则编译失败
处理方式有两种：1、捕捉；2、抛出
对于捕捉：java有针对性的语句块进行处理：
try {
需要被检测的代码；
}
catch(异常类 变量名){
异常处理代码；
}
fianlly{
一定会执行的代码；
}
异常处理原则：功能抛出几个异常，功能调用如果进行try处理，需要与之对应的catch处理代码块，这样的处理有针对性，抛几个就处理几个
throw 和throws区别：
throw用于抛出异常对象，后面跟的是异常对象；throw用在函数内。
throws用于抛出异常类，后面跟的异常类名，可以跟多个，用逗号隔开。throws用在函数上
编译异常：只要是Exception及其子类都是编译时被检测的异常
运行异常：其中Exception有一个特殊的子类RuntimeException，以及RuntimeException的子类是运行异常，也就说这个异常是编译时不被检查的异常
定义异常处理时，try和throws使用时机：
功能内部如果出现异常，如果内部可以处理，就用try
如果功能内部处理不了，就必须声明出来，让调用者处理
自定义异常的步骤：
1：定义一个子类继承Exception或RuntimeException，让该类具备可抛性
2：通过throw 或者throws进行操作
try catch finally的几种方式：
1：try catch
2：try catch finally
3：try finally 出现异常，并不处理，但是资源一定关闭
异常注意事项：子类覆盖父类只能抛出父类的异常或者子类或者子集。
如果父类的方法没有抛出异常，那么子类覆盖时绝对不能抛，就只能try包（package）
对类文件进行分类管理；给类文件提供多层名称空间
包是一种封装形式，用于封装类，想要被包以外的程序访问，该类必须public；
类中的成员，如果被包以外访问，也必须public
导入包：import 包名.*
jar ：java的压缩包，主要用于存储类文件，或者配置文件等
命令格式：jar –cf 包名.jar 包目录
解压缩：jar –xvf 包名.jar
访问控制权限：
public
protected
private
同类
√
√
√
√
同包
√
√
√
子类
√
√
不同包
√
755
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
