Java基础9--继承--抽象类--接口

9-1，子父类的构造函数-子类的实例化过程

1，在子类构造对象的时候，发现访问子类构造函数时，父类的构造函数也运行了，这时为什么呢？
原因是：在自类的构造函数中第一行有一个默认的隐式语句，就是super()。
super()调用的就是父类中空参的构造函数。
示例：

class Fu{
Fu() {
super();//Fu继承自Object，也有一个super()，访问的是Object的空参构造函数
System.out.println("Fu run ...");
}
}
class Zi extends Fu {
Zi() {
super();//这里访问的是Fu的空参构造函数
System.out.println("Zi run ...");
}
}
class ExtendsDemo {
public static void main(String[] args) {
new Zi();
}
}

运行结果是:
Fu run ...
Zi run ...
在本例中，如果Fu没有空参构造函数，如只有一个Fu(int x)，则编译出错，在子类中必须显示的调用父类构造函数，并且也必须在Zi构造函数的第一行，比如super(1)，即可解决。
继承时，构造函数不能被继承过来，也不能被覆盖。

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

class Fu {
Fu() {
super();
System.out.println("A Fu run ...");
}
Fu(int x) {
super();
System.out.println("B Fu run ..." + x);
}
}
class Zi extends Fu {
Zi() {
super();
System.out.println("C Zi run ...");
}
Zi(int x) {
super();
System.out.println("D Zi run ..." + x);
}
}
class ExtendsDemo {
public static void main(String[] args) {
new Zi(6);
}
}

程序结果：
A Fu run ...
D Zi run ...6
实例化过程为：
创建Zi对象，调用Zi的构造函数Zi(int x)，在Zi(int x)中有默认的额super()，再调用Fu中的Fu()，Fu()中有super()，调用Object的Object()，这个函数啥都没做，直接return，返回到Fu()中，执行下一句打印，输出A Fu run ...，再返回Zi(int x)输出D Zi run ...6。
若在Zi(int x)中加入super(6)，则先调用Fu中的Fu(int x)，再输出Zi(intx)中的语句。

9-2，子父类中的构造函数-子类实例化过程细节

1，为什么子类实例化的时候要访问父类中的构造函数呢？
因为子类继承了父类，就取到了父类中的内容(属性)，所以在使用父类的内容之前，要先看父类是如何对自己的内容进行初始化的。所以子类在构造对象时，必须访问父类中的构造函数，为了完成这个必须的动作，就在子类的构造函数的第一句中加入了super()语句，这是个默认的隐式语句，不写也会调用。
如果父类中没有定义空参的构造函数，那么子类的构造函数必须用super明确要调用父类中的那个构造函数。
注意：super语句必须定义在子类构造函数的第一行，因为父类的初始化动作要先完成。
子类构造函数中，如果使用this调用了本类的构造函数，那么super这个隐式语句就没有了，因为super和this都只能定义在第一行，所以二者只能存在一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

2，示例：

class Demo extends Object {//java中所有的类都继承自Object
/* 这是类中自带的默认的构造函数，自带有super
Demo() {
super();
return;
}
*/
}

从这个例子中可以看出，我们写一个Demo类，在这个类什么都没写的时候，就已经具备注释中的内容了。

9-3，子父类构造函数-子类实例化过程-内存图解

1，一个对象的实例化过程：
以Person p = new Person();为例。
(1)JVM会读取指定路径(classpath)下的Person.class文件，并加载进内存，并会先加载Person的父类(如果有直接父类的情况下)。
(2)在堆内存中开辟空间，分配地址。
(3)并在对象空间中，对对象的属性进行默认的初始化。
(4)调用对应的函数进行初始化。
(5)在构造函数中，第一行会先调用父类中构造函数进行初始化。
(6)父类初始化完毕后，再对子类的属性进行显示初始化。
(7)再进行子类构造函数的特定初始化。
(8)初始化完毕后，将地址值赋给引用变量。

2，示例：

class Fu {
Fu() {
super();
show();
return;
}
void show() {
System.out.println("fu show");
}
}
class Zi extends Fu {
int num = 8;
Zi() {
super();
return;
}
void show() { //覆盖了Fu中的show
System.out.println("zi show ..." + num);
}
}
class ExtendsDemo{
public static void main(String[] args) {
Zi z = new Zi();
z.show();
}
}

运行结果：
zi show ... 0
zi show ... 8



步骤：
(1)ExtendsDemo类的方法加载进方法区。
(2)main方法加载进静态方法区。
(3)main进栈。
(4)Zi z = new Zi();开始加载Zi类，由于Zi类继承了Fu类，所以Fu类先加载进方法区，然后Zi类加载。
(5)z对象进栈。
(6)实例化z对象，再堆中开辟空间，分配地址，num默认初始化为0。
(7)Zi()构造方法进栈，自带this引用，并指向0X0045。
(8)Zi()中super()引用Fu的构造函数Fu()，Fu()构造方法进栈，自带this引用，指向0X0045，执行show方法，由于Zi类中重写了Fu类中的show方法，把Fu类中的show覆盖，Fu()指向Zi类对象z，调用z中的show方法，且这时num的值为0，故此时输出zi show...0。
(9)Fu()运行结束，弹栈。
(10)回到Zi()构造方法中，继续显示初始化num为8.
(11)Zi()运行结束，弹栈。
(12)实例化完毕，把0X0045赋给z，Zi指向堆内存。
(13)show方法进栈，自带this引用指向0X0045，输出zi show ...8。
(14)show运行完毕，弹栈。

9-4，final关键字

1，继承的弊端：打破了封装性。
2，final关键字：
(1)final是一个修饰符，可以修饰类、方法、变量。
(2)final修饰的类不可以被继承。
(3)final修饰的方法不可以被覆盖。
(4)final修饰的变量是一个常量，只能赋值一次。
3，为什么用final修饰变量？
在程序中，如果一个数据是固定不变的，那么直接使用这个数据就可以了，但是这样阅读性很差，所以应该给这个数据起一个名称，而且这个变量名称的值不能变化，所以加上final固定。若该数据是要被共享的，可以在加上static修饰符，可以直接被类名调用，若该常量在全局有效，可以加上public修饰，使全县最大化。
4，写法规范：
常量的所有字母都大写，多个单词之间用下划线连接。

9-5，抽象类-概述

1，例：

abstract class Person {//抽象类
abstarct void show();//抽象方法
}

2，当遇到不具体的事物时就定义成抽象的，如犬科都有吼叫功能，狗和狼的叫声是不同的，但都具备吼叫功能，所以犬科的吼叫方法定义为抽象的，由于有不确定的方法，所以该类也是不确定的，该类也定义为抽象的。
3，示例：

abstarct class 犬科{
abstract void 吼叫();
}
class 狗 extends 犬科 {
void 吼叫() {
System.out.println("汪汪");
}
}
class 狼 extends 犬科 {
void 吼叫() {
System.out.println("嗷嗷");
}
}

因为犬科中有一些是具体的方法，如睡觉功能，狗和狼的睡觉功能是一样的，所以向上提取出犬科类，而不在狗和狼类中直接写吼叫的方法。

9-6，抽象类-特点

特点：
(1)方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰，抽象方法必须定义在抽象类中，该类必须也被abstract修饰。
(2)抽象类不可以被实例化，为什么？因为调用抽象方法没有意义。
(3)抽象类必须由其子类覆盖了所有的抽象方法后，该子类才可以被实例化，否则这个子类还是抽象类。

9-7，抽象类-细节

1，抽象类中有构造函数么？
有，用于给子类对象初始化。
2，抽象类可以不定义抽象方法么？
可以，但是很少见，目的就是不让这个类创建对象。AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是没有内容。
3，抽象关键字不可以和哪些关键字共存？
(1)private不行，因为抽象方法必须被子类覆盖并实现才能创建对象，若用private修饰，则子类不能覆盖这个抽象方法。
(2)static不行，用static修饰的方法可以不用对象调用，直接用类名调用，但是调用抽象方法是没有意义的，所以不兼容。
(3)final不行，抽象方法必须被覆盖，而加上final就不能被覆盖了，冲突。抽象类可以有子类，用final修饰则不能有子类，冲突。
4，抽象类和一般类的区别
相同点：抽象类和一般类都是用来描述事物的，都在内部定义了成员。
不同：
(1)一般类有足够的信息描述事物。
抽象类描述事物的信息有可能不足。
(2)一般类中不能定义抽象方法，只能定义非抽象方法。
抽象类中可以定义抽象方法，同时也可以定义非抽象方法。
(3)一般类可以被实例化。
抽象类不可以被实例化。
5，抽象类一定是一个父类么？
是的。因为需要子类覆盖其方法后才可以对子类实例化。

9-8，抽象类的一个小练习

需求：雇员示例：
公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出数据进行数据建模。
分析：
在这个领域中，先通过名词提炼找出涉及的对象。
程序员：
属性：姓名、工号、薪水
行为：工作
经理：
属性：姓名、工号、薪水、奖金
行为：工作
程序员和经理不存在直接继承的关系，但是程序员和经理有着共性的内容，可以进行抽取。因为他们都是公司的雇员。
可以将程序员和经理进行抽取，建立体系。

//描述雇员
abstract class Employee{
private String name;//姓名
private String id;//工号
private double pay;//薪水
Employee(String name,String id,double pay) {
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
//描述程序员
class Programmer extends Employee {
Programmer(String name,String id,double pay) {
super(name,id,pay);
}
public void work() {
System.out.println("code...");
}
}
//描述经理
class Manager extends Employee {
private int bonus;
Manager(String name,String id,double pay,int bouns) {
super(name,id,pay);
this.bonus = bonus;
}
public void work() {
System.out.println("manage");
}
}
class AbstractTest {
public static void main(String[] args) {
Programmer p = new Programmer("Peter","01001",6000.0);
p.work();
Manager m = new Manager("Tom","09001",12000.0,3000);
m.work();
}
}

9-9，接口interface-定义

1，当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口interface。
定义接口使用的关键字不是class而是interface，但接口仍是一个类，编译完成后生成与接口同名的.class文件，如：interface Demo，则声称Demo.class。
2，接口当中常见的成员，这些成员都有固定的修饰符。
(1)全局常量：public static final
(2)抽象方法：public abstract
如：

interface Demo {
public static final int NUM = 4;
public abstract void show();
}

接口中的成员必须这么定义。
可以得出一个结论，接口中的成员都是公共的权限。
3，由于接口中的成员的修饰符石固定的，所以若不写publc static final或是其中的某个修饰符，编译时会自动加上，但返回值类型必须写。
上述中的那段代码可以写成：

interface Demo {
int NUM = 4;
void show();
}

但一般不这么写，因为阅读性太差。若int NUM = 4;前面不加修饰符，很可能把它误以为是一个变量，而show()前不加修饰符，由于抽象方法是需要被覆盖的，而覆盖必须要了解抽象的权限，否则可能覆盖失败。

9-10，接口-实现implements

1，形式：

interface Demo {
// code...
}
class DemoImpl implements Demo {
// code...
}

2，类与类之间是继承关系，类与接口之间是实现关系。
接口不可以实例化，只能有实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化，否则这个子类就是一个抽象类。
3，示例：

interface Demo {
public static final int NUM = 4;
public abstract void show();
}class DemoImpl implements Demo {
public static void main(String[] args) {
DemoImpl d = new DemoImpl();
System.out.println(d.NUM);//正确
System.out.println(DemoImpl.NUM);//正确
System.out.println(Demo.NUM);//正确
}
}

但不能写d.NUM = 3;因为NUM为final的，其值不能改变。

9-11，接口-多实现

1，在Java中不直接支持多继承，因为会出现调用的不确定性。所以Java将多继承机制进行改良，在Java中变成了多实现。
一个类可以实现多个接口。
2，接口为什么不存在调用的不确定性？
之前说过，类之所以不支持多继承，是因为会出现方法调用的不确定性。接口为什么不存在这种情况呢？
因为接口中的方法都是抽象的，没有具体的实现方法，需要被覆盖才能实现，如果实现的两个接口中有相同的方法，则覆盖时把两个抽象方法都覆盖，所以实现的功能只有一个，不存在调用的不确定性。
注意：两个同名方法也需要相同的返回值类型。

9-12，接口-细节

1，一个类在继承另一个类的同时，还可以实现多个接口，接口的出现避免了单继承的局限性。

class Q {
public void method() { ... }
}
class Test extends Q implements A,Z {
...
}

Test类在继承Q的同时，可以实现A,Z等多个接口。
2，接口与接口之间是继承关系，而且接口可以多继承。

interface CC {
void show();
}
interface MM {
void method();
}
interface QQ extends CC,MM {
void function();
}
class WW implements QQ {
//需要覆盖三个方法
public void show() { ... }
public void method() { ... }
public void function() { ... }
}

3，Java中有没有多继承？
有，只不过换了一种方式实现，即接口。多实现的方式，但接口之间可以进行多继承，原理就在于方法体是否存在。

9-13，接口-特点

特点：
(1)接口是对外暴露的原则。如：电脑的USB接口，对外暴露，给外界提供一个与自己连接的地方，而用不到接口的地方就封装在电脑内。
(2)接口是程序的功能扩展。USB接口不仅可以接鼠标，还可以接键盘、U盘等，提高了其功能。
(3)接口的出现降低了耦合性。即降低联系程度，我们可以在用鼠标的时候，把它接到电脑上，不用的时候拔掉，而不是将鼠标焊死在电脑上。
(4)接口可以用来多实现。
(5)类与接口之间是实现关系，而且类可以在继承一个类的同时实现多个接口。
(6)接口与接口之间可以有继承关系。

9-14，接口和抽象类的区别

1，异同点：
相同：
都是不断向上抽取而来的。
不同：
(1)抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
(2)抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须有子类实现。
(3)抽象类中的继承是is a关系，在定义该体系的基本共性内容。
接口的实现是like a的关系，在定义体系的额外功能。

2，什么时候使用接口，什么时候使用抽象类呢？
Eg:犬按功能分有导盲犬、搜爆犬等。

/*
导盲犬和搜爆犬都是犬，具有吼叫，睡觉等共性功能，而二者可能吼叫的方式不同，故不提供实现方式，
但睡觉的方式是相同的，所以将犬类定义为abstract，定义一些共性的东西。
*/
abstract class 犬 {
abstract void 吼叫();
void 睡觉() {
System.out.println("我睡...");
}
}
/*
可能不只狗有导盲功能，还有导盲猪，这时就把导盲功能抽取出来，谁具有导盲功能，
谁来实现就可以了，而导盲的方式不同，所以不定义具体实现方法。
*/
interface 导盲 {
abstract void 导盲();
}
interface 搜爆 {
abstract void 搜爆();//谁具有搜爆功能，实现这个接口即可
}
/*
导盲是犬类的扩展性功能，需要实现导盲功能，实现导盲接口。
*/
class 导盲犬 extends 犬 implements 导盲 {
//让导盲犬继承共性的犬，实现特有的导盲功能
public void 吼叫() {
System.out.println("汪汪");
}
public void 导盲() {
System.out.println("狗的指引");
}
}

因为犬类中有抽象的方法，还有一半方法，定义为抽象类；导盲中只有一个抽象方法，定义为接口。
在不同的问题领域中，有不同的分析方式。