我的编程经历（27）----------面对对象编程（2）

最新推荐文章于 2024-07-20 23:59:39 发布
最新推荐文章于 2024-07-20 23:59:39 发布
阅读量31 收藏
点赞数
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z941030989/article/details/130136747
版权

上篇重点总结了向上转型，以及向上转型中的重写。在了解了这些之后才能更进一步理解何为多态。先创建一个父类和一个方法，并创建复数个子类和同名的构造方法进行复写再进行继承。这样在main函数中就可以进行调用，但由于发生了动态绑定，这个时候实际上调用的是子类的方法而非父类的方法：

class Shape{
    public void draw (){

    }
}

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

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

public class test1 {
    public static void main(String[] args) {
        Square square = new Square();
        square.draw();
    }
}

运行程序可得到一个方片图片，因为发生了动态绑定，也可以将main函数中的引用及类型进行向上转型：

public class test1 {
    public static void main(String[] args) {
        Shape shape = new Square();
        shape.draw();
    }

这样也能运行得到方片。

如果再构造一个方法，统一调用draw方法，即：

public class test1 {
    public void getDraw (Shape shape){
        shape.draw();
    }

这样就能只调用getDraw的情况下打印多个图形，就可以构成多态：

class Shape{
    public void draw (){

    }
}

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

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

public class test1 {
    public static void getDraw (Shape shape){
        shape.draw();
    }

    public static void main(String[] args) {
        getDraw(new Square());
        getDraw(new Triangle());
    }
}

在Shape类中，其方法并未实现，只是单纯的用于了继承，那么可以将其方法设计为抽象方法，用abstract进行修饰，则其类也用abstract修饰成为抽象类：

abstract class Shape{
     abstract public void draw ();
}

注意其中的一些细节：

1.抽象类不可以在主函数中被实例化

2.只能单纯用于继承

3.抽象类中可以包含普通成员方法

4.如果一个普通类要继承抽象类，就必须重写抽象类中的所有抽象方法

5.若抽象类B继承了抽象类A，那么就不必再重写抽象类A的抽象方法，但在此基础上若一个普通方法继承了抽象类B，则需要重写抽象类A B中的所有方法：

abstract class A{
    int a;
    String name;
    abstract public void draw();
}
abstract class B extends A{
    abstract public void func();
}
class C extends B{
    @Override
    public void draw() {
        System.out.println("测试1");
    }

    @Override
    public void func() {
        System.out.println("测试2");
    }
}
public class test2 {
    public static void main(String[] args) {
        C c = new C();
        c.draw();
        c.func();
    }
}

6.抽象类及抽象方法不可被final修饰

再抽象类的基础上，可以进一步优化。因为Java中类的继承只能继承一个，但实际写代码过程中只能继承一个过于局限，因此可以将抽象类进一步简化为接口，接口跟在类的后面以extends来表示，不再意为继承，而是改为扩展，其中需要注意的点是：

1.接口不再是类，要以interface来修饰

2.接口当中的普通方法不能有具体的实现，若非要实现只能通过关键字default来修饰

3.接口当中可以有static静态方法

4.接口中的方法都是public的，因此可以省略不写

5.抽象方法默认是public abstract，也可以省略

6.接口也不能实例化

7.类和接口之间以implement实现，若有多个接口，接口间以逗号隔开即可

8.当一个类实现了一个接口后，就必须重写其中的所有抽象方法

9.接口当中的成员变量默认是public static final修饰，可省略但是切记必须初始化赋值

10.注意权限问题，当一个类重写某个接口的抽象方法时必须加上public，否则默认的是包访问权限，而抽象方法默认的是public，比包访问权限更广

11.若接口之间存在扩展，当类实现接口时，就要重写包括扩展前的所有接口的抽象方法

interface IA{
    int a = 10;
    default void func2(){
        System.out.println("测试3");
    }
     static void func3(){
        System.out.println("测试4");
    }
    void draw();
}
interface IB extends IA{
     void func();
}
class C implements IA,IB{
    @Override
    public void draw() {
        System.out.println("测试1");
    }

    @Override
    public void func() {
        System.out.println("测试2");
    }
}
public class test2 {
    public static void main(String[] args) {
        C c = new C();
        c.draw();
        c.func();
        c.func2();
    }
}

简单介绍两个常用的接口。先来说说Comparable接口，还是以实例来说，先自定义一个数组，但是这个数组每个元素中所包含的属性不止一个：

class Student implements{
    String name;
    int age;
    double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
public class test3 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("小hhh", 15, 85.5);
        students[1] = new Student("小hhhh", 12, 80);
        students[2] = new Student("小h", 10, 98);
        System.out.println(Arrays.toString(students));

平常比较数组的大小都是调用Array.sort来进行的。但是如这个代码中的自定义数组，每个元素所包含的内容不是唯一的，这种情况下就得先明确，是用什么来进行比较，因此就可以使用Comparable接口：

class Student implements Comparable<Student>

加入接口后摁住ctrl点击该接口，下拉会发现只有一个compareTo方法，由于是接口，所以要在类中对该方法进行重写，若要比较age，则调用age：

 public int compareTo(Student o) {
        return this.age - o.age;
    }

this.所代指的就是调用的对象。

但是若要比较的是name这样的String类型，就得再调用一次compareTo方法，不能直接比较。因为本体的student只是一个引用，引用与引用直接比较Java是做不到的，所以最后代码写出来就是这样：

import java.util.Arrays;

class Student implements Comparable<Student>{
    String name;
    int age;
    double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {
        return this.name.compareTo(o.name);
    }
}
public class test3 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("小hhh", 15, 85.5);
        students[1] = new Student("小hhhh", 12, 80);
        students[2] = new Student("小h", 10, 98);
        System.out.println(Arrays.toString(students));
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

但是这个方法有一个非常局限的地方。其比较的属性是固定死了的，若要改变只能改变其compareTo中的代码，若随意改动，会造成一系列的连锁反应。因此更多推荐的是使用比较器Comparator进行比较。

例如，要对age进行比较，即可单独令一个类使用比较器接口，摁住ctrl再点击Comparator可再源码中看到其第一个抽象方法，在该类中进行重写即可获得相应的比较器：

class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

同样的道理也可以写出比较name与比较score的比较器：

class ScoreComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return (int) (o1.score - o2.score);
    }
}
class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

这样的话需要比较什么就调用相应的比较器即可，无需对代码本身进行修改，对代码的破坏性大大降低：

import java.util.Arrays;
import java.util.Comparator;

class Student{
    String name;
    int age;
    double score;

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                '}';
    }
}
class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}
class ScoreComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return (int) (o1.score - o2.score);
    }
}
class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}
public class test4 {
    public static void main(String[] args) {
        Student[] students = new Student[3];
        students[0] = new Student("aaaaa", 15,66.3);
        students[1] = new Student("bbbb", 18,75);
        students[2] = new Student("ccc", 14,89);
        System.out.println(Arrays.toString(students));
        AgeComparator ageComparator = new AgeComparator();
        Arrays.sort(students, ageComparator);
        System.out.println(Arrays.toString(students));
    }
}

在具体实践中使用哪一个跟具体的业务存在关系，但比较器是较为推荐的一个，其功能相比之下更为安全。

---------------------------------最后编辑于2023.4.14下午四点左右

莫轻离.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
精品专题（2021-2022年收藏）java实训个人总结.doc
10-02
实训期间，学员不仅掌握了基础的Java语法，还对面向对象编程有了更深入的理解，包括类、对象、继承、封装、多态等核心概念。此外，实训还涉及了JDK的配置、数据库的安装和使用，以及Java可视化开发工具的熟悉和应用...
工作总结-年末的工作汇报2.pptx
01-09
在工作技能方面，我深化了面向对象编程的理解，认识到对象是编程的核心思想，无论是在Asp.net、C#还是Java中，都能灵活运用类和方法进行开发。此外，通过参与vb.net项目，我弥补了在这方面的空白，同时加深了对XML和...
JAVA开发-个人简历模板.docx
12-18
1. **Core Java编程**：求职者掌握了Java的基础编程，包括面向对象编程概念、类、对象、封装、继承、多态等，具备扎实的编程基础和良好的编码规范。 2. **轻量级框架SSH**：Struts2、Hibernate和Spring是Java开发中...
2009-chp9数据库新技术发展.ppt
06-02
面向对象的方法和技术在这个阶段发挥了重大作用，推动了数据库技术与其他学科如人工智能、面向对象编程、并行计算和分布式技术的融合。面向对象数据库系统允许更自然地表示和操作复杂数据结构，例如继承、封装和多态...
java技术人员-面试评价表.doc
06-10
Java技术面试是评估潜在员工在编程、框架理解、数据库操作以及项目管理等核心技能上的熟练程度。以下是对每个评价要素的详细解析： 1. **Java基础知识**：这部分主要考察候选人的Java语法掌握程度，包括类、对象、...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 208
从本地导入Junit
Java内存模型
weixin_44267758的博客
07-19 544
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 466
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 731
JVM-垃圾回收与内存分配
java算法day19
TOMOT77的博客
07-20 117
我第一时间想到的方法是遍历二叉树+哈希。哈希用来统计数字出现的次数。之后遍历map收集结果。利用了BST的性质，即BST的中序序列是有序序列。
【Java算法】前缀和 下
2302_79806056的博客
07-18 938
这段代码实现了一个寻找数组中具有相等数量的0和1的最长子数组长度的算法。具体来说，它使用了前缀和（prefix sum）的概念以及哈希映射（HashMap）来优化查找过程。初始化哈希映射：计算前缀和：检查相等数量的0和1：更新哈希映射：返回结果：这种方法的时间复杂度为O(n)，因为我们只遍历数组一次，并且对每个元素执行常数时间的操作。空间复杂度也是O(n)，最坏情况下需要存储n个前缀和值。 初始化阶段:开始遍历数组:继续
Java实验2
qq_64727229的博客
07-16 528
类的封装、继承、多态和接口（1）有理数四则运算（2）最终得分
对androidTestDebug 产物进行重新签名
shuizhizhiyin的专栏
07-19 381
在运行 gradle assembleAndroidTestDebug 任务后，自定义的 reSignAndroidTestDebug 任务将会被执行，并对子模块的 androidTestDebug 产物进行重新签名。your_keystore_path.jks、your_keystore_password、your_key_alias 和 your_key_password 需要替换为你的实际路径和密码。如果需要对其他子模块的产物进行重新签名，可以根据需要创建不同的自定义任务。// 设置密钥库密码。
每 日练 习
m0_67187271的博客
07-19 788
正确答案：C 解析：是正确的，这是最基本的类定义形式，没有继承任何类，也没有实现任何接口。也是正确的，这里定义了一个名为x的类，它继承了名为y的类。同样是正确的，这里定义了一个公共类x，它继承了Applet类，这在Java中是合法的，尤其是在创建GUI应用程序时常见。是不正确的，因为在Java中，我们不能使用static关键字来修饰一个类的定义。static关键字只能用于类的方法、变量或者是内部类（即嵌套类），但不能用于顶级类（非嵌套类）。所以，这个选项是错误的。因此，正确答案是C。
Srping Cloud - @Async注解+Feign手动设置token
qq_36782325的博客
07-16 269
在Spring cloud项目开发中，经常需要通过feign远程调用其他的服务的方法。有时因为跨服务调用的时间较长，就会存在需要异步跨服务调用的场景，此时就会出现请求头（主要是token）丢失的问题。
《简历宝典》15 - 简历中“项目经历”，实战讲解，Java篇
xingyu_qie的专栏
07-18 220
校招和初级Java开发的项目经历重点是突出自己在实战中的学习。比如对数据库的操作，比如前后端联调工作中遇到问题的解决，比如一些Java基础知识点的逐渐深入掌握，这些都是这个阶段的Java开发需要去不断增强的。和初级前端开发类似，例如你作为一名初级Java开发，负责的是校园图书管理系统的图书信息上传，图书信息管理这个模块的服务端开发，项目经历可以这样编写，如图。
【利用Selenium+autoIt实现文件上传】
凌飞安
07-16 478
当文件上传功能不能简单修改value属性的时候，你一定要看一下我这片文章。
python--实验14 并发编程（多线程）
wumingzei的博客
07-18 715
定义通过声明Thread的派生类，创建一个子类，并重写对象的run方法，然后创建其对象实例，可创建线程。通过对象的start方法，可启动线程，并自动执行对象的run方法。注意子类的构造器一定要先调用基类的构造器直接将线程需要做的事写到run方法中示例。
码农生涯问题杂记
qq_38189542的博客
07-18 161
Q：工作中需要测试一个JNA程序，想着Windows方便，所以就在Windows进行动态库的编译，然后在编译过程中，对应的代码在Linux系统GCC编译是成功的，但是在Windows下死活报错，而且报的错莫名其妙。A：后面经过测试，Vistual Studio在UTF8编码下，对中文支持很糟糕，导致编译的时候，语法解释出错，从而就出现一大堆乱七八糟让人摸不着头脑的错误。后面删除代码中的中文注释，编译成功。
C++编程学习：面向对象特性与程序设计解析
这篇文档是对C++语言程序设计的学习指导，涵盖了程序设计语言的发展历程、C++语言的特点以及面向对象编程的概念。在学习C++的过程中，理解这些知识点是至关重要的。 首先，计算机程序设计语言的发展历程经历了三个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值