使用Java实现面向对象编程——第二章 继承

●继承是面向对象的三大特征之一，是JAVA实现代码重用的重要手段之一；

●继承是代码重用的一种方式，将子类共有的属性和行为放到父类中；

●JAVA只支持单继承，即每一个类只有一个父类，继承表达的是：子类与父类是is-a关系；

●在JAVA中，所有的JAVA类都直接或间接的继承了java.lang..Object类。Object类是所有JAVA类的祖先；

●在定义一个类时如果没有使用extends关键字，那么这个类直接继承Object类；

●继承可以解决代码复用，让我们的编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类(比如刚才的Student)，

●在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类：

●方便修改代码、减少代码

语法：class 子类 extends 父类

　　★子类就会自动拥有父类定义的某些属性和方法。

　　★不能被继承的父类成员：

　　　　●private成员

　　　　●子类与父类不在同包，使用默认访问权限的成员

　　　　●构造方法

父类：

狗类（子类（两种输出方式））：

企鹅类（子类（两种输出方式））

测试类：

第一中输出方式：super.

第二种输出方式：

第三种输出方式：

子类访问父类成员：

   使用super关键字来访问父类的成员,super代表父类对象

       ◆ super只能出现在子类的方法和构造方法中，而不是其他位置；

       ◆ 可以访问父类的成员，如父类的属性、方法、构造函数；

       ◆ super调用构造方法时，只能是第一句

       ◆ 注意访问的权限的限制，如super不能访问父类的private成员

　　子类可以从父类继承

　　　　◆父类的public修饰符的属性和方法；无论父类和子类是否在同一个包；

　　　　◆protected修饰符的属性和方法；无论父类和子类是否在同一个包；

　　　　◆默认修饰符属性和方法被子类继承了，子类和父类必须在同一个包；

　　子类不可以从父类继承：

　　　　★父类的private修饰符的属性和方法不能被子类继承。

　　　　★无法继承父类的构造方法；

多重继承关系的初始化顺序：

继承条件下构造方法的调用规则：

　　◆如果子类的构造方法中没有通过super显示调用父类的有参构造方法，也没有通过this显示调用自身的其他构造方法，则系统会默认先调用父类的无参构造方法。在这种情况下，有没有super()； 语句的效果是一样的；

　　◆如果子类的构造方法中通过super显示调用父类的有参构造函数，则执行父类相应的构造方法，而不执行父类无参构造函数；

　　◆如果子类的构造函数中通过this显示调用自身的其他构造方法，则在相应构造方法中应用以上两条规则；

　　◆如果存在多级继承关系，则在创建子对象时，以上规则会多次向更高一级父类应用，一直执行到顶级父类Object类的无参构造方法为止；

注意：

　　在构造方法中如果有this语句或者super语句出现，则只能是第一条语句；

　　在一个构造方法中不允许同时出现使用this和super语句调用构造方法（否则就有两条第一条语句）；

　　在类方法中不允许出现this或super关键字；

　　在实例方法中，thgis和super语句不要求是第一条语句，可以共存；

使用继承后效果：

使用重写效果：

◆方法重写的规则:

　　方法名相同；

　　参数列表相同；

　　返回值类型相同或者是其子类；

　　访问权限不能严于父类；

方法重载与方法重写：

　　注：构造方法不能被继承，因此不能重写；

重载与重写：

   重载涉及同一个类中的同名方法，要求方法名相同，参数列表不同，与返回值类型，访问修饰符无关；

     方法重载：简单的说：方法重载就是在类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。

　　　　注意事项：

　　　　　　1、方法名相同

　　　　　　2、方法的参数类型，个数，顺序至少有一项不同

　　　　　　3、方法返回类型可以不同(只是返回类型不一样，不能构成重载)

　　　　　　4、方法的修饰符可以不同(只是控制访问修饰符不同，不能构成重载)

  　　 重写涉及的是子类和父类之间的同名方法，要求方法名相同、参数列表相同、返回值类型相同（或是其子类）、访问修饰符不能严于父类；

abstract也可用于方法——抽象方法

  eg：

　　public abstract void print();

 注：

　　抽象方法没有方法体

　　抽象方法必须在抽象类里

　　抽象方法必须在子类中被实现，除非子类是抽象类

 每个子类的实现也不同：

public abstract class Pet {

       public void print() {

               //…

       }

}

抽象类是java中一个比较重要的类。

　　1、用abstract关键字来修饰一个类时，这个类就是抽象类。

　　2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法。

　　3、abstract抽象类中的abstract抽象方法是不允许在抽象类中实现的，一旦实现就不是抽象方法和抽象类了。abstract抽象方法只能在子类中实现。

　　4、抽象类中可以拥有实现方法。

抽象类--注意事项

　　1、抽象类不能被实例化

　　2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract抽象方法。

　　3、一旦类包含了abstract抽象方法，则这个类必须声明为abstract抽象类。

　　4、当一个子类继承的父类是abstract抽象类的话，需要把抽象类的抽象方法全部实现。

　　5、可以有0~多个抽象方法；

　　6、非抽象类必须重写父类的所有抽象方法；

　　7、抽象方法不能有主体。

          　　正确的抽象方法例：abstract void abc();

          　　错误的抽象方法例：abstract void abc(){}

父类：

狗类(子类)：@override用于检测是否为重写

测试类：

输出结果：

1、当不希望父类的某个方法被子类覆盖(override)时，可以用final关键字修饰。

2、当不希望类的某个变量的值被修改，可以用final修饰。如果一个变量是final，则必须赋初值，否则编译出错。

3、当不希望类被继承时，可以用final修饰。

注：

1、final修饰的变量又叫常量，一般用XX_XX_XX来命名。(带下划线)

2、final修饰的变量在定义时，必须赋值，并且以后不能再赋值。

            final float reate_1=3.1415926f  //圆周率不让修改，带有final修饰的变量命名时应有_下划线来区分表示

            final float reate_1=3.1415926f;//使用final可以保证，需要强制不被修改的数据一定要用final锁定

            final int b=0;  //定义类型后应赋值，使用final定义变量时一定要赋初值否则报错。

            final public void sendMes(){}//给成员方法用final来修饰则表示不可以被修改，不可被覆盖。

　　　　final class Bbb extends Aaa{}//定义类前加final表示该类不允许被继承

Penguin类不再被其他类继承

 //最终版的类

public final class Penguin extends Pet {

      //…

}

方法不被重写

//最终版的方法

public final void print () {

      //…

}

属性值不被修改

 //最终版的属性值

public class Penguin {

       final String  home ="南极";// 居住地

       public void setHome(String name){

       this.home=home; //错误，不可再赋值

    }

}

错误示例：//使用final修饰引用型变量，变量的值是固定不变的，而变量所指向的对象的属性值是可变的

class Dog {

    String name;

    public Dog(String name) {

        this.name = name;

    }

}

class Test {

    public static void main(String[] args) {

        final Dog dog = new Dog("欧欧");

        dog.name = "美美";

        dog = new Dog("亚亚");   //使用final修饰引用型变量，变量不可以再指向另外的对象

    }

}

包--三大作用

1、区分相同名字的类

2、当类很多时，可以很好的管理类

3、控制访问范围

包--换包命令

package com.自定义名字;

注意：打包命令一般放在文件开始处。

包--如何引入包

语法：import 包;

包--命名规范

小写字母

比如 com.sina.shunping

包--常用的包

一个包下，包含很多的类，java中常用的包有：

java.lang.* 包      自动引入

java.util.* 工具包

java.net.* 包      网络开发包 

java.awt.* 包 窗口工具包

●方法重写是在两个类存在继承关系时，子类可以重写父类中的同名方法，要求参数列表相同，访问权限不能严于父类，返回值类型与被重写方法相同或是其子类；

●java.lang包中Object的equals方法将比较两个对象是否相等，如果相等则返回true.

　　1.==是判断两个变量或实例是不是指向同一个内存空间

　　   equals是判断两个变量或实例所指向的内存空间的值是不是相同

　　2.==是指对内存地址进行比较

　　   equals()是对字符串的内容进行比较

　　3.==指引用是否相同

　　   equals()指的是值是否相同

注意：默认(friendly)访问修饰符的反访问范围是本来和同包中访问。

●JAVA只支持单继承，并且子类无法继承父类的构造方法；

●static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为：

类名.静态方法名(参数列表...)

类名.静态变量名

●eg：

分析：

面向对象三个特性是封装、继承、多态，其中，java的类是单继承的，不支持多继承，

即extends关键字后只能有一个类名称，即直接父类。

继承是is-a的相互关系，将子类转换成父类，在继承关系上面是向上移动的，所以一般称之为向上转型。

由于向上转型是从一个叫专用类型向较通用类型转换，所以它总是安全的，

第2和3行都是向上转型（即可以子类对象赋给父类类型变量，反之，则不对），第1行创建自己类型的对象，自然也是正确的

●父类如果写了有参数构造而没写无参构造，默认无参构造将无法调用，这时子类构造也就无法调用父类无参构造

（子类无参构造默认调用super（）且写在第一行。）；

●抽象类可以有子类，抽象类不能被实例化，抽象类中除了有抽象方法外，也可以有普通实例方法，声明抽象类和抽象方法都要使用abstract关键字

●抽象类不能使用私有访问修饰符修饰（即不能用private修饰）；

抽象方法不能使用final进行修饰（final和abstract不能同时修饰一个方法）；

抽象方法不能有实现。

抽象类不能创建对象，

抽象类的引用可以指向实现其抽象方法的子类的对象。

定义抽象类时，abstract关键字放在class之前；

●abstract是用来修饰抽象类的（abstract修饰符可修饰类和方法，不能修饰属性；）。

                    abstract型方法用于被子类实现，所以只能是public、protected关键字所修饰；

抽象类中可以同时存在抽象方法和非抽象方法，需要注意的是有抽象方法的类一定是抽象类。

static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块；

final修饰类中的属性或者变量,无论属性是基本类型还是引用类型，final所起的作用都是变量里面存放的“值”不能变。

final修饰类中的方法，作用：可以被继承，但继承后不能被重写。final修饰类，作用：类不可以被继承。

interface关键字是用来定义修饰接口的。与抽象想法不同的是，接口里的方法全都是抽象方法。

●抽象类和接口的区别：

●JAVA方法的特点：抽象、继承、多态；

●使用super可以调用父类的公有方法，调用父类的属性及父类的构造方法。并且，子类构造方法调用父类构造方法时，必须放在第一行；

●super明确显式地指出一个类可以它父类的构造函数、方法和变量；

调用父类的属性，一个类中如果有int x属性，如果其子类中也定义了int x属性的话，

在子类中调用父类的x属性时应用super.x，表示该x是引用的父类的属性，

而要表示子类中的x属性的话，使用this.x。调用父类方法也可以通过该关键字实现；

●如果没有使用super显示调用父类的构造函数，将自动调用默认构造函数；

 ●super关键字，在子类对象内部指代其父类对象的引用，可以用来调用父类中的成员。但是不能够直接将super输出。

●main方法的格式讲解public static void main(String[] args){}

public:公共的，访问权限最大的，由于main方法是被jvm调用的，所以权限要够大

static：静态的，不需要创建对象，通过类名就可以，方便jvm的调用

void:方法的返回值是返回给调用者，而main方法是被jvm调用，你返回内容jvm调用，你返回内容给jvm没有意义

main:是一个常见的方法入口，语言都是以main作为入口

String[] args:这是一个字符串数组，值去哪里了？这个东西早起是为了接受键盘录入的数据的。

●public：所有的类都可以访问。

private：只有在同一个类中才可以访问。

protected：同一个类中、同一个包中、子类中都可以访问，包类型的。

默认类型：同一个类中、同一个包中可以访问到

●final修改的类不能是抽象的，abstract修饰的方法要求子类中必须重写，final修饰的方法要求不能重写可以重载，

可以被static修饰，final和static可以同时去修饰类、变量和类的方法，顺序没有要求；

Java关键字final有“这是无法改变的”或者“终态的”含义,它可以修饰非抽象类、非抽象类成员方法和变量。

final修饰的为基本类型的，变量将变成常量。必须要在常量声明时对其进行初始化，常量名一般使用大写字母来表示，

字符常量使用单引号括起来，字符串常量使用双引号；

使用final关键字修饰一个变量为引用类型，是指引用地址不能变，引用变量所指向的对象中的内容还是可以改变的；

●final类不能被继承，没有子类，final类中的方法默认是final的。

final方法不能被子类的方法覆盖，但可以被继承。

final成员变量表示常量，只能被赋值一次，赋值后值不再改变。

final不能用于修饰构造方法。