黑马程序员--java基础--类的继承与接口的实现

来源：互联网发布：c语言国际象棋棋盘编辑：程序博客网时间：2024/05/19 12:26

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

继承

当多个类中存在共性时，将这些共性抽取到单独一个类中，继承这个类，这时，多个类可以称为子类，单独的这个类称为父类或者超类。

类与类之间就存在了继承的关系。通过extends关键字表示继承关系

子类可以直接访问父类中的非私有的属性和行为。

如图

必须是类与类之间有所属关系才可以继承。这种所属关系的表示为is a。

书写格式

class Fu{}class Zi extends Fu//继承了上面的类{void show(){System.out.println("this:"+super);}}

在内存中的加载先后顺序

特点

Java语言中

多层继承

Java类中虽然不支持多继承，但可以多层继承，也就是一个继承体系。

class A{}
class B extendsA{}
class C extendsB{}

查阅父类功能，创建子类对象使用功能。

继承后，类成员的特点：

成员变量

子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this。

子类要访问父类中的同名变量，用super。

super的使用和this的使用几乎一致，且两者都存在于方法区中。
this表示本来对象的引用。
super表示父类对象的引用。
成员函数——覆盖
子类出现和父类一样的函数时，子类对象调用该函数，会运行子类函数的内容。这种情况是函数的另一个特性：重写（覆盖）。
子类继承父类，沿袭了父类的功能到子类中。可以用super.方法();

class Fu{Fu(){show();return;}void show(){System.out.println("fu show");}}class Zi extends Fu{int num = 8;Zi(){System.out.println("zi cons run...."+num);return;}void show(){System.out.println("zi show..."+num);//覆盖了父类的方法}}class ExtendsDemo5 {public static void main(String[] args) {Zi z = new Zi();z.show();}}

注意

1、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
2、静态只能覆盖静态。
3、父类中的私有方法不能被重写。

构造函数

/*子父类中的构造函数的特点。在子类构造对象时，发现，访问子类构造函数时，父类也运行了。为什么呢？原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。为什么子类实例化的时候要访问父类中的构造函数呢？那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。所以子类在构造对象时，必须访问父类中的构造函数。 为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。*/class Fu{int num ;Fu(){num =10;System.out.println("A fu run");}Fu(int x){System.out.println("B fu run..."+x);}}class Zi extends Fu{int num;Zi(){//super();//调用的就是父类中的空参数的构造函数。System.out.println("C zi run"+num);}Zi(int x){this();//super();//super(x);System.out.println("D zi run "+x);}}class  ExtendsDemo{public static void main(String[] args) {new Zi(6);}}

扩展

final关键字

当一些数据的出现值是固定的，为了增强阅读性，给这些值起个名字，而这个值不需要改变，所以加上final修饰作为常量。

常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。

class Fu{void method(){//调用了底层系统的资源。}}class Zi extends Fu{public static final double MY_PI = 3.14;//常量的书写规范static final int x = 7;//final的使用void method(){final int NUMBER = 9;System.out.println(MY_PI);}}

注意：内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。

抽象类

抽象类特点：

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

抽象类中的小问题

1，抽象类中有构造函数？
有，用于给子类对象进行初始化。

2，抽象类可以不定义抽象方法吗？
可以的。但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。

abstract class Demo
{
void show1()
{}

void show2()
{}
}

3，抽象关键字不可以和那些关键字共存?
private 不行
static 不行
final 不行

4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
抽象类不可以被实例化。

5，抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。

下面我们用一个小例子说明一下

abstract class 犬科//<span style="font-family: Arial, Helvetica, sans-serif;">抽象类需要用abstract修饰</span>{abstract void 吼叫();<span style="font-family: Arial, Helvetica, sans-serif;">//抽象方法也需要用abstract修饰</span>}class 狗 extends 犬科{void 吼叫()//抽象方法需要被覆盖，子类才能被实例化{System.out.println("汪汪");}}class 狼 extends 犬科{void 吼叫(){System.out.println("嗷嗷");}}

雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。

分析：在这个问题领域中，先找出涉及的对象。通过名词提炼法。程序员：属性：姓名，工号，薪水、行为：工作。经理：属性：姓名，工号，薪水，奖金。行为：工作。程序员和经理不存在着直接继承关系，但是程序员和经理却具有共性内容。可以进行抽取。因为他们都是公司的雇员 可以将程序员和经理进行抽取.建立体系.*///描述雇员。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 bonus){super(name,id,pay);this.bonus = bonus;}public void work(){System.out.println("manage");}}

抽象类与一般类的区别

1、抽象类和一般类没有太大的不同。该如何描述事物，还是如何描述事物。只不过，该事物中出现了一些不知道具体内容的方法部分。这些不确定的部分，也是该事物的功能，需要明确出来，但是无法定义主体。通过抽象方法来表示。
2、抽象类比一般类多了个抽象函数。就是在类中可以定义抽象方法。
3、抽象类不可以实例化。
4、抽象类虽然不能创建对象，但是也有构造函数。供子类实例化调用。

接口

定义接口使用的关键字不是class，是interface.

对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public static final

2，抽象方法。public abstract

由此得出结论，接口中的成员都是公共的权限.

接口特点
1、接口是对外暴露的规则。
2、接口是程序的功能扩展。
3、接口的出现降低耦合性。
4、接口可以用来多实现。这也是对多继承不支持的转换形式。java支持多实现。
5、类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
6、接口与接口之间可以有继承关系。而且可以多继承。

7、接口不可以创建对象的，因为有抽象方法。

8、需要被子类实现（implements），子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则子类是一个抽象类。

9、实现多个接口时，接口中不可以有返回不同类型的同名抽象函数。这样子类实现时将不能复写。

以电脑主板为图例说明接口的优点

接口与抽象类区别
共同点：都是不断向上抽取出来的抽象的概念。
不同点：
1、抽象类体现继承关系，一个类只能单继承。
接口体现实现关系，一个类可以多实现。同时接口与接口之间有继承关系。
2、抽象类是继承，是 "is a "关系。
接口是实现，是 "like a"关系。
3、抽象类中可以定义非抽象方法，供子类直接使用。
接口的方法都是抽象，接口中的成员都有固定修饰符。
4、抽象类中可以私有变量或方法。
接口中的常量和方法都是public修饰的权限。

interface Demo{public static final int NUM = 4;public abstract void show1();public abstract void show2();}//类与类之间是继承关系，类与接口直接是实现关系。 /*接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。否则，这个子类就是一个抽象类。*/class DemoImpl implements /*实现*/Demo{public void show1(){}public void show2(){}}/*在java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制进行改良，在java中变成了多实现。一个类可以实现多个接口。 */interface A{public void show();}interface Z{public int add(int a,int b);}class Test implements A,Z//多实现{public int add(int a,int b){return a+b+3;}/**/public void show(){}}/*一个类在继承另一个类的同时，还可以实现多个接口。*/class Q{public void method(){}}abstract class Test2 extends Q implements A,Z{}/*接口的出现避免了单继承的局限性。*/interface CC{void show();}interface MM{void method();}interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。 {void function();}class WW implements QQ{//覆盖3个方法。public void show(){}public void method(){}public void function(){}}

0 0