黑马程序员 第七篇 继承 （part 1） (Foundation; completed)

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

目录
1.什么是继承
2.修饰符
3.成员变量的覆盖
4.对象引用
5.方法的重写和重载

1.什么是继承

Java提供了单一继承，通过接口可以实现多重继承。

日常生活中，我们常遇到类似自行车和公路赛车的问题
自行车有颜色大小之分，公路赛车同样也有颜色大小之分，也多了一项特殊属性即速度的优势；自行车有的属性，公路车也有；公路车有的，自行车不一定有。

在Java中，遇到此类问题，可以通过继承来完成处理这类情况的功能。继承节省了定义新类中的大量工作，大大提高了代码的重用性。

//创建一个自行车类
public class bike
{
    public Sstring color'
    public int size;
}

//创建一个公路车赛车类
public class racing_cycle
{
    public String color;
    public int size;
    public String speed;
}

代码解析：既然公路赛车是自行车的一种，我们可以用自行车类定义自行车，然后通过继承来使公路赛车获得自行车的所有属性，而公路赛车类只需要定义自己所特有的属性和状态。

就好比公路赛车是自行车的一个升级版本，很自然地拥有了自行车的特性。

通过继承来简化上面的程序

public class bike
{
    public String color;
    public int size;
}
public class racing_cycle extends bike
{
    public String speed;
}

Java提供了单一继承，通过接口可以实现多重继承。

1.1 类的继承 （extends）

在Java中，被继承的类叫超类(super)，继承超类的类叫做子类(subclass)。
因此，子类是超类的一个功能上的扩展，它继承了超类定义的所有属性和方法，并且添加了特有的功能方法。

所有的类都继承自Java.lang.Object类，所以说Object类是Java中所有类的父类。如果在定义的类中不做特殊的规定，自己定义的类均直接继承自Object类。

特性总结:

• 通过继承定义类，可以简化类的定义，让所需要的功能相应的子类去定义和实现
• Java是单继承的，子类可以有很多，父类只能有一个。
• Java的继承是多层继承，一个类可以有很多子类，而子类下面又可以有很多子类
• 父类里的属性和方法可以使子类同样拥有，而子类的不能调用父类的方法和属性，子类的午餐构造器默认是调用父类的无参构造器。
• 父类没有定义一个无参的构造器，那么编译器就默认生成一个午餐的构造器，也可以在子类构造器里显示使用super方法调用父类构造器，super方法里写几个参数就可以表示调用的是父类的哪一个构造器。
• 一般情况下，定义了一个有参的构造器，就应该定义一个无参的构造器

1.2 继承的语法

语法
class 类名 extends 父类名称

2.修饰符

在定义类的一个成员变量和方法时，必须要指定成员变量或方法的访问权限，这时就需要使用到修饰符。修饰符是修饰的当前成员变量的访问限制和状态的。Java中的修饰符主要有public，protected，private，static和final。

修饰成员变量的修饰符主要有4个 public private default protected

2、final修饰符
final的意思是不可变，他可以修饰类、字段、方法。修饰类后类不能被扩展（extends），也就是不能被继承。修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。修饰方法后该方法不能被改变，也就是重写。
3、abstract修饰符
abstract是抽象的意思，用来修饰类和方法，修饰类后，该类为抽象类，不能被实例化，必需进行扩展。修饰方法后，该方法为抽象方法必须被子类重写（override）。
4、static修饰符
static用来修饰内部类，方法，字段。修饰内部类说明该内部类属于外部类而不属于外部类的某个实例。修饰字段说明该字段属于类而不属于类实例。修饰方法说明该方法属于类而不属于类实例。

详细参考
Java修饰符全解：

http://www.cnblogs.com/leokou/archive/2011/06/30/2094282.html

3.成员变量的覆盖

class fruit
{

    static String color = "蓝色";
    String size = "大";

    static String getFruirColor()
    {
        return color;   
    }

    String getFruitSize()
    {
        return size;
    }


}

public class apple extends fruit
{
    static String appleColor = "红色";
    String appleSize = "小";

    static String getFruitColor()
    {
        return appleColor;
    }

    String getFruitSize();
    {
        return appleSize;
    }


    public static void main(String[] args)
    {

        fruit f = new apple();
        System.out.println(f.getFruitColor());
        System.out.println(f.getFruitSize());


    }
}


输出结果

打印    蓝色
        小

静态方法无法重写

所有getFruitColor 返回蓝色

getFruitSize被重写返回小

4.对象引用

外部可以调用类来创建对象，比如上面在Test类中:

Human aPerson = new Human(160);

创建了一个Human类的对象aPerson。

上面是一个非常简单的表述，但我们有许多细节需要深入:

1. 首先看等号的右侧。new是在内存中为对象开辟空间。具体来说，new是在内存的堆(heap)上为对象开辟空间。这一空间中，保存有对象的数据和方法。
2. 再看等号的左侧。aPerson指代一个Human对象，被称为对象引用(reference)。实际上，aPerson并不是对象本身，而是类似于一个指向对象的指针。aPerson存在于内存的栈(stack)中。
3. 当我们用等号赋值时，是将右侧new在堆中创建对象的地址赋予给对象引用。

这里的内存，指的是JVM (Java Virtual Machine)虚拟出来的Java进程内存空间。内存的堆和栈概念可参考Linux从程序到进程。

参考资料
作者：Vamei 出处：http://www.cnblogs.com/vamei
对象引用
http://www.cnblogs.com/vamei/archive/2013/04/01/2992484.html

5.方法的重写和重载

5.1 方法重写的特点
5.2 方法重载的特点
5.3 重写的返回类型
5.4 重写是基于继承的
5.5 静态方法是不能重写的
5.6  三者之间的关系 
5.7 重写toString方法

5.1 方法重写的特点

方法重写也可以叫方法的覆盖，关键词为override。在子类本身的方法中，如果和所继承的方法具有相同的名称，便构成了方法的重写。重写的特点就是能够为各个子类定义特有行为。

静态方法不可重写。

关于自行车和公路赛车的相同点和不同点例子

class bike
{
    public void move()
    {
        System.out.println("速度慢的！");
}

public class racing_cycle extends bike
{

    public void move()
    {
        System.out.println("速度快的！");
    }

    public static void main(String[] args)
    {

        racing_cycle rc = new racing_cycle();
        rc.move();

    }

}

输出结果

打印    速度快的！

问题 如果把

racing_cycle rc = new racing_cycle();
换成

bike rc = new racing_cycle();

5.2 方法重载的特点

方法的重载就是指在一个类中，存在两个或者两个以上具有相同名称，不同参数的方法。

Java里重载的关键字为overload。

• 重载的方法名称相同，但方法的参数列表不同。如参数个数和参数类型等。
• 重载的方法和返回值可以相同也可以不相同。

示例代码如下

public String move() {}
public String move(String name) {}
public void move(String name, int spend) {}

代码说明:

• 虽然3种方法的名称是相同的，但这3种方法的参数列表，即个数和类型，是不相同的。
• 判断方法是否重载，看参数列别是很重要的。

一个重载的例子

class math
{
    public int add(int i, int j)
    {
        return i+j;
    }

    public float add(float i, float j)
    {
        return i+j;
    }

    public static void main(String args[])
    {
        math m = new math();
        System.out.println(m.add(1.0f, 2.3f));
        System.out.println(m.add(1, 2));
    }
}

输出结果:

打印  3.3
      3

5.3 重写的返回类型

方法有它的返回类型，而重写的方法也有返回类型，并有一些相应的限制。方法被重写后，返回的类型为基本类型时，重写方法的返回要必须一样，否则会出现错误。

如果返回类型是对象引用类型，重写的方法返回类型可以相同，也可以派生（父类的派生类，即子类）自被重写方法的返回类型。

以下演示一段错误的使用返回类型的代码

class math
{
    public int add()
    {
        return 10 + 15;
    }

}



public class son extends math
{
    public float add()
    {
        return 10 + 15;
    }


    public static void main(String[] args)
    {
        math m = new son();
        System.out.println(m.add());
    }
}


运行结果:

    代码编译不通过
因为该代码重写add() 但返回类型改变了，所以出错。

5.4 重写是基于继承的

重写和重载的产生是基于继承，如果没有发生继承就不会产生重写和重载了。在实际开发中，一定要注意继承是重写的基础，没有继承就不会存在重写。

class door
{
]

class wood_Door extends door
{
}

class math
{
    static public door getMes()
    {
        return new door();
    }
}

public class Son extends math
{
    static public wood_Door getMes()
    {
        return new wood_Door();
    }

    public static void main(String[] args)
    {
        math m = new Son();
        System.out.println(m.getMes());
    }
}


输出结果:

    door@61de33


代码解析


    父类和子类的getMes是被修饰为static类型的，static关键字表示这个方法为静态方法，具有唯一性，是个类方法。因为static类型的方法不能被重写，所以方法m.getMes() 调用的是父类的方法`getMes(){return new door();}`

5.5 静态方法是不能重写的

静态方法就是被修饰为static类型的方法，在类里声明具有唯一性，不是通过类的实例化而存在的，而是通过类的建立而存在，可以理解为用关键字new创建对象了，就是把这个对象实例化了。Java中的静态方法可以被继承，但是不可以被重写。

下面代码演示来说明静态方法不能被重写

class door
{
}

class wood_Door extends door
{
}

class math
{
    static public door getMes()
    {
        return new door();
    }

}


public class Son extends math
{
    static public wood_Door getMes()
    {
        return new wood_Door();
    ]


    public static void main(String[] args)
    {
        Son m = new Son();
        System.out.println(m.getMes());
    }
}




输出结果 

打印  wood_Door@61de33

这里调用了wood_Door的getMes()方法，因为创建对象的时候使

Son m = new Son()

区别于上一段代码的

math m = new math()

• 调用door的getMes()方法

因为编译期为math类型，又因为getMes方法被修饰为static类型的。所以对象引用m在运行期被强制转型为math类型

总结
==

 - 父类的静态方法可以被子类的静态方法覆盖
 - 父类的非静态方法不能被子类的静态方法覆盖
 - 父类的静态方法不能被子类的非静态方法覆盖
 - 覆盖用于父类和子类之间
 - 重写用在同一个类中，有相同的方法名，但参数不一样。

5.6 三者之间的关系
-----------

重写关键字是override，重载的关键字为overload，重写，重载，覆盖，都是基于继承的关系。当继承的关系放了，想用父类的方法就用super关键词来引用，如果想用新的方法了就重写，来完成新的功能需要。




对覆盖（重写也叫覆盖）的总结:
---------------

 - 覆盖的方法的参数列表必须要和被覆盖的方法的参数列表完全相同，才能达到覆盖的效果
 - 覆盖的方法的返回值必须和被覆盖的方法的返回值一致
 - 覆盖的方法锁抛出的异常必须和被覆盖的方法所抛出的异常一致，或者是其子类
 - 被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。


## 对重载的总结： ##

 - 使用重载时只能定义不同的参数列表
 - 不能通过重载的方法对返回类型，访问权限和抛出的异常来进行方法的重载

重写的总结如下
-------

 - 重写的方法存在于父类中，也存在于子类中
 - 重写的方法在运行期采用多态的形式
 - 重写的方法不能比被重写的方法有更高的访问权限
 - 重写的方法不能比被重写的方法有更多的异常


5.7 重写toString方法
----------------

toString方法是Java里Object类的方法，很多类都重写了该方法。该方法返回对象的状态信息。如果需要得到比较详细的状态信息，就需要对toString方法进行重写。

5.8 重写equals
------------

方法equals也是Object类的方法，很多类也进行了重写，一般重写equals方法是为了比较两个对象的内容是否相等。equals方法在两个比较的对象指向同一个对象的时候才会返回真值。如果需要进行比较详细的判断，就需要对equals方法进行重写。

equals的原型

public boolean equals(Object obj)
{
return (this == obj); //这里比较的是两个对象的引用
}

关于equals和==的区别总结
================

public class EqualTest {
public static void main(String[] args) {

//对于基本类型的变量。"=="和"equal"的区别 
int t1=57; 
int t2=67; 
int t3=124; 
int t4=124; 

//“==”对于基本数据类型，判断两个变量的值是否相等。 
Boolean result1=(t1==t2); 
Boolean result2=((t1+t2)==t3); 
Boolean result3=(t3==t4); 

System.out.println("/n/n-----【t1==t2】"+result1+"/n-----【(t1+t2)=t3】"+result2+"/n-----【t3=t4】"+result3); 
//“equal”不能用于基本数据类型。只能用于类变量。对于基本数据类型要用其包装类。 
Integer i1=new Integer(t1); 
Integer i2=new Integer(t2); 
Integer i3=new Integer(t3); 
Integer i4=new Integer(t4); 


Boolean ri1=i1.equals(i2); 
Boolean ri2=i3.equals(i1+i2); 
Boolean ri3=i3.equals(i4); 

System.out.println("/n/n-----【i1.equals(i2)】"+ri1+"/n-----【i3.equals(i1+i2)】"+ri2+"/n-----【i3.equals(i4)】"+ri3); 

//对于对象变量，"=="和"equal"的区别 

String st1="wasiker "; 
String st2="is super man"; 
String st3="wasiker is super man"; 
String st4="wasiker is super man"; 

Boolean b1=(st1==st2); 
Boolean b2=(st1+st2)==st3; 
Boolean b3=(st3==st4); 

System.out.println("/n/n-----【st1==st2】"+b1+"/n-----【(st1+st2)==st3】"+b2+"/n-----【st3==st4】"+b3); 

//因为对象变量的存储的是对象在内存中的路径，即内存地址。所以用“==”比较时，即使
//对象的值相等，但是他们的内存地址不同，所以==的结果为false。故“==”用于比较两
//个变量的值是否相等，而不是变量引用的对象是否相等

Boolean r1=st1.equals(st2); 
Boolean r2=(st1+st2).equals(st3); 
Boolean r3=st3.equals(st4); 

System.out.println("/n/n-----【st1.equals(st2)】"+r1+"/n-----【(st1+st2).equals(st3)】"+r2+"/n-----【st3.equals(st4)】"+r3); 

//equal用于比较两个对象是否相同。
}
}
“`

运行结果为：

—–【t1==t2】false
—–【(t1+t2)=t3】true
—–【t3=t4】true

—–【i1.equals(i2)】false
—–【i3.equals(i1+i2)】true
—–【i3.equals(i4)】true

—–【st1==st2】false
—–【(st1+st2)==st3】false
—–【st3==st4】true

—–【st1.equals(st2)】false
—–【(st1+st2).equals(st3)】true
—–【st3.equals(st4)】true

总之：
**“==”比较的是值【变量(栈)内存中存放的对象的(堆)内存地址】
equal用于比较两个对象的值是否相同【不是比地址】**

【特别注意】Object类中的equals方法和“==”是一样的，没有区别，而String类，Integer类等等一些类，是重写了equals方法，才使得equals和“==不同”，所以，当自己创建类时，自动继承了Object的equals方法，要想实现不同的等于比较，必须重写equals方法。

“==”比”equal”运行速度快,因为”==”只是比较引用.

reference:
http://blog.csdn.net/xcysuccess3/article/details/6557771

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