[java核心技术01]__继承与多态、重载与重写、抽象类与接口

前言
前面简单学习了面向对象的知识,知道了其两个重要的特性,继承与多态,今天就围绕着面向对象的这两个特性,将继承与多态及相关的几个几个定义重载与重写,抽象类与接口的相关知识具体学习一下.

类的继承
关于类的继承定义,前面多少都有些了解了,可以简单的理解为父亲和儿子的关系,儿子会继承父亲的属性和方法,父亲就是父类,儿子就是子类.他们的关系就是继承关系.

继承是面向对象的重要观念,它的作用是巨大的,它使得程序架构具有一定的弹性,在程序中复用一些已经定义完善的类可以减少软件的开发周期,也可以提高软件的可维护性.

extends和implements关键字

在Java语言中继承可以使用 extends 和 implements (用于继承接口)这两个关键字来实现.

需要注意的是JAVA语言所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

Java语言中,类的继承是单一性的,即entends只能单一继承一个类.而implements的存在就是变相的实现了多继承,即一个类可以继承多个接口.接口会在后面讲到.

实例代码

package java02.day_4_12;

import My_tools.Boundlinetool;
import My_tools.FormatTimetool;

/**
 * @outhor xiaoshe
 * @date 2019/4/12  - @time 21:36
 */public class sty_extends {
    public
 static void main(String[] args) {
        father father = new father("小舍的父亲", "工人");
        son son = new son("小舍", "男", "程序员");
        System.out.println(father.getName());
        father.work();
        Boundlinetool.Minus();
        System.out.println(son.getName());
        son.work();
    }
}
// 构建父类
class father{
    private String name;
    private String work;
    // 成员方法
    public String getName() {
        return name;
    }
    public String getWork() {
        return work;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void setWork(String work) {
        this.work = work;
    }
    //构造方法
    public  father(String name,String work){
        this.work=work;
        this.name=name;
    }
    // 新增方法
    public void work(){
        System.out.println(this.work);
    }
}
// 构建子类
class son extends father{  // 通过extends 继承父类
     private String sex;  // 添加新属性.

    // 重写构造方法,属性不仅继承了父类属性,还将新属性添加其中.
    public son(String name, String sex,String work) {
        super(name, work);
        this.sex=sex;
    }
    @Override
    // 直接调用父类的成员方法,获取和设置成员属性.
    public String getName() {
        return super.getName();
    }
    // 重写父类的work方法
    @Override
    public void work(){
        System.out.println("子类"+super.getName()+"的工作是:"); // 重写内容
       super.work();  // 直接调用父类方法.
    }
}

重写(Override)与重载(Overload)
- 重写

就是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

我们在类的继承中知道子类不仅可以继承父类的属性方法,还可以定义自己的属性和方法,并且还可以对父类的方法进行重写,来实现自己的需求.重写在面向对象的思想里占重要的地位.它使程序具有了非常良好的扩展性.可以说能够通过重写方法解决一切问题.重写可以说是继承的一种特性.

 // 重写父类的work方法
    @Override
    public void work(){
        System.out.println("子类"+super.getName()+"的工作是:"); // 重写内容
       super.work();  // 直接调用父类方法.
    }

重载

重载就是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

就是说在类中方法的构建时,可以构建方法名相同而参数不同的方法,这就是方法的重载,重载在类的构造方法中使用的十分常见,我们经常会使用到某些类的构造方法,而且我们会发现通常情况下构造方法都会有很多个,可以通过不同类型的参数构建对象.这就是方法的重载.

多态

多态就是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作.其实继承,重写就是多态的一种体现,我们可以通过不同的子类重写父类的同一个方法来实现不同的结果.

多态的特性:
1. 消除类型之间的耦合关系
2. 可替换性
3. 可扩充性
4. 接口性
5. 灵活性
6. 简化性

多态存在的必要条件,就是继承,重写,父类引用指向子类对象.当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：
可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。
多态最常见的实现方式就是通过重写,或继承接口然后实现接口里的方法(其实就是通过重写接口里的方法来实现不同的作用).
抽象类和接口
抽象类

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。
实例代码

package java02.day_4_12;

/**
 * @outhor xiaoshe
 * @date 2019/4/13  - @time 0:55
 * 抽象类
 */
public class sty_Polymorphism {
    public static void main(String[] args) {
        woman woman = new woman("女", "黄"); // 尽管不能实例抽象类,但可以实例其子类对象.
        System.out.println(woman.getSex()); // 可以直接调用抽象类允许的方法.
        System.out.println( woman.getColor()); // 可以直接调用抽象类允许的方法.
    }
}
// 定义抽象类人类
abstract class humanity{  // abstact关键字用来定义抽象类
    private String sex;
    private String color;
    public String getSex() {
        return sex;
    }
    public String getColor() {
        return color;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public void setColor(String color) {
        this.color = color;
    }
   humanity(String sex,String color){  //构造方法
        this.color=color;
        this.sex=sex;
   }
    @Override
    public String toString() {  //重写toString方法
        return("性别:"+this.sex+"肤色:"+this.color);
    }
}
class woman extends humanity{  // 继承抽象类.woman类可以作为humanity类的一个对象,这就是向上转型.
    woman(String sex, String color) {  // 必须要有构造方法.
        super(sex, color);
    }
}

接口

接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

需要注意的是:接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
除非实现接口的类是抽象类，否则当该类继承这个接口后要定义接口中的所有方法。
接口同样无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

接口和类的区别:

接口不能用于实例化对象。
接口没有构造方法。
接口中所有的方法必须是抽象方法。
接口不能包含成员变量，除了 static 和 final 变量。
接口不是被类继承了，而是要被类实现。
接口支持多继承。

接口的特性:

接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract.
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别:

抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

关于抽象方法:

抽象方法就是只有方法名,而没有实现方法的方法体,需要在实现类里重写方法体来实现的方法.

public void work(String work);

接口的定义:
和了id定义类似的接口通过inteface关键字来定义.

interface man{
public void eat();
public void work();
public void play();
}

接口默认就是抽象的(abstract),所以不能实例化,接口的使用,必须被继承,并且其中的方法必须全部被定义实现.才能使用.

实例代码

package java02.day_4_12;

/**
 * @outhor xiaoshe
 * @date 2019/4/13  - @time 1:35
 */
public class sty_interface {
    public static void main(String[] args) {
        // 然后可以通过实例化接口的实现类的对象,来调用其方法,
        achieveman achieveman = new achieveman();
        achieveman.eat();
        achieveman.work();
    }
}
// 定义一个man接口
interface man{
    public void eat();  // 抽象方法
    public void work();
}
class achieveman implements man {
// 继承接口后,接口内的方法必须的全部实现
    @Override
    public void eat() {
        System.out.println("男人吃饭");
    }
    @Override
    public void work() {
        System.out.println("男人工作");
    }
}

更新时间:
2019-4-13
1:49

[java核心技术01]__继承与多态、重载与重写、抽象类与接口

猜你喜欢