7.1.2 实现继承
实现继承也就是创建一个类的子类，需要在类的生命中加入extends子句，其格式如下：
<修饰符> class <子类名> extends <超类名>
{
//实现代码
}
其中，参数class是关键字。子类名可以由用户随意定义，但必须要符合java标识符中的命名规范，
超类名也就是被继承的父类名，示例如下。
public class Son extens Father{
}
注意：在java中，一个类只有一个父类，也就相当于是一个孩子只有一个亲生父亲。
一个extends只能够指定一个类。
示例代码7-1是一个测试继承的程序
public class Minicar extends Car{
public static void main(String[] args){
MiniCar car=new MiniCar();
System.out.println("父类中车的颜色是:"+car.color);
car.setColor("blue");
System.out.println("子类中车的颜色是:"+car.color);
}
}
class Car{
String color="red";
public void setColor(String c){
this.color=c;
}
}
运行结果：程序运行结果如下。
父类中车的颜色是:red
子类中车的颜色是：blue
代码解析：在以上的程序中，实现的是一个比较简单的继承。首先定义了Car类，其中包含有字符串类型的color，
public类型的方法setColor。然后定义了类MiniCar，代表小汽车。类MiniCar继承自类Car，作为Car的子类，
类MiniCar没有定义自己的任何属性，方法也仅仅只有一个main方法。在main方法中，创建了类Car的一个对象car，
首先打印car的属性color，打印结果为red，然后，调用继承自类Car属性setColor，最后再次打印car的属性
color，打印结果为blue。
注意：在java中，子类无法继承父类中使用private修饰的类成员。如果将color的属性定义为private，则语句会报错。
--------------------------
总结：
1.public class Minicar extends Car 继承是这么实现的。要记住。
2.在java中，子类无法继承父类中使用private修饰的类成员。

7.2 继承关系
7.2.1 单一继承关系
单一继承关系，一个类只继承一个直接父类，这种也是比较简单的一种继承关系。
示例代码7-2是一个测试单一继承的程序。
public class MiniCar2 extends Car{
private int maxspeed;
public static void main(String[] args){
MiniCar2 car = new MiniCar2();
System.out.println("父类中车的颜色是:" + car.color);
car.setColor("blue");
System.out.println("子类中车的颜色是:" + car.color);
System.out.print("小汽车的最大速度是:");
car.setMaxspeed(180);
System.out.println(car.maxspeed);
}
public int getMaxspeed(){
return maxspeed;
}
public void setMaxspeed(int maxspeed){
this.maxspeed = maxspeed;
}
}
运行结果：运行结果如下：
父类中车的颜色是:red
子类中车的颜色是：blue
小汽车的最大速度是:180
代码解析:在以上程序的中，实现了单一继承关系，并在继承的同时，实现了类的扩展，
该示例和示例7-1类似，同样先定义一个Car类，即代表了各种汽车的基类。类car中包含了
String类型的属性color，public类型的方法setColor.然后定义了一个MiniCar类，代表小汽车。
类MiniCar同样继承了父亲Car的属性Color和setColor方法，除了继承父类外，类MiniCar还定义了
自己的属性maxspeed以及相应的获取与设置的方法getMaxspeed,setMaxspeed。main（）方法中先创建
类MiniCar的一个对象car，然后调用父类的属性和方法，并且进行打印，然后调用MiniCar自身的属性
方法进行打印。
---------------
总结：
其实没有什么可评价的。
就是一个单一继承的关系。在继承的同时，进行了类的扩展。

7.2.2 多重继承关系
在java中，一个类只可以继承一个父类，即只有单一继承，没有多重继承。但可以通过
实现接口的方法来达到多重继承的目的。
示例代码是一个测试多重继承的程序。
public class Sontest extends FatherTest implements Stepfather{
public void hitChild(){
System.out.println("这是继父");
}
public static void main(String[] args){
SonTest son = new SonTest();
son.pet("这是生父");
son.hitChild();
}
}
class FatherTest{
public void pet(String str){
System.out.println(str);
}
}
interface Stepfather{
public void hitChild();
}
运行结果：程序运行结果如下。
这是生父。
这是继父。
代码解析，在以上的程序中，首先定义了一个FatherTest类，作为父类，并在类中实现一个方法pet，实现打印输出。
然后定义了一个接口Stepfather,并在其中定义了一个方法hitChild()。最后创建类SonTest,继承类FatherTest并实现
接口Stepfather,在该类中实现接口中的hitChild方法，最后打印输出。
-----------------
总结：其实我不知道用这个破接口有什么鬼用处，不还是跟自己写个方法没有什么区别的么。
1.在java中，一个类只可以继承一个父类，即只有单一继承，没有多重继承
2.可以通过实现接口的方法来达到多重继承的目的

7.3 抽象类
抽象类是java中比较特殊的类，其中只包含有对方法的声明，而没有具体的实现。
在抽象类中，对所有的方法都只进行了声明而没有具体的实现。
抽象类中的方法需要声明方法的名称，但不用指明方法体。当要对问题域实行分析和设计，
得出抽象概念时可以使用抽象类，而且不能够被实例话，只能被继承扩展。在java中抽象
类的语法如下：
abstact class ClassName{
abstact ReturnType abstractMethodName(paramList);
//其他方法代码
}
在以上的语法代码中，abstract是关键字，表示此类是抽象类。class也是关键字。classname
则是抽象类的类名。类中的abstract表示该方法是一个抽象方法。returnType表示抽象方法的
返回类型，为合法的Java数据类型。abstractMethodName表示抽象方法的方法名。
示例代码7-4是一个测试定义抽象类的程序
public class SubClass extends AbstractClass{
public void speak{
System.out.println("我请大家去吃饭...");
}
public static void main(String[] args){
SubClass sc = new SubClass();
sc.speak();
sc.eat();
}
}
abstract class AbstractClass{
public void eat(){
System.out.println("我们一起去吃饭...");
}
public abstract void speak();
}
运行结果：程序运行结果如下：
我请大家去吃饭...
我们一起去吃饭...
代码解析：在程序中，首先定义了一个抽象类，类名为abstractClass。在该类中
包含有两个方法，一个为一般的方法eat()，另一个则是抽象方法speak()。需要
注意的是，在eat()方法中包含有方法体，有具体的方法实现过程，而speak()则被
abstract修饰，没有方法体，只是定义了方法的结构。然后定义了类sunClass，该类
继承了抽象类abstractClass。并且在该类中实现了抽象类中的抽象方法speak()，
最后在main()方法中创建了类subClass的对象，并分别调用eat()和speak()方法.
通过对以上的示例和语法的介绍，可以总结抽象类的特点如下：
至少含有一个抽象方法。
不能被实例化。
继承抽象类的子类必须实现其所有抽象方法才能够被实例话，否则该子类还是抽象类
------------------------------------
总结：属于比较重要级别，可以看看代码
1.至少含有一个抽象方法。
2.不能被实例化。
3.继承抽象类的子类必须实现其所有抽象方法才能被实例话，否则该子类还是抽象类。

7.4 使用关键字final
final是java中一个比较重要的关键字，可以用它来修饰成员变量，也可以用它来修饰方法
甚至还可以修饰一个类。如果成员变量被final修饰的话，这个成员变量就变成一个常量；
如果一个方法被final修饰，则这个方法不能被重写；如果一个类被final修饰，则这个类不能
被继承。
7.4.1 常量
在一个变量前使用final进行修饰，这个变量就会变成一个常量，也就是这个常量只能够被赋值一次。
可以不在它声明的那一行复制，但是需要在构造函数完成之前保证这个变量有一个值。
示例代码7-5 是一个测试final常量的程序。
public class Constant{
public static void main(String[] args){
ConstantTest ct = new ConstantTest();
System.out.println("a的值是:"+ct.print());
}
}
class ConstantTest{
int print(){
final int a = 10;
return a;
}
}
运行结果:程序运行结果如下。
a的值是:10
代码解析：在程序中，首先创建一个类constantTest类，并在其中创建方法print(),设置一个
变量a，使用final修饰。然后创建类constant，在其中创建 constantTest的对象ct，并调用
print方法，打印输出a的值。
如果定义为final的变量是静态变量，那它的赋值最晚不得迟于最后一个静态语句块的完成。
示例代码7-6是一个测试final常量的程序。
public class StaticConstant{
public static void main(String[] args){
StaticContantTest sct = new StaticContantTest();
System.out.println(sct.eat());
}
}
class StaticContantTest{
static final String str = "去吃饭....";
static String eat(){
return str;
}
}
运行结果-程序运行结果如下
去吃饭...
代码解析-在程序中，首先创建一个staticContantTest类，并在其中创建方法eat()，设置一个字符串类型变量str，
使用final修饰，然后创建类staticConstant，在其中创建 staticContantTest的对象sct，并调用eat()的方法，打印
输出str的值。
-----------------------------------
总结：属于简单级别，可以看看代码
1.如果定义为final的变量是静态变量，那它的赋值最晚不得迟于最后一个静态语句块的完成。
2.这句话什么意思呢，就是你丫是个变量需要赋值吧。静态语句块都没了，你也没用了。所以限定一个最晚时间。

7.4.2 方法
如果一个方法被final修饰了，那么这个方法就不可以被重写了，这提供了比较高的安全保证。
但是，final修饰方法应该小心使用，因为一旦使用了final关键字，那么被修饰ide方法就会失去一些
面向对象的优点。
示例代码7-7是一个测试final方法的程序
public class FinalMethod{
public static void main(String[] args){
FinalTest ft = new FinalTest();
ft.a = 50;
ft.print();
}
}
class FinalTest{
int a;
final void print(){
System.out.println("a的值是:"+a);
}
}
运行结果是程序的运行结果如下。
a的值是: 50
代码解析:在以上的程序中，首先定义了一个类finalTest，并在该类中定义了成员变量a和
一个final修饰的方法print(),在方法中打印输出a的值，然后定义一个类finalmethod，并在
主方法中创建finaltest的对象ft，并设置a的值，然后调用print()方法，打印输出a的值。
----------------------
总结：属于简单级别，可忽略。
1.如果一个方法被final修饰了，这个方法就不能被重写了。提供安全保证。

7.4.3 类
如果一个类被final修饰，那么这个类就不能在派生出子类，也就是说任何类都不能继承它。
只有当该类中的所有方法都不需要重写的时候，才能将该类定义为final类。
示例代码7-8是一个测试final类的程序
public class FinalClass{
public static void main(String[] args){
FinalClassTest fct = new FinalClassTest();
fct.eat = "该去吃饭了";
fct.str = " 十一点半";
fct.print();
fct.eat();
}
}
final class FinalClassTest{
Stirng str;
String eat;
void print(){
System.out.println("现在时间是"+str);
}
void eat(){
System.out.print(eat);
}
}
运行结果：程序运行结果如下：
现在时间是十一点半
该去吃饭了
代码解析：在以上的程序中，首先定义了一个类finalClassTest，并在该类中定义了成员变量str和eat，以及两个方法print()
和eat()，在方法中打印输出str和eat的值，然后定义了一个类finalClass，在主方法中创建FinalClassTest的对象fct，并设置
两个变量的值，最后调用print()和eat()方法，打印输出str和eat值
-------------
总结：属于简单级别，可以忽略正文
1.如果一个类被final修饰，任何类都不能继承这个家伙。

7.5 Object对象
java中，所有类的祖先类都是object，这是java中存在的比较特殊的类。如果一个类没有继承任何的类，
那么它默认是继承object类的。如果它继承了一个类，那么它的父类或者父类的父类也继承于object类。
也就是说，任何类都是object的子类。
7.5.1 object对象
Object类比较特殊，在实际的项目开发中会经常用到。定义一个object类型对象的数组，
根据前面继承的知识，它可以放置任何的类型，可以把几个不同的对象放置到object数组中。
但是放置进去后，对象的类型就会被丢弃了，在取出后需要进行类型的转换。
------------------
总结：属于比较重要级别，可以看正文。
1.任何类都是object的子类。