[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

人已赞赏
随笔日记

LIS3DH三轴加速度计-实现欧拉角(俯仰角,横滚角)

2020-11-9 4:21:33

随笔日记

MSCI将对MSCI中国全股票指数的过渡推迟至11月26日

2020-11-9 4:21:35

0 条回复 A文章作者 M管理员
    暂无讨论,说说你的看法吧
个人中心
购物车
优惠劵
今日签到
有新私信 私信列表
搜索