java面向对象编程的实现

最新推荐文章于 2024-08-01 10:07:38 发布

海绵宝宝养的的小窝

最新推荐文章于 2024-08-01 10:07:38 发布

阅读量2k

点赞数 3

分类专栏： Java学习文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/qq_59689127/article/details/121322026

版权

Java学习专栏收录该内容

23 篇文章 2 订阅

订阅专栏

前言

我们都知道java是一门面向对象的语言，但它具体又是通过怎样实现的呢？

本文将详细介绍java语言面向对象编程的实现。

包

包（package）是组织类的一种方式，使用包的主要目的是保证类的唯一性.

我们知道如果在一个java文件下写了两个同名的类，编译器会报错。

但如果我们在不同的包下面写入相同的类名却不会报错。

java已经提供了许多现成的类供我们使用。如下图所示，util是一个包，Arrays是包中的一个类，tostring是类下面的一个静态方法，因此可以直接通过类名调用。

要注意的是导入只能导入包中一个具体的类，而不能直接导入一个包。

我们有时也看到过这种写法java.util.*，这种 “ * ”叫做通配符，当你调用该包中的类的方法时，他才会导入类（很nice），与c语言的include不同，include直接导入该文件下的所有方法。

但是我们一般建议直接写出调用的类。因为通配符容易犯错。

java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配，编译器不知道你要调用哪个，因此报错了。正确的写法是导入java.sql.Date或java.util.Date。

但如果你导入两个类名中都有的date，编译器同样会报错哦。

当我们创建一个包时，会在对应的文件夹中产生一个包的文件夹，而在该包中创建的类也会出现在该文件夹下。

当然，能创建包我们也自然能调用包，就如同java已写好的一样，在前面加入import加上包的名字就能进行调用包中的各种方法。

常见的系统包

1. java.lang: 系统常用基础类 (String 、 Object), 此包从 JDK1.1 后自动导入。

2. java.lang.reflflect:java 反射编程包 ;

3. java.net: 进行网络编程开发包。

4. java.sql: 进行数据库开发的支持包。

5. java.util: 是 java 提供的工具程序包。 ( 集合类等 ) 非常重要

包访问权限

我们已经了解了类中的 public 和 private。 private 中的成员只能被类的内部使用 .

如果某个成员不包含 public 和 private 关键字 , 此时这个成员可以在包内部的其他类使用 , 但是不能在包外部的类使用。

总结：包是我们面向对象编程的一个重要方式，可以实现分工合作及简化我们的操作。

继承（extends）

代码中创建的类, 主要是为了抽象现实中的一些事物(包含属性和方法).

有的时候客观事物之间就存在一些关联关系, 那么在表示成类和对象的时候也会存在一定的关联.

当我们写了如上图所示的两个类时，我们发现它们有许多重复的字段和方法，这就叫做共性。 共性是指具有相同的属性或方法。于是我们有了另一种思路，将共性抽取出来重新再创一个类：

这种方式叫做继承。 因此我们也说继承就是对具有共性的事物进行抽取再创一个新类作为父类，具有共性属性的作为子类。

extends 英文原意指 " 扩展 ". 而我们所写的类的继承 , 也可以理解成基于父类进行代码上的 " 扩展 ".

例如我们写的 Bird 类，就是在animal基础上扩展了翅膀属性和fly方法。

被继承的叫做父类，继承父类的叫做子类。 在Java中，一个类只能继承一个父类，就像我们只能有一个父亲一样。子类继承了父类之后，父类里所有 不加private修饰的属性或方法子类都能调用。

因为我们还没给name赋予初值，所以String类型默认为null。

于此，我们还能进行优化，为父类增加一个构造方法，使子类定义的时候就不必再重新赋值。

但当我们为父类构造方法后，发现子类报错了，这又是为啥呢？

原来，子类在继承父类时，会默认调用父类的无参数的构造方法，而当父类没有写自己的构造方法时，编译器会默认生成一个不带参数的构造方法，如下图：

而父类写了一个构造方法后，编译器便不会再生成一个默认的无参构造方法（也就是父类里没有了无参的构造方法），而子类默认调用的又是父类的无参构造方法，于是编译器就报错了。于是我们得出了一个重要结论：子类构造的同时，要先帮助父类进行构造。

那子类什么时候构造，在构造方法之后就构造完成。

也就是说，如果在子类构造方法里，必须将super放在第一行，突出"先".

说了这么多，那么super是干什么的呢。

super其实就是让编译器确定你要用的是父类的哪个构造方法，而且调用父类的构造方法要与子类的形参类型对应上。下图这样就不行。

如果子类里又重新定义了一个与父类重名的字段或方法又会怎么样呢？

我们发现当子类与父类有重名时，会优先调用自己类中的字段或方法。

当我们在name前加入super修饰时，他就会调用父类的name。

super修饰：

protected关键字

前文说了非private修饰的字段或方法在子类中是可以使用的，但将字段或方法设置为public或友好型（包访问权限）都不符合我们“封装(private修饰)”的初衷，因为如果子类不在同一个包下，那么子类的继承限制就太多。此时protect关键字就应运而生。

protect：①对于类的调用者来说, protected 修饰的字段和方法是不能访问的

对于类的子类和 同一个包的其他类 来说 , protected 修饰的字段和方法是可以访问的。

当我们在三个不同包下创建了三个类时，子类继承父类的protected的字段或方法时并没有报错。

但在一个普通类下跨包调用animal时会无法通过编译。

小结：

什么时候下用哪一种呢?

我们希望类要尽量做到 "封装", 即隐藏内部实现细节, 只暴露出必要的信息给类的调用者.

因此我们在使用的时候应该尽可能的使用比较严格的访问权限. 例如如果一个方法能用 private, 就尽量不要用 public.

另外, 还有一种简单粗暴的做法: 将所有的字段设为 private, 将所有的方法设为 public. 不过这种方式属于是对访问权限的滥用, 还是更希望我们能写代码的时候认真思考, 该类提供的字段方法到底给 "谁" 使用(是类内部自己用, 还是类的调用者使用, 还是子类使用).

更复杂的继承关系

public animal{

}

public Vegetarian animal extends animal{

}

public cattle extends Vegetarian animal{

}


...........


//等等

如刚才这样的继承方式称为多层继承, 即子类还可以进一步的再派生出新的子类.

时刻牢记, 我们写的类是现实事物的抽象. 而我们真正在公司中所遇到的项目往往业务比较复杂, 可能会涉及到一系列复杂的概念, 都需要我们使用代码来表示, 所以我们真实项目中所写的类也会有很多. 类之间的关系也会更加复杂.

但是即使如此, 我们并不希望类之间的继承层次太复杂. 一般我们不希望出现超过三层的继承关系. 如果继承层次太多, 就需要考虑对代码进行重构了.

如果想从语法上进行限制继承, 就可以使用 final 关键字。

final

我们曾经学过final修饰字段时，表示常量不能被修改。

final int a = 10;

a = 20;	// 编译出错

final 关键字也能修饰类, 此时表示被修饰的类就不能被继承.

final public class Animal {

...

}

public class Bird extends Animal {

...

}

//	编译出错

final 关键字的功能是限制类被继承

"限制" 这件事情意味着 "不灵活". 在编程中, 灵活往往不见得是一件好事. 灵活可能意味着更容易出错.

是用 final 修饰的类被继承的时候, 就会编译报错, 此时就可以提示我们这样的继承是有悖这个类设计的初衷的.

我们定义一个String类型，将鼠标放到String上，按住ctrl，在点击一下String，就能看到如下画面

这说明我们平时是用的 String 字符串类, 就是用 final 修饰的, 不能被继承.

组合

和继承类似, 组合也是一种表达类之间关系的方式, 也是能够达到代码重用的效果.

例如表示一个学校:

public class Student {

...

}

public class Teacher {

...

}

public class School {

public Student[] students;

public Teacher[] teachers;

}

组合并没有涉及到特殊的语法(诸如 extends 这样的关键字), 仅仅是将一个类的实例作为另外一个类的字段.

这是我们设计类的一种常用方式之一.

组合表示 “ has - a”的关系，在刚才的例子中, 我们可以理解成一个学校中 "包含" 若干学生和教师.

继承表示“ is - a”的关系，比如之前的狗是一个动物。

多态

向上转型

在刚才的例子中, 我们写了形如下面的代码

Bird bird = new Bird("hehe");

这个代码也可以写成这个样子

Bird bird = new Bird("hehe");

Animal bird2 = bird;

//	或者写成下面的方式

Animal bird2 = new Bird("hehe");

此时 bird2 是一个父类 (Animal) 的引用, 指向一个子类 (Bird) 的实例. 这种写法称为向上转型.

至于为啥叫 "向上转型"?

通过查阅资料得知：在面向对象程序设计中, 针对一些复杂的场景(很多类, 很复杂的继承关系), 程序猿会画一种 UML 图的方式来表示类之间的关系. 此时父类通常画在子类的上方. 所以我们就称为 "向上转型" , 表示往父类的方向转.

UML图：

向上转型发生的时机:

直接赋值

方法传参

方法返回

直接赋值就是上面的一个操作。

方法传参

public class Test {
    public static void feed(animal animal) {
        animal.eat();
    }
    public static void main(String[] args) {
        bird bird = new bird("haha",19);
        feed(bird);
    }
}

此时形参 animal 的类型是 Animal (基类), 实际上对应到 Bird (父类) 的实例.

方法返回

public static animal findMyAnimal() {
        bird bird = new bird("haha",19);
        return bird;
    }

animal animal = findMyAnimal();
        System.out.println(animal.name);
        System.out.println(animal.age);

此时方法 findMyAnimal 返回的是一个 Animal 类型的引用, 但是实际上对应到 Bird 的实例.

动态绑定

当我们写入了如下一段代码，并且在bird类之中添加一个eat方法，结果会怎么样呢？

        animal animal1 = new animal("圆圆",19);
        animal animal2 = new bird("团团",20);
        animal1.eat();
        animal2.eat();

此时, 我们发现：animal1 和 animal2 虽然都是 animal 类型的引用, 但是 animal1 指向 animal 类型的实例, animal2 指向bird 类型的实例.

针对 animal1 和 animal2 分别调用 eat 方法, 发现 animal1.eat() 实际调用了父类的方法, 而

animal2.eat() 实际调用了子类的方法.

因此, 在 Java 中, 调用某个类的方法, 究竟执行了哪段代码 (是父类方法的代码还是子类方法的代码) , 要看究竟这个引用指向的是父类对象还是子类对象. 这个过程是程序运行时决定的(而不是编译期), 因此称为动态绑定.

我们再通过反汇编理解为啥叫动态绑定：

在反编译代码的主函数中我们发现两个调用的还都是父类的eat方法，但运行后，却有一个调用的是子类的eat，也就是说编译器在编译时还不能完全确定调用的是哪种方法，而是在运行时完全确定的。

方法重写

针对刚才的 eat 方法来说:子类实现父类的同名方法, 并且参数的类型和个数完全相同, 这种情况称为覆写/重写/覆盖(Override).关于重写的注意事项

1.重写和重载完全不一样. 不要混淆(思考一下, 重载的规则是啥?)

     2.普通方法可以重写, static 修饰的静态方法不能重写.

     3.重写中子类的方法的访问权限不能低于父类的方法访问权限.

     4.重写的方法返回值类型不一定和父类的方法相同(但是建议最好写成相同, 特殊情况除外).

//父类eat方法为public
public void eat(){
        System.out.println(name+"正在吃饭");
    }

//子类eat方法为private
private void eat(){
        System.out.println("我是一只小鸟"+super.name+"正在吃饭");
    }

当父类得到方法为public时，子类重写的方法也只能是public

另外, 针对重写的方法, 可以使用 @Override 注解来显式指定

public class Bird extends Animal {

@Override

private void eat(String food) {

...

}

}

有了这个注解能帮我们进行一些合法性校验 . 例如不小心将方法名字拼写错了 ( 比如写成 aet),此时编译器就会发现父类中没有 aet 方法 , 就会编译报错 , 提示无法构成重写 .

重载和重写的区别：

事实上, 方法重写是 Java 语法层次上的规则, 而动态绑定是方法重写这个语法规则的底层实现. 两者本质上描述的是相同的事情, 只是侧重点不同.

在构造方法中调用重写的方法(一个坑)

当我们写了如下一段代码后

class B {
    public B() {
	func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
    }
}

public class test4 {
    public static void main(String[] args) {
        D d = new D();
    }
}

D.func()结果应该很容易想出来，但后面的0 又是怎么回事呢？

构造 D 对象的同时, 会调用 B 的构造方法.B 的构造方法中调用了 func 方法, 此时又会触发动态绑定, 会调用到 D 中的 func ，而又因为此时 D 对象自身还没有构造（还没有完全实例化）, 此时 num 处在未初始化的状态, 值为 0.

只有当完全实例化之后，也就是说生成了对象后，num的值才会初始化。

结论: "用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

理解多态

有了上面的向上转型, 动态绑定, 方法重写之后, 我们就可以使用多态(polypeptide) 的形式来设计程序了.我们可以写一些只关注父类的代码, 就能够同时兼容各种子类的情况.

代码示例: 打印多种形状

class Shape {
    public void draw() {
//	啥都不用干
    }
}

class Cycle extends Shape {
    @Override
    public void draw() {
        System.out.println("○");
    }
}

class Rect extends Shape {
    @Override
    public void draw() {
        System.out.println("□");
    }
}

class Flower extends Shape {
    @Override
    public void draw() {
        System.out.println("♣");
    }
}

public class Test {
    public static void main(String[] args) {
        Shape shape1 = new Flower();
        Shape shape2 = new Cycle();
        Shape shape3 = new Rect();
        drawMap(shape1);
        drawMap(shape2);
        drawMap(shape3);
    }
//	打印单个图形
    public static void drawMap(Shape shape) {
        shape.draw();
    }
}

对于上述代码，Test类以上的代码是类的实现者编写的，而Test是类的调用者编写的。

当类的调用者在编写 drawMap 这个方法的时候, 参数类型为 Shape (父类), 此时在该方法内部并不知道, 也不关注当前的 shape 引用指向的是哪个类型(哪个子类)的实例. 此时 shape 这个引用调用 draw 方法可能会有多种不同的表现(和 shape 对应的实例相关), 这种行为就称为多态.

也就是说，类的调用者不必注重方法或属性的实现，只需知道这个事物具有这一属性或方法，就能通过该事物的父类直接调用该方法或属性。

多态顾名思义, 就是 "一个引用, 能表现出多种不同形态"

举个具体的例子. 小明家里养了两只鹦鹉(圆圆和扁扁)和一个小孩(核弹). 小明妈妈管他们都叫 "儿子". 这时候小明爸爸对小明妈妈说, "你去喂喂你儿子去". 那么如果这里的 "儿子" 指的是鹦鹉, 小明妈妈就要喂鸟粮; 如果这里的 "儿子" 指的是核弹, 小明妈妈就要喂馒头.

那么如何确定这里的 "儿子" 具体指的是啥? 那就是根据小明爸爸和小明妈妈对话之间的 "上下文".

代码中的多态也是如此. 一个引用到底是指向父类对象, 还是某个子类对象(可能有多个), 也是要根据上下文的代码来确定.

使用多态的好处是什么?

类调用者对类的使用成本进一步降低.

封装是让类的调用者不需要知道类的实现细节.

多态能让类的调用者连这个类的类型是什么都不必知道, 只需要知道这个对象具有某个方法即可.

因此, 多态可以理解成是封装的更进一步, 让类调用者对类的使用成本进一步降低.

2.可扩展能力更强.

如果要新增一种新的形状, 使用多态的方式代码改动成本也比较低.
class Triangle extends Shape {

@Override

public void draw() {

System.out.println("△");

}

}
对于类的调用者来说(drawShapes方法), 只要创建一个新类的实例就可以了, 改动成本很低.

而对于不用多态的情况, 就要把 drawShapes 中的 if - else 进行一定的修改, 改动成本更高.

向下转型

向上转型是子类对象转成父类对象, 向下转型就是父类对象转成子类对象. 相比于向上转型来说, 向下转型没那么常见,但是也有一定的用途.

当我们写了这么一串代码时，eat方法发生了动态绑定，fly方法直接找不到了？

编译过程中, animal 的类型是 Animal, 此时编译器只知道这个类中有一个 eat 方法, 没有 fly 方法.

虽然 animal 实际引用的是一个 Bird 对象, 但是编译器是以 animal 的类型来查看有哪些方法的.

那么想实现fly的方法就需要向下转型：

bird bird = (bird)animal;
        bird.fly();

但是这样的向下转型有时是不太可靠的. 例如

animal animal = new Dog("haha",10);
        animal.eat();
        bird bird = (bird) animal;
        bird.fly();

animal 本质上引用的是一个 Dog 对象, 是不能转成 Bird 对象的. 运行时就会抛出异常.

所以, 为了让向下转型更安全, 我们可以先判定一下看看 animal 本质上是不是一个 Bird 实例, 再来转换。

Animal animal = new Cat("小猫");

if (animal instanceof Bird) {

Bird bird = (Bird)animal;

bird.fly();

}

instanceof 可以判定一个引用是否是某个类的实例. 如果是, 则返回 true. 这时再进行向下转型就比较安全了.

抽象类

在刚才的打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape 的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstract method), 包含抽象方法的类我们称为抽象类(abstract class).