黑马程序员_继承

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

 

继承(extends 面向对象特征之一)

1.什么是继承？

一个类使用extends关键字可以继承另一个类，子类会继承到父类的属性和方法

2.什么时候会用到继承？

在定义一个类的时候，发现另一个类的功能这个类都需要, 那么我们就可以在当前类名的后面使用extends关键字继承另一个类。

3.父类的由来：其实是由多个类不断向上抽取共性内容而来的。

4.继承的好处

提高了代码的复用性；让类与类之间产生了关系，有了这个关系，才有了多态的特性.

5.继承的特点

Java只支持单继承，不支持多继承；Java支持多层继承(继承体系)。

6.为什么不支持多继承？

因为多继承容易带来安全隐患，当多个父类中定义了相同的功能，但功能的内容不同时，子类对象不确定要运行哪一个。但是Java保留这种机制，并用另一种体现形式来完成表示--->多实现。

7.注意

千万不要获取其他类的功能简化代码而继承，必须是类与类之间有所属的关系才可以继承，所属关系is a。

8.如何使用一个继承体系中的功能呢？

一个体系要想被使用，直接查阅该系统中的父类的功能即可知道该体系的基本用法，那么要想使用一个体系，需要建立对象，一般建立子类对象，因为子类对象不仅可以使用父类的功能，还可以使用子类特有的一些功能。

9.在具体调用时，为什么要创建最子类的对象？

因为有可能父类不能创建对象；创建子类对象可以使用更多的功能，包括基本的也包括特有的。

简单一句话就是查阅父类的功能，创建子类对象使用功能。

10.继承代码如下：

class Person

{

       Stringname;

       int age;

}

class Student extends Person

{

              voidstudy()

       {

              System.out.println("goodstudy");

       }

}

class ExtendsDemo

{

       publicstatic void main(String[] args)

       {

              Students = new Student();

              s.name= "丽";

              s.age=22;

              System.out.println(s.name+"::"+s.age);

       }

}

11.子父类出现后，类中成员的特点

1).子父类中变量的特点

如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this.子类要访问父类中的同名变量，用super.

This代表本类的引用；

Super代表父类对象的引用；

注意：子父类中是不会出现同名的成员变量的，因为父类中只要定义了，子类就不用定义了，直接继承过来用就行了。

例如：

class Fu

{

       privateint num = 4;

       publicvoid setNum(int num)

       {

              this.num=num;

       }

       public intgetNum()

       {

              returnthis.num;

       }

}

class Zi extends Fu

{

       int num =5;

       voidshow()

       {

              System.out.println(num);

       }

}

class ExtendsDemo1

{

       publicstatic void main(String[] args)

       {

              Ziz = new Zi();

              z.show();

       System.out.println(z.num+"...."+z.num);

       }

}

 

2).子父类中函数的特点

1.当子类和父类出现一摸一样的函数时，当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖了一样。这种情况就是函数的另一特性：覆盖（复写，重写）。覆盖：保留父类定义，并重写功能内容。

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

3.覆盖：

3.1，子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，    否则编译失败。

3.2，静态只能覆盖静态。

4.什么时候使用覆盖？当一个类的内容需要修改时，可以通过覆盖来实现。

5.总结子类覆盖父类方法（重写）：

5.1.子类可以重写父类中的方法，一旦重写，调用的时候就会调用子类中的   方法。

5.2.如果需要调用父类中被覆盖的方法，需要用到关键字super。

5.3.重写方法时, 返回值类型、函数名、参数列表必须全部相同, 访问权限     不能比父类权限小。

6.注意：

重载（Overload）和重写（Override）的区别：

重载是方法名相同，参数列表不同(个数和类型)，和返回值类型无关,并且和方法的访问权限无关。

重写是方法名、参数列表、返回值类型全相同，访问权限不能比父类的权限小。

例如：

class Fu

{

       void show()

       {

              System.out.println("fushow");

       }

       voidspeak()

       {

              System.out.println("web");

       }

}

class Zi extends Fu

{

       voidshow()

       {

              System.out.println("zishow");

    }

}

class ExtendsDemo2

{

       publicstatic void main(String[] args)

       {

              Ziz = new Zi();

              z.speak();

              z.show();

       }

}

3).子父类中构造函数的特点--子类的实例化过程

1.在对子类对象进行初始化时，父类的构造函数也会运行，因为在子类的构造函数默认第一行有一条隐式的语句super()；Super()会访问父类中空参数的构造函数，而且子类中所有的构造函数默认第一行都是super()；

2.为什么子类一定要访问父类中的构造函数？

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

3.子类的实例化过程

子类的所有的构造函数，默认都会访问父类中空参数的构造函数。

因为子类每一个构造函数内的第一行都有一句隐式super();

当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。

当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。子类中至少会有一个构造函数会访问父类中的构造函数。

4.super（）和this（）不可以同时出现在构造函数中，因为this和super只能在第一行；

5.super（）或者this（）：为什么一定要在第一行？

因为super（）和this（）都是调用构造函数，构造函数用于初始化，所以初始化的动作要先完成。

6.super关键字总结:

在定义一个类的时候，如果定义了一个有参数的构造方法，务必再定义一个无参的构造方法，否则会运行时极有可能会发生错误。

例如：

class Fu

{

       int num ;

       Fu()

       {

              num=60;

              System.out.println("furun");

       }

    Fu(int  x)

       {

              System.out.println("fu...."+x);

       }

}

class Zi extends Fu

{

       Zi()

       {

              System.out.println("zirun");

       }

       Zi(int x)

       {

              this();

              System.out.println("zi..."+x);

       }

}

class ExtendsDemo2

{

       publicstatic void main(String[] args)

       {

              Ziz = new Zi(0);

              System.out.println(z.num);

       }

}

11.final关键字最终

1）.final作为一个修饰符，可以修饰类，函数，变量；

2）被final修饰的类是一个最终类，不可以被继承

3）被final修饰的方法是一个最终方法，不可以被覆盖

4）被final修饰的变量是一个常量，只能被赋值一次

被final修饰的变量，变量名全部大写，如果由多个单词组成，单词间通   过_连接，这是一种规范，不是强制的。

例如：

final int x=4;

X=4;//出错

final标记的成员变量必须在声明的同时或在该类的构造方法中显式赋值，      然后才能使用。

另补知识点：当我们用public static final 共同标记常量时，这个常量就     成了全局常量。而且这样的定义只能在定义时赋值或者在静态代码块中赋     值，即使在构造函数里面也不能对其进行赋值。

12.抽象类

1).当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。这时只抽取功能定义，而不抽取功能主体。

格式：修饰符 abstract 返回值类型函数名（参数列表）；

2).抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰（可以描述类和方法，不能描述变量）。

3，抽象方法只能定义方法声明，不能定义方法实现

4，抽象类不可以用new创建对象（实例化）。因为调用抽象方法没意义。

5，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

3).抽象类中的相关问题

1.抽象类中是否有构造函数？

有，抽象类是一个父类，要给子类提供实例的初始化。

2.abstract 关键字，和哪些关键字不能共存？

final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类。

private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。

而抽象方法出现的就是需要被复写。

static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。

3.抽象类中可不可以没有抽象方法？

抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

例如：

abstract class Employee

{

       privateString name;

       privateString id;

       privatedouble pay;

       Employee(Stringname,String id,double pay)

       {

              this.name= name;

              this.id= id;

              this.pay= pay;

       }

       publicabstract void work();

}

class Manager extends Employee

{

       privateint bonus;

       Manager(Stringname,String id,double pay,int bonus)

       {

              super(name,id,pay);

              this.bonus= bonus;

       }

       publicvoid work()

    {

              System.out.println("managerwork");

       }

}

class Pro extends Employee

{

       Pro(Stringname,String id,double pay)

       {

              super(name,id,pay);

       }

       publicvoid work()

       {

       System.out.println("prowork");

       }

}

13.模版方法模式

什么是模版方法？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。

例子：

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");

       }

              }

}

14.接口

1).接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。

2).interface 用于定义接口；class用于定义类

接口定义时，格式特点：格式：interface{}

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

       常量：publicstatic final

       方法：publicabstract

interface Inter{

public static final int x = 3;

public abstract void show();

}

记住：接口中的成员都是public的。

3).接口：是不可以创建对象的，因为有抽象方法。需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。否则子类是一个抽象类。

4).接口可以被类多实现，也是对多继承不支持的转换形式。<--java支持多实现。

5)类与类之间存在着继承关系，类与接口之间存在的是实现关系。

继承用extends；实现用implements；

接口和类不一样的地方，继是接口可以被多实现；

一个类在继承另一个类的同时，还可以实现多个接口；

接口与接口之间存在着继承关系，接口可以多继承接口（因为都是抽象类，没有方法主体）；

补充一点：java中存在多继承，但是只有接口与接口之间；在类与类之间是用多实现的方式表现多继承（类与类之间只存在单继承）。

6).接口的特点

1.接口是对外暴露的规则；

2.接口是程序的功能扩展；

3.接口可以用来多实现；

4.类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口；

5.接口与接口之间可以有继承的关系。

7).抽象类和接口异同：

相同：

1，都可以在内部定义抽象方法。

2，通常都在顶层。

3，都不可以实例化，都需要子类来实现。

不同点：

1，抽象类中可以定义抽象方法和非抽象方法，

       而接口中只能定义抽象方法。

2，接口的出现可以多实现。

       抽象类只能单继承。

       也就是说：接口的出现避免了单继承的局限性。

3，继承和实现的关系不一致。继承：is a，实现：like a

 

 

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