黑马程序员__父子类中变量、函数、构造函数的特点、抽象类和模板方法模式

来源：互联网发布：马前课指算法图解编辑：程序博客网时间：2024/04/30 09:54

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

1、父子类中变量、函数、构造函数的特点：

a)       类中的成员：
                        i.             变量；
                      ii.             函数；
                    iii.             构造函数；
b)       变量：
                        i.             如果子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用 this ；子类要访问父类中的同名变量，用super。
                      ii.             super和this的用法相同
                    iii.             this代表本类应用
                     iv.             super代表父类引用
                       v.             当子父类出现同名成员时，可以用super进行区分；子类要调用父类构造函数时，可以使用super语句。
class Fu
{
    private int num = 4;
    public void setNum(int num)
    {
       this.num =num;
    }
    public int getNum()
    {
       return this.num;
    }
}

class Zi extends Fu
{
    int num = 5;
    void show()
    {
       System.out.println(num);
    }
}

class ExtendsDemo2
{
    public static void main(String[] args)
    {
       Zi z = new Zi();
       z.show();
       //System.out.println(z.num+"...."+z.num);
    }
}
子类也可以继承父类中的私有成员，但是在子类中不能直接访问父类中的这些私有的成员。

2、子父类中的函数：

a)      子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。
b)      当子类对象调用该函数，会运行子类函数的内容，如同父类的函数被覆盖一样。（重写只是一种形象的说法，其实父类中的该方法也已经加载到了方法区中，只是没有被调用运行而已。）
c)      父类中的私有方法不可以被覆盖。（但是编译可以通过，没问题可以运行），即使子类中出现重写父类中私有方法的方法也没有问题可以运行。
d)      在子类覆盖方法中，继续使用被覆盖的方法可以通过 super.函数名 获取。
e)      覆盖注意事项：
                    i.             覆盖时，被覆盖的子类方法权限一定要大于等于父类方法权限，但是子父类中的同名变量却没有这个限制，因为变量没有覆盖。覆盖只限于子父类中的非静态方法；（成员变量、成员方法的访问权限有 public ＞ package ＞ private ）
                ii.             静态只能覆盖静态，静态不能覆盖非静态。
1.      如果子类想覆盖父类中的静态方法，那么子类中定义的这个覆盖方法也必须得是静态的，否则将会编译失败。例如：
class AA
{
    public static int show(int a)
    {
       System.out.println("a="+a);
       return a;
    }
}
class BB extends AA
{
    public static intshow(int b)//子类覆盖父类中的静态方法//show，那么子类中的这个覆盖方法show也必须为静态的。如果 //子类的这个show方法不是静态的，并且（子类的这个）show方 //法的参数和返回类型还和（父类中的）一致的话，那么将会编   //译失败。这是经过验证的，也即这个show方法去掉static就会 //编译失败。
    {
       System.out.println("b="+b);
       return b;
    }
}
            iii.              重载：只看同名函数的参数列表。
                iv.             重写：子父类方法要一模一样（包括返回值类型，但是方法体可以不一样）。
f)      覆盖的应用：
                    i.             当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，既沿袭了父类的功能，又定义了子类特有的内容。

3、子父中的构造函数的特点：

a)      一般情况下，在对子类对象进行初始化时，父类的构造函数也会运行。那是因为子类的构造函数默认第一行有一条隐式的语句super();
b)      super():会访问父类中空参数的构造函数。而且子类中所有的构造函数默认第一行都是super();
c)      为什么子类一定要访问父类中的构造函数？
i.      因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化时，要先访问一下父类中的构造函数。
d) 如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式       来指定。
e) 注意：super语句一定定义在子类构造函数的第一行。
f) 子类的实例化过程:

结论：

1、子类的所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内的第一行都有一句隐式super();
2、当父类中没有空参数的构造函数时，子类的构造函数必须手动通过 this或者super语句指定要访问的构造函数。
3、当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
4、子类中至少会有一个构造函数会访问到父类中的构造函数。

为什么this语句或super语句必须在构造函数的第一行？

因为初始化动作要先做。

1、抽象类：

a)        抽象就是从多个事物中将共性的，本质的内容抽取出来。例如：狼和狗共性都是犬科，犬科就是抽象出来的概念。（当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。只抽取功能定义，而不抽取功能主体。）
b)      抽象：笼统的、模糊的、不具体的、看不懂的。
c)      Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
d)        抽象方法的由来：
i.           多个对象都具备相同的功能，但是功能具体内容有所不同，那么在抽取过程中，只抽取了功能定义，并未抽取功能主体，那么只有功能声明，没有功能主体的方法称为抽象方法。
ii.         例如：狼和狗都有吼叫的方法，可是吼叫内容是不一样的。所以抽象出来的犬科虽然有吼叫功能，但是并不明确吼叫的细节。
e)        抽象类的特点：
i.      抽象方法一定定义在抽象类中。
格式：修饰符 abstract 返回值类型函数名(参数列表);
ii.         抽象方法和抽象类都必须被abstract关键字修饰。
iii.        抽象类不可以被实例化，即不可以用new创建对象。因为调用抽象方法没意义。原因如下：
1.        抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。
2.        而且抽象类即使创建了对象，调用抽象方法也没有意义。
iv.       抽象类中的抽象方法要被使用，必须由子类复写该抽象类中所有的抽象方法后，建立子类对象来调用之。
v.         如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。
vi.       抽象类和一般类没有太大的不同。
1.        该如何描述事物，就如何描述事物。
2.        只不过，该事物出现了一些看不懂的东西，这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体，通过抽象方法来表示。
3.        抽象类比一般类多了个抽象函数。就是在类中可以定义的抽象方法。
4.        抽象类不可以实例化。
5.        特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。
f)          abstract关键字，和哪些关键字不能共存：
i.           final：被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类（不作为父类就没有意义了）。
ii.         private: 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法的出现就是需要被复写。
iii.        static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。
iv.       经验证知：抽象类中可以有私有（private）方法，但是private和abstract不能共同来修饰一个方法（也即不能写到一起）。
v.         经验证知：抽象类中可以有final方法，但是abstract和final不能同时修饰一个方法。
g)       抽象类中是否有构造函数？
i.           有，抽象类是一个父类，要给子类提供实例的初始化。这是经过验证的。但是接口没有构造函数。
h)        抽象（abstract）只能用来修饰类和方法，不能用来修饰变量。

由以下例子可知：子类不能继承父类的构造函数。
/*
假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：
姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个
奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方
法进行属性访问。
员工类：name id pay
经理类：继承了员工，并有自己特有的bonus。
*/
abstract class Employee     //定义的员工抽象类，因为该类含有抽象方法work，所以该类必须要用abstract来修饰。
{
       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 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("manager work");
       }
}

class Pro extends Employee      //定义的员工类
{
       Pro(String name,String id,double pay)//假如子类继承了父类的构造函数，那么就没必要再写这个构造函数了！
       {
              super(name,id,pay);
       }
       public void work()
       {
              System.out.println("pro work");
       }
}

1、模版方法模式：

a)        什么是模版方法设计模式呢？
i.         在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去。由该类的子类去完成。
ii.         例如：做月饼的模子，模子里面刻的字确定了，模子的花边确定了。至于往模子里面放什么由我来确定，这样可以做出来多种多样的、不同陷儿的月饼。
iii.        模版方法设计模式提高程序的扩展性、复用性。
b)        模版方法模式例子：
i.           需求：获取一段程序运行的时间。
ii.         原理：获取程序开始和结束的时间并相减即可。
iii.        获取时间：System.currentTimeMillis();

iv.       抽象类中可以有final方法。
v.         代码：
abstract class GetTime
{
       public final void getTime()//抽象类中可以有final方法，设置为                                       //final方法是为了拒绝其他类重写、覆盖该方法。
       {
              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)
       {
              SubTime gt = new SubTime();
              gt.getTime();
       }
}
这个例子能很好地说明模版方法设计模式，但是并不是说模版方法设计模式就是这个不会变了。在实际应用中还要根据具体需要做相应的修改、灵活运用。