---------------------- android培训、java培训、期待与您交流！ ----------------------
继承
1.提高了代码的复用性；
2.让类与类之间产生了关系，有了这个关系，才有了多态的特性；
注意：千万不要为了获取其他类的功能，简化代码而继承；
必须是类与类之间有所属关系才可以继承，所属关系 is a。
java语言中，java只支持单继承，不支持多继承。因为多继承容易带来安全隐患：当多个父类（也叫超类）中定义了相同功能，当功能内容不同时，子类对象不确定要运行哪一个。但是java保留了这种机制，并用另一种体现形式来完成表示，这种体现形式叫做“多实现”。
java支持多层继承。也就是一个继承体系。
3.如何使用一个继承体系中的功能呢？
想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中共性的功能，通过了解共性功能，就可以知道该体系中的基本功能。那么这个体系就已经基本可以使用了。
在具体调用时，要创建最子类的对象，为什么呢？
1.因为有可能父类不能创建对象；
2.创建子类对象可以使用更多的功能，包括基本的也包括特有的。
简单说就是：查阅父类功能，创建子类对象使用功能。
子、父类中变量、函数、构造函数的特点
子父类出现后，类中成员的特点。
1.变量
如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量用this，子类要访问父类中的同名变量，用super，如果子类没有与父类同名的变量，访问父类中的变量时也可以用：this.父类变量。
super的使用和this的使用几乎一致。
this代表本类对象的引用。
super代表父类（超类）对象的引用。
2.函数
当子类出现与父类一模一样的函数时，如果子类对象调用该函数，会运行子类中该函数的类容，如同父类的函数被覆盖一样。这种情况叫做覆盖（也叫重写）。
当子类继承父类，从而沿袭了父类的功能到子类中，但是，子类虽具备该功能，功能的内容却和父类不一致，这时就没有必要定义新的功能，而是使用覆盖特性，保留父类的功能定义，并重写功能内容。
子类覆盖父类，必须保证子类权限大于等于父类权限才可以覆盖，否则编译失败。（但是父类权限如果是私有的话，子类就无法知道父类的相同函数功能，从而无法实现覆盖。），
静态只能覆盖静态。
到目前学了public、private、默认权限（就是没有public、private），默认权限的权限大小介于public和private之间。
记住：
1.重载只看同名函数的参数列表；
2.（覆盖）重写要求子父类方法要一模一样（包括返回值类型等）。
3.构造函数
super();用于调用父类的空参数构造函数，
如果要调用父类中的有参数构造函数的话，调用格式就是super(参数1，参数2，…);
this();语句调用本类的空参数构造函数。
在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数中默认第一行有一条隐式的语句super();而且子类中所有的构造函数默认第一行都有super();
为什么子类一定要访问父类中的构造函数：
因为父类中的数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问以下父类中的构造函数。
如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来指定（即super(参数1，参数2，…)，调用格式跟this关键字在构造函数间的调用方法一样）。
还有就是super()语句也要求必须定义在子类构造函数的第一行（物理位置上的第一行，不能说平行什么的）。
子类的实例化过程
子类的所有构造函数默认都会访问父类中空参数的构造函数。因为子类中每一个构造函数内的第一行都有一句隐式的super()语句。
当父类中没有空参数的构造函数时，子类必须手动通过super或者this语句形式来指定要访问父类中的构造函数。
当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数。
Final关键字
final : 最终。作为一个修饰符，
1，可以修饰类，函数，变量。
2，被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3，被final修饰的方法不可以被复写。
4，被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。
而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。
单词间通过_连接。
5，内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
抽象类：
当多个类中出现相同功能，但是功能主题不同，这时可以进行向上抽取，但是只抽取功能定义，也就是函数名（），而不抽取功能主体。
“抽取”：是通过分析问题的共性内容完成的，不是通过提取相同代码实现的。
“抽象”：是强迫子类去做覆盖的一种方式。
特点：
1， 抽象方法一定定义在抽象类中，并且，抽象类中也可以有非抽象的方法；甚至抽象类中可以没有抽象的方法，此种情况下，这个抽象类的功能只有一个，就是不允许该类实例化。
2，抽象方法和抽象类都必须被abstract关键字修饰
3，抽象类不可以用new创建对象，因为调用抽象方法没意义。
4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类之覆盖了部分抽象方法，那么该子类还是一个抽象类。
抽象类和一般类没有太大不同，该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的内容
这些不确定的部分，也是事物的功能，只是具体实现的方式不一样，所以需要明确出现，但是无法定义主体。
通过抽象方法来表示。
抽象类比一般类多了抽象函数，不可实例化。
抽象类或者接口为什么不能建立对象？
当这个类中有了抽象方法，作为类的成员存在，那么这个类如果建立对象，再去调用这个没有方法主体的抽象方法，
是没有任何意义的
故此，抽象方法也要存放在抽象类中。并且这个类不能建立对象，因为声明了抽象的类，说明类当中有抽象方法，
你不能创建一个你看不懂，而且调用函数无意义的类的对象。
abstract 关键字，和哪些关键字不能共存。
final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。
private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。
static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。
抽象类中是否有构造函数？
有，抽象类是一个父类，要给子类提供实例的初始化。
abstract class Student //当类中出现了抽象方法时候，这个类也必须声明为抽象类,在class前加上abstract
{
abstract void study(); //向上抽取相同功能，但是功能主题不同。去掉了方法主体大括号“{}”，（此处区别于有方法体
//abstract void study1(); 声明了另一个抽象函数； 并且用abstract关键字说明
}
class BaseStudent extends Student
{
void study()
{
System.out.println("base study");
}
//abstract void study1(); 如果BaseStudent类中没有覆盖study1的抽象方法，那么这个BaseStudent类也成为了抽象类
//void study1(){} 此语句实现了对Student抽象类中抽象方法study1的“空复写”
}
class AdvStudent extends Student
{
void study()
{
System.out.println("adv study");
}
}
class AbstractDemo
{
public static void main(String[] args)
{
//new Student(); //创建了一个抽象类的对象，编译失败：“Student是抽象的，无法对其实例化”
new BaseStudent().study();
}
}
模版方法设计模式思路：
在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，
那么这时就将不确定的部分暴露出去。由该类的子类去完成。
示例：
abstract class GetTime
{
public final void getTime()
{
long start = System.currentTimeMillis();
runcode();
long end = System.currentTimeMillis();
System.out.println("毫秒："+(end-start));
}
public abstract void runcode();
}
class SubTime extends GetTime
{
public void runcode()
{
for(int x=0; x<4000; x++)
{
System.out.print(x);
}
}
}
class TemplateDemo
{
public static void main(String[] args)
{
//GetTime gt = new GetTime();
SubTime gt = new SubTime();
gt.getTime();
}
}
接口
接口：初期理解，可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。
class用于定义类
interface 用于定义接口。
接口定义时，格式特点：
1，接口中常见定义：常量，抽象方法。
2，接口中的成员都有固定修饰符。
常量：public static final
方法：public abstract
记住：接口中的成员都是public的。只要定义了接口，它的修饰符就都是固定的，少写哪个，系统会自动默认补充。
接口：是不可以创建对象的，因为有抽象方法。
需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。
接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。
类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；接口与接口之间可以有多继承的关系。
interface Inter
{
public static final int NUM=3;//全局，静态，最终。。。。全局常量
public abstract void show();
}
interface InterA
{
public abstract void show();
}
class Demo
{
public void function(){}
}
class Test extends Demo implements Inter,InterA
//一个类在继承一个父类的同时也可以实现一个或多个接口,先继承在实现可以扩展这个类的功能。
{
public void show(){} //只要有方法体就实现了覆盖。接口的权限比较特殊
//接口里面的方法都是公有的，所以要覆盖其中的方法，必须声明的函数权利为public
//而抽象类不是，抽象类中的方法权限可以单独设定，而接口都是固定的。
}
interface A
{
void methodA();
}
interface B extends A //接口与接口之间是继承关系。extends
{
void methodB();
}
interface C extends B //且接口之间存在多继承，如果B没有继承A的话
//C可以直接继承A和B。 interface C extends B,A 接口的多继承是因为接口中的抽象方法都没有方法体
{ //但是在多继承时候，继承的两个或多个接口中不能有同名却不同类型的函数。
//（因为在实例创建对象时，对象调用该函数时会出错，不知道该调用哪一个）
void methodC();
}
class D implements C //D若要创建对象的话必须覆盖ABC中的三个方法
{
public void methodA(){}
public void methodC(){}
public void methodB(){}
}
class InterfaceDemo
{
public static void main(String[] args)
{ Test t = new Test(); //用实现接口的类创建一个对象
System.out.println(t.NUM); //对象调用成员
System.out.println(Test.NUM); //类名直接调用成员
System.out.println(Inter.NUM); //接口名调用成员。编译完成后，接口也会生成一个字节码class文件。
//t.NUM = 4; 这个语句是错误的，这三个语句中任何一个都不能对NUM赋值。
---------------------- android培训、java培训、期待与您交流！ ----------------------
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
