黑马程序员_Java面向对象——继承

------- android培训、java培训、期待与您交流！ ----------
Java面向对象——继承
Java面向对象的第二大特性就是继承。一个类如果包含着和其他类一样的行为和属性，那么我们在定义子类时，继承这个父类，以便拥有这个类的行为和属性。由此可以发现继承可以提高代码的复用性，这只是继承好处的其中之一，继承给我们程序开发带来的不只是代码的复用性，他有着太多太多的好处。让我们慢慢地体会吧。

继承就是拥有父类的某些行为和特征。在java的世界里，所有的类都是继承至基类Object，所有的类都有着Object的行为和特性。
一、定义：

一个类继承另外一个类，那么这个类叫做子类，被继承的类叫做父类（也叫做基类或超类）如:

A继承了B，那么A就是B的子类，而B是A的父类（基类或超类），A继承了B，A就有B的行为和属性。
如果一个类承至另外一个类，那么用关键子“extends”声明如下：
class B
{

}
class
A extend B
{
}
例子：人类是一个类，他描述着所有人的个体的共同个性，在人类的下面又有，儿童，妇女，老人，年经人，学生，老师等。我们用java语言来描述上述：
图下：



1、人类：
分析：对于现代人类来说，他都有着姓名，年龄，吃等等。
class person
{

String name=null;

int age=0;

public person(String name,ing age)
{

this.name=name;

this.age=age;

}

public void eat(String feed)
{

System.out.println(name+“在吃”+feed);
}
}
2、农民
分析：农民也是人类的一种，同用有着名字，年龄，吃等。
class farmer extends
{

public Farmer(Stirng name,ing age)
{

super(name,age)

}
}
3、学生：
分析：学生也是人类的一种，同用有着名字，年龄，吃等
class Student extends
{

public Farmer(Stirng name,ing age)
{

super(name,age)

}
}
4、工人：
分析：工人也是人类的一种，同用有着名字，年龄，吃等
class Worker extends
{

public Farmer(Stirng name,ing age)
{

super(name,age)

}
}
5常景类：
public class client
{

public static void main(String[] args)

{

Farmer farmer=new Farmer(“刘三”,35)

Student student=new Student(“小明”，15);

Worker worker=new Worker(“张打铁”,30);

farmer.eat(“玉米”)

student.eat(“馒头”);

student.eat(“盒饭”);
}
运行结果为：

刘三在吃玉米

小明在吃馒头

张打铁在吃盒饭。
我们分别在三个子类中继承了Person类，然而在子类并没有定义eat方法，而这三个方法中却有了eat这个方法。说明了eat是从Person中继承而来。这可以说得过去，因为是人的话，总是要吃东西的。吃东西，这是人的共同特性。
总结：把一类事物特有我共性抽取出来，封装成一个类，然后拥有这个类的特性的其他类只要继承这个类即可。提高了代码的复用性和降低代码的复杂性以及简化代码。继承了这个类的子类就成为了这个类的体系。拥有这个类的共性。
二、抽象类

上面我们定义的人类中，我们只定义了人类有吃的行为，并不是说人类只有吃的行为，他还应该有劳动，睡觉等等行为。这些的表现行为都各不相同。但是他们确实有这些行为，只有行为的方式不周罢了。

如代码如下:
class farmer extends//农民类
{

public Farmer(Stirng name,ing age)
{

super(name,age)

}

public void work()
{

System.out.println(“农民的工作是耕作”);
}
public void sleep()
{

System.out.println(“农民在家里卧室睡觉”);
}
}
class Student extends//学生
{

public Student (Stirng name,ing age)
{

super(name,age)

}

public void work()
{

System.out.println(“学生的工作是学习”);
}
public void sleep()
{

System.out.println(“学生在寝室睡觉”);
}

}
class Worker extends//工人
{

public Worker (Stirng name,ing age)
{

super(name,age)

}

public void work()
{

System.out.println(“工人的工作是生产产品”);
}
public void sleep()
{

System.out.println(“工人在宿舍睡觉”);
}
}
看看上面这几个类，都有着工作和睡觉的行为。只是它们的行为不同，这时就用到了抽象类。把一类事物抽象的共同特性抽取出来，定义成抽象类，然后让其子类分别去实现各自的行为。这就是抽象。如下：
class abstract person
{

String name=null;

int age=0;

public person(String name,ing age)
{

this.name=name;

this.age=age;

}

public void eat(String feed)
{

System.out.println(name+“在吃”+feed);
}
public abstract void work();
public abstract void sleep();

}
class farmer extends//农民类
{

public Farmer(Stirng name,ing age)
{

super(name,age)

}

public void work()
{

System.out.println(“农民的工作是耕作”);
}
public void sleep()
{

System.out.println(“农民在家里卧室睡觉”);

}
}
class Student extends//学生
{

public Student (Stirng name,ing age)
{

super(name,age)

}

public void work()
{

System.out.println(“学生的工作是学习”);
}
public void sleep()
{

System.out.println(“学生在寝室睡觉”);

}

}
class Worker extends//工人
{

public Worker (Stirng name,ing age)
{

super(name,age)

}

public void work()
{

System.out.println(“工人的工作是生产产品”);
}
public void sleep()
{

System.out.println(“工人在宿舍睡觉”);

}
}
每个子类分别继承了Person类，并实现了抽象方法，场景如下：
public static void main(String[] args)

{

Person p=new Farmer(“刘三”,35)

p.eat(“玉米”);

p.work();

p.sleep();

p =new Student(“小明”，15);

p.eat(“馒头”);

p.work();

p.sleep();

p =new Worker(“张打铁”,30);

p.eat(“盒饭”);

p.work();

p.sleep();
}
运行结果：

刘三在吃玉米
农民的工作是耕作
农民在家里卧室睡觉

小明在吃馒头
学生的工作是学习
学生在寝室睡觉

张打铁在吃盒饭。
工人的工作是生产产品
工人在宿舍睡觉
总结：1、抽象类就把事物的不定确性的行为抽取出来，抽象成这一类事物的抽象描述，简单说，就是不具体的描述。然后让其子类去实现各自的行为。

2、抽象方法只定义了事物的共有特性，没有对事物的该行为进行任何的具体实现。

3、抽象类，他约束了子类的行为特征。换句话说就是只要一个类继承了抽象类，那么这个子类就有着抽象类的该行为。正因为这一定，抽象类实现了多态，何为多态呢，就是一个对象，多种状态，就叫做多态。如上面的对象p他即是农民，也是学生和工人。
抽象类的特点：

1、
抽象类不能被实例化。因为抽象类含有抽象方法，实例了抽象类没有什么意义。

2、
继承了抽象类的子类必须实现其抽象方法，如果未能实现，子类必须声明为抽象类。

3、
抽象方法不能是私有的。因为私有的方法只能在类的内部可见。无法继承。

4、
抽象方法不能修饰为静态方法，因为静态方法直接用类名调用，而抽象方法未有逻辑实现。

5、
抽象类不能修饰为final。因为final修饰的类是不可以被继承的。
何时使用抽象类：
1、
如果一类事物被抽取出来，但又不确定其逻辑功能的实现时，就定义成抽象类。
2、
抽象类必须使用abstract关键字声明。如果有抽象方法，用abstract关键字声明，且没有方法体。
3、
抽象类可以没有抽象方法。
三、更加抽象——接口

接口在我们现实生活中无处不在，例电脑的PIC插槽，USB等等。那么软接口，又指的是什么呢？

接口定义了一序列的行为，这些行为在不同的子类中有不同的实现，然后把实现了接口的类赋给接口，从而实现了多态。从这可看出，接口是对一序列行为进行规范，从而约束了子类必须按照此规范去实现行为。简而言之，接口就是一组行为规范，它规范了子类的行为准则。

1、
接口的定义
（1）定义接口用interface。
（2）接口只能定义常量和抽象方法。
（3）抽象方法不能有逻辑实现（方法体）。
例如：现代电脑外连设备都是USB接口，不管是什么类型的设备，只要实现了USB接口，就可以使用它。这用java来描述是：
interface IUSB
{

public static final String SHAPE=”
Rectangular”;

public static final int WIDTH=20;

public static final int HEIGTH=10;

public void open();

public void close();
}

class Computer//电脑
{

public void USB(IUSB usb)//电脑提供USB接口。
{

usb.open();

usb.close();
}
}
class Mouse implement IUSB//鼠标
{

public Mouse(int width,int height)

{

if(!(WIDTH==width&&HEIGTH==height))

{

System.out.println(“usb型号不对”);

return;

}

}

public void open()

{

System.out.println(“usb已经插入”);

System.out.println(“鼠标在工作中”);
}

public void close()

{

System.out.println(“usb已经拔出”);
}
}

class Key implement IUSB//键盘
{

public Mouse(int width,int height)

{

if(!(WIDTH==width&&HEIGTH==height))

{

System.out.println(“usb型号不对”);

return;

}

}

public void open()

{

System.out.println(“usb已经插入”);

System.out.println(“键盘在工作中”);
}

public void close()

{

System.out.println(“usb已经拔出”);
}
}
class Client
{

public static void main(String[] args)
{

IUSB mouse=new Mouse(20,10);

Computer computer=new Computer();

computer.USB(mouse);

IUSB key=new Key(20,10)

computer.USB(key);
}
}
运行结果：

usb已经插入

鼠标在工作中

usb已经拔出

usb已经插入

键盘在工作中

usb已经拔出
看看，电脑只提供了接口，只要实出了接口规则的设备都能插入进去。
总结：1、接口定义了一组规则，然后面向接口编程，后期再把实现了接口规则的子类传进去，使得编程时，不依赖细节。提高了代码的可扩展性。

2、当需求发生改变时，新建一个类实现接口，在子类里重新定义新功能，然后再把新对象传进去即可，而不必修改原来的逻辑实现。提高了代码的可维户性。
何时使用接口呢？

1、
当一个模块的实现功能经常要变动，以便适应需求时，就可以使用接口。使软件架构和逻辑功能实现分离。从而逻辑的改变不会影向到软件的架构。使软件模块间松藕。

2、
团队协作时，可以使用接口，一个团队开发软件架构，另一个团队开发功能实现。只要接口定义出来，在接口的约束下，可以同步开发模块。最后拼接成软件。
使用接口要主意的事项：

1、接口不能实现化。能只由子类完全实现其接口定义的
方法后，才可以由子类实例化。

2、接口不能定义构造函数。

3、接口的成员默认都是公有的。

4、接口只能定义学量，而不能定义变量。

5、接口的方法都是抽象的，不能有方法体。

6、接口的方法不能使用 static
、final关键字修饰。
7、子类如果不能实现全部的抽象方法，那么子类也是抽象的，需要声明为抽象。
抽象类和接口的区别。

1、
解决问题的不同，抽象类是专注于一类事物的共性只是每个共性的表现形式很抽象。而接口是解决模块间的通信，使模块间的依赖关系降低。简单说，就是抽象类专注于实现内容而接口专注于模块间的通信契约。

2、
抽象类可以有构造孔函数、一般函数以及抽象函；而接口只能定义常量和抽象方法。

3、
抽象类只能单继承，因为java的继承机制导致，而java可以通过接口实现多继承。