四、接口

一、继承

1.1、继承概念

将对象的共性抽取出来。提取出一个单独的类。

继承使用复用以前的代码非常容易，能够大大的缩短开发周期，降低开发成本，同时增加程序的易维护性

继承使重一个类A能够直接使用另外一个类B的属性和方法的一种途径

类A可以有自己的属性和方法通过 extends 关键字让类与类之间产生继承关系。

让类和类之间产生了关系，有了这个关系，才有了多态的特性。

注意：千万不要为了获取其他类的功能，简化代码而继承。

必须是类与类之间有所属关系才可以继承，所属关系是 is a.的关系

1.2、继承的实现

类的继承格式

在java中使用extends关键字完成类的继承关系，操作格式：

class 父类{} // 定义父类

class 子类 extends 父类{} // 使用extends关键字实现继承

1.3、继承的特点

子类继承父类的什么?

继承public 和PRotected修饰的属性和方法，不管子类和父类是不是在一个包中

继承默认权限修饰的属性和方法，子类和父类必须在同一个包中

注意：

JAVA只支持单继承，也就是一个类只能继承一个类

无法继承private修饰的属性和方法

无法继承父类的构造方法

子类继承了父类的所有属性（包括private）和方法或子类拥有父类的所有属性和方法是对的，只不过父类的私有属性和方法，子类是无法直接访问到的。即只是拥有，但是无法使用。

示例：

packagecom.study.day07.person;/*** 父类

*@authordenny

**/publicclassPerson {/*** name=姓名

* age=年龄

* 都是私有的*/privateString name;privateintage;/*** 无参数构造方法*/publicPerson() {

System.out.println("父类无参数的构造方法");

}/*** 有参数构造方法

*@paramname=姓名

*@paramage=年龄*/publicPerson(String name,intage) {this.name =name;this.age =age;

System.out.println("父类有参数的构造方法");

}/*** 显示信息方法*/publicvoidshow(){

System.out.println("父类show方法");

System.out.println("姓名: "+this.name+" \n年龄: "+this.age);

}/*** getterXxx和setterXxx方法

*@return*/publicString getName() {returnname;

}publicvoidsetName(String name) {this.name =name;

}publicintgetAge() {returnage;

}publicvoidsetAge(intage) {this.age =age;

}

}

子类

packagecom.study.day07.person;/*** 学生类继承父类

*@authordenny

**/publicclassStudentextendsPerson {/*** gender=性别

* 子类特有的属性*/privateString gender;/*** 子类无参数构造方法*/publicStudent() {super();//使用父类的构造方法

System.out.println("子类无参数构造方法");

}publicStudent(String name,intage,String gender) {/** 调用父类有参数的构造方法*/super(name,age);this.gender =gender;

System.out.println("子类有参数构造方法");

}publicString getGender() {returngender;

}publicvoidsetGender(String gender) {this.gender =gender;

}/*** 重写父类的方法*/@Overridepublicvoidshow(){super.show();//调用父类的方法,System.out.println("子类show方法");

System.out.println("性别: "+this.gender);//子类自己的方法体}

}

测试类

packagecom.study.day07.person;importcom.study.day07.person.Person;publicclassTest {publicstaticvoidmain(String[] args) {

Person s=newStudent("张三",20,"男");

s.show();

}

}

结果：

父类有参数的构造方法

子类有参数构造方法

父类show方法

姓名: 张三

年龄:20子类show方法

性别: 男

在子类构造函数执行时，发现父类构造函数也运行了。

原因：在子类的构造函数中，第一行有一个默认的隐式语句：super();

1.4、方法重写

上例中子类show()实现的对父类show()方法的重写.

/*** 重写父类的方法*/@Overridepublicvoidshow(){super.show();//调用父类的方法,System.out.println("子类show方法");

System.out.println("性别: "+this.gender);//子类自己的方法体}

在子类覆盖方法中，继续使用父类的方法可以通过super.函数名获取 ,super.变量名

什么时候使用覆盖操作？

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

注意：

1、父类中的私有方法不可以被覆盖。

2、父类为static的方法无法覆盖。

3、覆盖时，子类方法权限一定要大于等于父类方法权限。

1.5、子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数。

因为每一个构造函数的第一行都有一条默认的语句super();。

为什么子类实例化的时候要访问父类中的构造函数呢？

那是因为子类继承了父类，获取到了父类中内容（属性），所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。

注意：

1、当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

2、子类构造函数中如果使用this调用了本类构造函数，那么默认的super()，就没有了，因为super和this都只能定义在第一行，所以只能有一个。但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。

3、super语句必须要定义在子类构造函数的第一行！因为父类的初始化动作要先完成。

总结：

一个对象实例化过程，以Person p = new Person();为例：

1. JVM会读取指定的路径下的Person.class文件，并加载进内存，并会先加载Person的父类（如果有直接的父类的情况下）。

2. 在内存中开辟空间，并分配地址。

3. 并在对象空间中，对对象的属性进行默认初始化。

4. 调用对应的构造函数进行初始化。

5. 在构造函数中，第一行会先到调用父类中构造函数进行初始化。

6. 父类初始化完毕后，再对子类的属性进行显示初始化。

7. 再进行子类构造函数的特定初始化。

8. 初始化完毕后，将地址值赋值给引用变量。

二、final

final可以修饰类，方法，变量。

final修饰的类不可以被继承。

final修饰的方法不可以被覆盖。

final修饰的变量是一个常量，只能被赋值一次。

为什么要用final修饰变量，其实，在程序中如果一个数据是固定的。那么直接使用这个数据就可以了，但是这种阅读性差，所以应该给数据起个名称。而且这个变量名称的值不能变化，所以加上final固定。

写法规范：常量所有字母都大写，多个单词，中间用_连接。

/*final 修饰的变量是常量不可更改其值*/classFinalDemo{publicstaticvoidmain(String [] args){finalintx=5;

x=4;

System.out.println("x="+x);

}

}

结果:

三、抽象类和抽象类和方法3.1、抽象类概述

使用关键字abstract 来修饰

抽象定义：

抽象就是从多个事物中将共性的、本质的内容抽取出来。

例如：学生和老师都是人，人类就是抽象出来的共性。

抽象类：使用abstract 修饰。

抽象方法：Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。使用abstract来修饰

3.2、抽象类特点

抽象类和抽象方法必须用abstract关键字来修饰。

抽象方法只有方法声明，没有方法体，定义在抽象类中。

格式：修饰符 abstract 返回值类型 函数名(参数列表) ;

抽象类不可以被实例化，也就是不可以用new创建对象。

原因如下：

1. 抽象类是具体事物抽取出来的，本身是不具体的，没有对应的实例。例如：犬科是一个抽象的概念，真正存在的是狼和狗。

2. 而且抽象类即使创建了对象，调用抽象方法也没有意义。

3. 抽象类通过其子类实例化，而子类需要覆盖掉抽象类中所有的抽象方法后才可以创建对象，否则该子类也是抽象类。

示例：

packagecom.day08.abstrac.demo1;/*** 定义人类抽象类

*@authordenny

**/publicabstractclassPerson {/*** 定义属性

* name=姓名

* age=年龄

* gender=性别*/privateString name;privateintage;privateString gender;/*** 抽象方法*/publicabstractvoidlife();//生活方法/*** getter和setter方法

*@return*/publicString getName() {returnname;

}publicvoidsetName(String name) {this.name =name;

}publicintgetAge() {returnage;

}publicvoidsetAge(intage) {this.age =age;

}publicString getGender() {returngender;

}publicvoidsetGender(String gender) {this.gender =gender;

}

}

子类:

packagecom.day08.abstrac.demo1;/*** 老师类继承人类抽象类

* 必须实现人类中的抽象方法

* 如果不实现老师类必须是抽象类

*@authordenny

**/publicclassTeacherextendsPerson {

@Overridepublicvoidlife() {

System.out.println("教师的生活就是教学!");

}

}

3.3、抽象类相关问题

抽象类中是否有构造函数？

答：有，用于给子类对象进行初始化。

抽象关键字abstract不可以和哪些关键字共存？

答：private、static、final。

抽象类中可不可以没有抽象方法？

答：可以，但是很少见。目的就是不让该类创建对象，AWT的适配器对象就是这种类。通常这个类中的方法有方法体，但是却没有内容。

3.4、抽象类和一般类的区别?

相同点：

抽象类和一般类都是用来描述事物的，都在内部定义了成员。

区别：

抽象类不可以被实例化，一般类可以被实例化

抽象类可以有抽象方法和一般方法，一般类只能有一般的方法

抽象类描述事物的信息有可能不足。一般类有足够的信息描述事物。

抽象类一定是个父类吗？

答：是的，因为需要子类覆盖其方法后才可以对子类实例化。

四、接口4.1、接口定义

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口。

格式：interface 接口名 {}

接口中的成员修饰符是固定的：

成员常量：public static final 成员变量都是静态常量

成员函数：public abstract 所有方法都是抽象方法，可以不写abstract，只能是public，不能是其它的

由此得出结论，接口中的成员都是公共的权限。

接口是对外暴露的规则。

接口是程序的功能扩展。

P.S.

1、虽然接口类中的全局变量和抽象方法的修饰符都可以不用写，但是这样阅读性很差。所以，最好写上。

2、类与类之间是继承关系，类与接口直接是实现关系。

3、接口不可以实例化，能由实现了接口并覆盖了接口中所有的抽象方法的子类实例化。否则，这个子类就是一个抽象类。

4.2、接口的实现

类要实现接口要使用implements关键字

格式 class 类名 implements 接口名

1.实现接口时，实现接口中的所有方法

2.

示例：

分别定义接口鸟的叫和攻击方法都是抽象的

packagecom.day08.interfac.demo1;/*** 攻击接口

*@authordenny

**/publicinterfaceBirdAttack {/*** 攻击的方法

* 没有方法体*/publicvoidattack();

}

packagecom.day08.interfac.demo1;/*** 叫声的接口

*@authordenny

**/publicinterfaceBirdShout {/*** 叫的方法

* 没有方法体*/publicvoidshout();

}

火箭鸟

packagecom.day08.interfac.demo1;/*** 火箭鸟

*@authordenny

*攻击方式：火箭攻击

*实现了攻击的接口和叫的接口，所有要重写攻击接口中的叫方法和攻击方法

*接口可以实现多个，但继承只能有一个

**/publicclassFireBirdimplementsBirdAttack,BirdShout{

@Overridepublicvoidshout() {

System.out.println("火箭鸟喳喳叫!");

}

@Overridepublicvoidattack() {

System.out.println("火箭鸟发射火箭弾攻击!");

}

}

胖子鸟

packagecom.day08.interfac.demo1;/*** 胖子鸟

*@authordenny

* 叫声：唧唧叫

* 没有攻击，所以不需要实现攻击的接口

**/publicclassFatBirdimplementsBirdShout {

@Overridepublicvoidshout() {

System.out.println("胖子鸟唧唧叫!");

}

}

测试类

packagecom.day08.interfac.demo1;publicclassBirdTest {publicstaticvoidmain(String[] args) {//创建胖子鸟对象，并调用相应的方法FatBird fatBird=newFatBird();

fatBird.shout();//创建火箭鸟对象，并调用相应的方法FireBird fireBird=newFireBird();

fireBird.shout();

fireBird.attack();

}

}

结果

胖子鸟唧唧叫!火箭鸟喳喳叫!火箭鸟发射火箭弾攻击!

以上例子中，实现的，行为和类的分离，需要哪个就实现哪个接口，没有就不要实现

接口的出现将“多继承”通过另一种形式体现出来，即“多实现”。

java将多继承机制进行改良，在java中变成了多实现，一个类可以实现多个接口。

接口的出现避免了单继承的局限性。

4.3、抽象类和接口

相同点：

抽象类和接口都不能被实例化

都是不断向上抽取而来的。

区别：

1. 抽象类需要被继承（extends），而且只能单继承。

接口需要被实现，而且可以多实现。(implements)

2. 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。

接口中只能定义抽象方法，必须由子类去实现。

3. 抽象类的继承，是is a关系，定义该体系的基本共性内容。

接口的实现是like a关系。