黑马程序员-JAVA基础-继承、抽象、接口

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、继承

1.概念：多个类中具有相同的属性和行为时，可以将相同的属性和行为提取出来放在单独一个类中，多个类就可以继承这个类，而不再需要定义这些属性和行为。多个类称为子类，单独一个类称为父类或超类。子类可以直接访问父类中非私有属性和行为。

2.好处：提高代码复用性；继承的出现让类与类之间产生关系，提供多态的前提。

例如：学生和工人都具有姓名和年龄，但是学生有学习功能，工人有工作功能，这是就可以将姓名和年龄提取出来

class Person{int age;//共性属性年龄String name;//共性属性姓名}class Student extends Person{public void study(){System.out.println("姓名："+this.name+"年龄："+this.age+"---学习");//特有学习方法}}class Worker extends Person{public void work(){System.out.println("姓名："+this.name+"年龄："+this.age+"---工作");//特有工作方法}}class ExtendsDemo{public static void main(String[] args) {Student s = new Student();s.age = 21;s.name = "lee";s.study();Worker w = new Worker();w.age = 30;w.name = "lisi";w.work();}}

3.特点：只支持单继承，支持多层继承

3.1子父类中变量的特点：子父类中存在相同的成员变量时，用this调用子类变量，用super调用父类变量。

class Fu{int num = 2;}class Zi extends Fu{int num = 6;void show(){System.out.println(this.num);//访问子类numSystem.out.println(super.num);//访问父类num}}class ExtendsDemo {public static void main(String[] args) {Zi z = new Zi();z.show();}}

3.2子父类中函数的特点：

覆盖：子类中有跟父类一模一样的函数，这就是覆盖。注意：父类的私有方法不能被覆盖；子类方法权限一定要大于父类的方法权限；静态只能覆盖静态。

应用：当子类要沿袭父类功能时，但子类又有自己的特有内容，这时就可以进行覆盖，可以通过super关键字访问父类的方法。

例如：手机以前只能显示电话号码和姓名，在更新换代后，不仅可以显示号码和姓名，还可以显示头像和归属地。

class Phone{void show(){System.out.println("姓名");System.out.println("电话号码");}}class newPhone extends Phone{void show(){super.show();System.out.println("归属地");System.out.println("头像");}}class ExtendsDemo2 {public static void main(String[] args) {newPhone p = new newPhone();p.show();}}

3.3子父类中构造函数的特点：

      子类的所有构造函数都会访问父类中的空参数构造函数。原因：子类要先知道父类是如何初始化父类中的数据

      子类所有的构造函数的第一行都有一条隐式的super();

      当父类中没有空参数构造函数时，子类必须通过super语句来指定要访问父类中哪个构造函数。

      子类中也可以通过this语句要指定访问本类中的构造函数。

class Fu{Fu(){System.out.println("父类运行");}}class Zi extends Fu{Zi(){System.out.println("子类运行");}}class ExtendsDemo3 {public static void main(String[] args) {//super(); 隐式的super语句Zi z = new Zi();//父类运行<span style="white-space:pre"></span>//子类运行}}

4. final关键字：

(1)可以修饰类、变量、方法
(2)被修饰的类不可以被继承
(3)被修饰的方法不可以被复写
(4)被修饰的变量是一个常量，只能赋值一次。便于阅读，变量名称都应大写、由多个单词组成，用_连接

(5)内部类定义在类的局部位置时，只能访问局部位置被final修饰的局部变量

二、抽象

1、概念：当多个类中出现相同的功能，但功能主体不同时，可以将相同的功能抽取出来放在一个类中，这是功能没有明确主体，调用没有意义，

             可以用abstract关键字修饰，同时这个类也要用abstract修饰。

例如：猫和狗都会叫，但猫是“喵喵叫”，狗是“汪汪叫”，这是叫的功能就可以抽取出来放在一个动物类中

abstract class Animal{//定义抽象的叫方法public abstract void shout();}//定义一个猫类class Cat extends Animal{//猫特有的叫方法public void shout() {System.out.println("喵喵叫");}}//定义一个狗类class Dog extends Animal{//狗特有的叫方法public void shout() {System.out.println("汪汪叫");}}

2、特点：

(1)抽象方法一定在抽象类中
(2)抽象方法和抽象类都要用abstract修饰
(3)抽象类不能用new创建对象
(4)抽象类中的抽象方法要被使用，必须由子类覆盖所有抽象方法，创建子类对象调用。
(5)如果子类只是覆盖一部分抽象方法，那么子类还是抽象类

3、注意事项：

（1）抽象类中是否有构造函数?

有，因为抽象类是父类，要给子类提供实例初始化

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

final关键字，被final修饰的类不能被继承。

private关键字，被private修饰，子类就不知道父类的功能，无法进行复写

static关键字，在抽象类中可以直接被调用，没有存在的意义。

4、练习

/*假如我们在开发一个系统时需要对员工进行建模，员工包含 3 个属性：姓名、工号以及工资。经理也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问*/abstract class Employee{private int id;//工号属性private String name;//姓名属性private double pay;//工资属性public void setId(int id){this.id = id;}public int getId(){return id;}public void setName(String name){this.name = name;}public String getName(){return name;}public void setPay(double pay){this.pay = pay;}public double getPay(){return pay;}//具有工号、姓名、工资的构造函数public Employee(int id,String name,double pay){this.id = id;this.name = name;this.pay = pay;}public abstract void work();//抽象的工作方法}class Manager extends Employee{private double bonus;//奖金属性public void setBonus(double bonus){this.bonus = bonus;}public double getBonus(){return bonus;}//具有工号、姓名、工资、奖金的构造函数public Manager(int id,String name,double pay,double bonus){super(id,name,pay);//调用父类构造方法this.bonus = bonus;}public void work(){System.out.println("经理工作");}}class AbstractTest {public static void main(String[] args) {Manager m = new Manager(1,"lee",5000.00,1000.00);m.work();}}

5、模板方法设计模式：当定义功能时，有一部分功能是确定的，但是有一部分功能没有确定，并且已经确定的功能要使用到没有确定的功能

      这时可以将不确定的功能暴露出去给子类实现。

例如：

/*定义一个类，里面有一个获取代码运行时间的功能分析：获取时间的功能是确定的，但是获取哪些代码运行的时间是不确定的可以将代码提取出来，由子类去完成*/abstract class getTime{public final void getTime(){long start = System.currentTimeMillis();runCode();long end = System.currentTimeMillis();System.out.println(start-end);}public abstract void runCode();}class subTime extends getTime{public void runCode(){for (int i=0; i<2000; i++){System.out.print(i);}}}class Template{public static void main(String[] args) {subTime st = new subTime();st.getTime();}}

三、接口（interface）
1.接口中成员的修饰符是固定的

成员变量：public static final 

成员函数：public abstract

2.特点：

接口是对外暴露的规则
接口是程序的扩展
接口降低程序的耦合性
类可以实现多个接口，这就是多实现
接口与接口之间可以继承，并且可以多继承