1.继承(关键词：extends)：(子父类)
　　1.提高代码的复用性。
　　2.让类与类之间产生了关系。有了这个关系，才有了多态的特性。

1.1变量
　　如果子父类中出现非私有的（private）同名成员变量时，子类要访问本类中的变量，用this，子类要访问父类中的同名变量，用super。
　　super的使用和this使用几乎一致。
　　this代表的是本类对象的引用。
　　super代表的父类对象的引用。

1.2 子父类中的函数
　　当子类出现和父类一模一样的函数时，
　　当子类对象调用该函数，会运行子类函数的内容。如同父类的函数被覆盖一样。

　　这种情况是函数的另一个特性：重写（覆盖）

　　当子类继承父类，沿袭了父类的功能，到子类中，但是子类虽具备该功能，但是功能的内容却和父类不一致，这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。

覆盖注意事项：
　　1.子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。（不写权限修饰符则是默认权限，介于private和public之间。）
　　2.静态只能覆盖静态。

重载和重写：
　　重载：只看同名函数的参数列表。
　　重写：子父类中的方法名和返回类型要一模一样。（即：返回类型 方法名() 要一样）

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

为什么子类一定要访问父类中的构造函数。
　　因为父类中的数据子类可以直接获取，所有子类对象在建立时，需要先查看父类是如何对数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定。

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

结论：
　　子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
　　因为子类每一个构造函数内的第一行都会有一句隐式super();
　　当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。
　　当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。（因为this()和super()都只能放在构造函数的第一行，所以在构造函数中只能存在其中一个。）

注意：千万不要为了获取其他类的功能，简化代码而继承。必须是类与类之间有所属关系才可以继承。所属关系 is a 。
2.final：最终。作为一个修饰符。
2.1 可以修饰类，函数，变量。
2.2 被final修饰的类不可以被继承。为了避免被继承，避免被子类重写功能。
2.3 被final修饰的方法不能被重写
2.4 被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。当描述事物时，一些数据的出现，值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。而这个值不需要改变，所以加上final修饰。 作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。单词间通过_连接。（eg: final double PI = 3.14； final int SET_ON = 1;）
2.5 内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

3. 抽象：
3.1 抽象方法一定在抽象类中。
3.2抽象方法和抽象类都必须被 abstract关键字修饰。（abstract class 类名 { abstract void 方法名(); }）
3.3抽象类不可以用new创建对象。因为调用抽象方法没意义。
3.4 抽象类中的抽象方法要被使用，必须由子类重写其所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
一般类和抽象类的异同：抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。
抽象类比一般类多了个抽象函数。就是在类中可以定义抽象方法。
抽象类不可以实例法。
特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
4. 模版设计模式：
　　在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。
5.接口：
　　初期理解，可以认为是一个特殊的抽象类。当抽象类中的方法都是抽象的（abstract），那么该类可以通过接口的形式来表示。
　　class ：用于定义类
　　interface：用于定义接口。接口也是一种类。可以生成class文件。

接口定义时，格式特点：
　　1.接口中常见定义：常量，抽象方法。接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。
　　2.接口中的成员都有固定修饰符。
　　常量：public static final
　　方法：public abstract
　　记住：接口中的成员都是public的。
　　接口：是不可以创建对象的，因为有抽象方法（abstract）。需要被子类实现，子类对接口中的抽象方法全都重写后，子类才可以实例化。否则子类是一个抽象类。
　　eg: interface Inter
　　{
　　　　//public static final 和public abstract修饰符缺少也可以，因为接口中的成员都有固定修饰符。但是开发中最好写，增强阅读性。
　　　　public static final int SET_ON = 1;
　　　　public abstract void show();
　　}
　　//使用接口implements
　　class Test implements Inter
　　{
　　　　public void show(){} //需要重写抽象方法show，才能创建对象
　　}
　　class InterfaceDemo
　　{
　　　　public static void main(String[] args)
　　　　{
　　　　　　Test t = new Test();
　　　　　　System.out.println(t.SET_ON);

　　　　}

　　}

接口的特点：
　　接口是对外暴露的规则。
　　接口是程序的功能扩展。
　　接口可以用来多实现。
　　类与接口之间是实现关系，而且类可以继承一个类的同时实现多接口。
接口与接口之间可以有继承关系。
6.多态：
　　定义：某一类事物的多种存在形态。
　　eg:动物中猫、狗
　　猫这个对象对应的类型是猫类型
　　猫 x = new 猫();
　　同时猫也是动物中的一种，也可以把猫称为动物。
　　动物 y = new 猫();
　　动物是猫和狗具体事物中抽取出来的父类型。
　　父类型引用指向了子类型对象。
6.1.多态的体现：
　　父类的引用指向了自己的子类对象。
　　父类的引用也可以接收自己的子类对象。
　　eg: 父类 父类引用名 = new 子类();//类型提升。向上转型。要使用子类特有功能，需要向下转型：子类 新 子类引用名 = （子类）原父类引用名
　　关键字： instanceof 判断引用类型
　　　　eg: if (a instanceof Cat)//判断a是不是猫类型。
6.2.多态的前提：
　　　必须是类与类之间有关系。要么继承，要么实现。
　　通常还有一个前提：子类必须覆盖（重写）。

6.3.多态的好处：
　　多态的出现大大的提高了程序的扩展性。
6.4.多态的弊端：
　　提高了扩展性，但是只能使用父类的引用访问父类中成员。

6.5在多态中非静态成员函数的特点：
　　在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有，编译失败。
　　在运行时期：参阅对象所属的类中是否有调用的方法。
　　简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。
6.6在多态中成员变量的特点：
　　无论编译和运行，都参考左边（引用型变量所属的类。）
　　在多态中静态成员函数的特点：
　　　　无论编译和运行，都参考左边（static本身就可以直接调用）。

7.object：是所有对象的直接或者间接父类，传说中的上帝。
　　该类中定义的肯定是所有对象都具备的功能。
　　内部类的访问规则：
　　　　1.内部类可以直接访问外部类中的成员，包括私有。
　　　　2.外部类要访问内部类，必须建立内部类对象。

Java--相关特性