面向对象编程

最新推荐文章于 2024-09-16 21:37:07 发布
最新推荐文章于 2024-09-16 21:37:07 发布
阅读量170 收藏
点赞数
文章标签： java 接口 面向对象编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41257074/article/details/109295504
版权

面向对象编程

1.包

包(package)是组织类的一种方式。

1.1导入包中的类

例如：

可以使用java.util.Date这种方式导入java.util这个包中的Date类。

import java.util.Date;

public class TestDemo01 {
    public static void main(String[] args) {
        java.util.Date date = new Date();
        date.getTime();
    }
}

1.2包的访问权限控制

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

1.3常见的系统包

  1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。
  2. java.lang.reflect:java 反射编程包;
  3. java.net:进行网络编程开发包。
  4. java.sql:进行数据库开发的支持包。
  5. java.util:是java提供的工具程序包。(集合类等) 非常重要。
  6. java.io:I/O编程开发包。

2.继承

**面试问题：**子类继承了父类什么东西？

子类继承了除构造方法外所有的东西。私有的东西，不能在子类访问。

基本语法：

class 子类 extends 父类{

}

  1. 使用 extends 指定父类.

  2. Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).

  3. 子类会继承父类的所有 public 的字段和方法.

  4. 对于父类的 private 的字段和方法, 子类中是无法访问的.

  5. 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.

    super关键字：

    1. super：代表父类对象的引用
    2. super.data:访问父类的数据成员
    3. super.func():调用父类的方法
    4. super():调用父类的构造方法

3.多态

**向上转型：**把子类的对象给了父类的引用，通过父类引用调用的方法，一定在父类当中存在的。

​ 父类引用引用子类对象

有3种方式进行向上转型：

  1. 直接赋值
  2. 方法传参
  3. 方法返回

**动态绑定：**当前这个方法需要重写。父类引用引用子类对象，调用子类的方法。

什么叫做重写？(override)

  1. 方法名称相同
  2. 参数列表相同
  3. 返回值相同

重写的注意事项：

  1. 子类方法的访问权限大于等于父类的访问权限

  2. 父类的访问权限不能是private

  3. static修饰的静态方法不能重写

    **面试问题：**构造函数当中是否可以发生动态绑定？可以的

使用多态的好处：

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

  2. 能够降低代码的”圈复杂度“，避免使用大量的if-else。

  3. 可扩展能力强。

    代码示例：

    package com.itbit_04;

public class Sharp {
    public void draw() {

    }
}

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

class Flower extends Sharp {
    @Override
    public void draw() {
        System.out.print("❀");
    }
}

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


package com.itbit_04;

public class SharpTest {
    public static void main(String[] args) {
        Sharp sharp1 = new Cycle();
        Sharp sharp2 = new Flower();
        Sharp sharp3 = new Rect();
        drawMap(sharp1);
        drawMap(sharp2);
        drawMap(sharp3);

        Rect rect = new Rect();
        Cycle cycle = new Cycle();
        Flower flower = new Flower();
        Sharp[] sharps = {rect, cycle, flower, flower, cycle, rect};
        for (Sharp sharp: sharps) {
            sharp.draw();
        }
    }

    public static void drawMap(Sharp sharp) {
        sharp.draw();
    }
}

4.抽象类

语法规则：

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

  1. 包含抽象方法的类，抽象类。使用abstract来修饰。

  2. 抽象方法是不能够具体的实现的。

  3. 在抽象类当中，可以定义和普通类相同的数据属性和方法。

  4. 抽象类是不可以实例化的。

  5. 一个普通类继承了抽象类之后，一定要重写抽象类的抽象方法。

  6. 如果一个类，继承了抽象类但是又不想重写这个抽象方法，那么就把这个类设置为抽象类，但是迟早是要被重写的。

  7. 抽象方法不能是private。

    **问题：**那么抽象类存在的意义是什么？既然不能够进行实例化，那么数据成员和方法如何调用？

    答：抽象类天生就要被继承。

    代码示例：
    public abstract class Shape {
    public abstract void draw();
}

class Cycle extends Shape {

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

class Flower extends Shape {

    @Override
    public void draw() {
        System.out.println("❀");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //Shape shape = new Shape();错误的
        drawMap(new Cycle());
        drawMap(new Flower());
    }

    public static void drawMap(Shape shape) {
        shape.draw();
    }
}

//打印结果
○
❀

5.接口

语法规则：

interface name{
    void draw();
    default public void func();
    
}

  1. 接口当中的方法，一定是不能够具体实现的。

  2. 接口当中default修饰的方法才能够具体实现。

  3. 接口当中的成员变量都是常量(public static final)。

  4. 接口当中的方法都是public abstract。

  5. 如果不写，默认都是。

  6. 接口不能够被实例化。

  7. 接口也可以发生向上转型和运行时绑定。

    代码示例：

    public interface Shape {
    void draw();
   /* default public void func1() {

    }*/
}

package com.itbit_02;

class Cycle implements Shape {

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

class Flower implements Shape {

    @Override
    public void draw() {
        System.out.println("❀");
    }
}
public class TestDemo {
    public static void main(String[] args) {
//        Shape shape = new Shape();错误的
        Shape shape1 = new Cycle();
        shape1.draw();
        Shape shape2 = new Flower();
        shape2.draw();
        Flower flower = new Flower();
        flower.draw();
        drawMap(flower);
    }

    public static void drawMap(Shape shape) {
        shape.draw();
    }
}


//打印结果
○
❀
❀
❀

    两个意义：

    1. 实现多继承
    2. 可扩展能力非常强

    注意：

    1. 类和接口之间的关系？抽象类是否可以实现接口？可以的
    2. 接口和接口之间的关系？接口之间是可以继承的 extends

    代码示例：

    interface IFlying {
     void fly();
}

interface IRunning {
    void run();
}

interface ISwimming {
    void swim();
}

package com.itbit_03;

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }
}

class Cat extends Animal implements IRunning {

    public Cat(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(this.name+"正在跑，疯狂的跑。。。。。");
    }
}

class Fish extends Animal implements ISwimming {

    public Fish(String name) {
        super(name);
    }

    @Override
    public void swim() {
        System.out.println(this.name+"正在游泳，疯狂的游泳。。。。。");
    }
}

class Frog extends Animal implements IRunning, ISwimming {

    public Frog(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println(this.name+"又在跑。。。。。");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"又在游泳。。。。。");
    }
}

class Duck extends Animal implements IRunning, ISwimming, IFlying {

    public Duck(String name) {
        super(name);
    }

    @Override
    public void fly() {
        System.out.println(this.name+"还会飞。。。。。。");
    }

    @Override
    public void run() {
        System.out.println(this.name+"又在跑。。。。。");
    }

    @Override
    public void swim() {
        System.out.println(this.name+"又在游泳。。。。。");
    }
}

class Robot implements IRunning {

    @Override
    public void run() {
        System.out.println("机器人在跑");
    }
}


package com.itbit_03;

public class TestDemo {
    public static void main(String[] args) {
//        Animal animal = new Cat("狸花猫");
//        IRunning iRunning = new Cat("狸花猫");
//        func1(new Cat("狸花猫"));
//        func2(new Duck("可达鸭"));
//        func3(new Fish("江团"));
        Cat cat = new Cat("橘猫");
        func1(cat);
        //func2(cat);
        Duck duck = new Duck("小鸭子");
        func1(duck);
        func2(duck);
        func3(duck);
        Fish fish = new Fish("草鱼");
        func3(fish);
        Frog frog = new Frog("牛蛙");
        func1(frog);
        func3(frog);
        IRunning robot = new Robot();
        func1(robot);
    }
    public static void func1(IRunning iRunning) {
        iRunning.run();
    }

    public static void func2(IFlying iFlying) {
        iFlying.fly();
    }

    public static void func3(ISwimming iSwimming) {
        iSwimming.swim();
    }
}


//打印结果
橘猫正在跑，疯狂的跑。。。。。
小鸭子又在跑。。。。。
小鸭子还会飞。。。。。。
小鸭子又在游泳。。。。。
草鱼正在游泳，疯狂的游泳。。。。。
牛蛙又在跑。。。。。
牛蛙又在游泳。。。。。
机器人在跑
    代码示例：Comparable接口
    package com.itbit_04;

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

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

    @Override
    public int compareTo(Student o) {
        if (this.age < o.age) {
            return -1;
        } else if (this.age > o.age) {
            return 1;
        } else {
            return 0;
        }
    }

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


package com.itbit_04;

public class TestDemo {
    public static void main(String[] args) {
        Student student1 = new Student(10, "狸花猫");
        Student student2 = new Student(5, "橘猫");
        if (student1.compareTo(student2) > 0) {
            System.out.println("s1>s2");
        } else if (student1.compareTo(student1) < 0) {
            System.out.println("s1<s2");
        } else {
            System.out.println("s1 == s2");
        }
        System.out.println(student1.toString());
    }
}

    **面试问题：**clone接口为什么是一个空接口，作用是什么？

    标记接口，标记当前类是可以被克隆的

喜欢电影的小子
关注
面向对象——必敲项目（简化版qq炫舞）
m0_60304031的博客
09-25 824
小游戏简化版qq炫舞，指尖跳动，第六关太难啦
简单模拟qq聊天程序（TCP版）
上善若水
03-12 3096
本程序特点：         1.分为client，server，tool 3个包，实现了多个任意客户端之间，进行通信         2.由于使用了包头+包体的信息传递格式，所以可以发送任意长度信息         3.由于没有界面，发送信息时需要指定目标id 一、client包： public class Client { private static final Strin
简单的汇总代码，面向对象
qq7652401741的博客
04-29 272
初学 建议的代码 VBA 实现对各个表进行计算 本例中为计算平均分 并汇总到一个sheet内 Option Explicit Sub 汇总() Dim i, j, k, total, count Dim wq As Worksheet Dim wall As Worksheet k = 2 For i = 1 To Worksheets.count '对各表进行循...
仿QQ聊天程序（java）
热门推荐
王人冉的博客
04-17 2万+
仿QQ聊天程序（java） 2014年03月17日 15:52:47 标签： java/ 聊天/ 仿QQ 90246 仿QQ聊天程序 转载请标明出处：牟尼的专栏http://blog.csdn.net/u012027907 一、设计内容及要求 1.1综述 A.系统概述 我们要做的就是类似QQ这样的面向企业内部的聊天软件，基本功能和QQ类似。首先，系统分为两大部分，第一部分...
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是基于C++的面向对象程序设计实现，旨在教授学生如何运用面向对象编程思想来构建实际的应用程序。** **一、面向对象编程基础** 面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心思想...
JAVA面向对象程序设计(期末考试试题及答案)
06-16
JAVA面向对象程序设计是 Java 编程语言的核心 contents，涵盖了面向对象编程的基本概念、语法规则、编程技术和实际应用等方面的知识。本文总结了 JAVA面向对象程序设计的知识点，涵盖了 Java 语言的基本语法、面向...
java面向对象编程pdf
04-16
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为。 一、对象和类 在Java中，对象是指具有某些特征和行为的实体，例如人、学生、大象、冰箱...
JAVA面向对象程序设计(期末考试试题及答案).zip
06-05
在Java编程语言中，面向对象程序设计（Object-Oriented Programming, OOP）是一种核心的编程范式，它基于“对象”概念，将数据和处理数据的方法封装在一起，以实现代码的模块化和可重用性。这个压缩包文件"JAVA面向...
Labview面向对象编程
10-31
Labview面向对象编程是NI...通过学习和掌握Labview面向对象编程，开发者可以构建出更复杂、更易于维护的应用程序，适应不断变化的需求，并利用Labview的强大功能进行数据分析、控制工程、测试测量等领域的项目开发。
【学习笔记】手写 Tomcat 三
LearnTech_123的博客
09-12 1112
响应动态资源不需要写文件名了，只需要写功能的名称即可。比如登录功能，可以定义名称为 doLogin
Gradle
xiaocaij_icai的博客
09-15 155
");
计算机毕业设计 基于SpringBoot的课程教学平台的设计与实现 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-12 919
本文介绍了一款基于Java、SpringBoot和Vue.js技术的课程教学平台。该平台服务于管理员、学生和教师，提供教学资源管理、课程信息浏览、作业提交与批改等功能，旨在优化教学流程，提升教育质量，促进教育资源的数字化共享，推动教育信息化发展。
spring security中几大组件的作用和执行顺序
阿信今天的代码没bug的博客
09-11 346
spirng security中的几大组件的差异和执行顺序
计算机毕业设计 网上书店系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试
weixin_19164791635
09-16 840
本文介绍了一款基于Java、SpringBoot和Vue.js技术的网上书店系统。该系统为管理员、用户和卖家提供了图书信息浏览、订单管理、个人中心管理等功能，旨在打造一个便捷、高效的在线购书平台。系统通过优化图书销售流程，提升用户体验，推动出版行业的数字化转型，促进知识传播和文化交流。
模拟面试后端开发复盘
Java小白的博客 致力分享每一天学到的知识
09-11 1195
一般来说系统的开发和设计思路的话，就是一般现在的项目基本上都是前后端分离架构来实现的，所以在项目的设计时，要分层次结构来划定。前后端分离架构中，前端一般是有专业的前端工程师来写的，因此我们步需要过分的关注前端，可以在github上找到相关的前端项目即可。
使用API有效率地管理Dynadot域名，查看域名服务器（NS）信息
Dynadot_tech的博客
09-12 1069
Dynadot是通过ICANN认证的域名注册商，自2002年成立以来，服务于全球108个国家和地区的客户，为数以万计的客户提供简洁，优惠，安全的域名注册以及管理服务。Dynadot.com提供的API是专为效率而构建的高级域名管理和获取工具包。使用Dynadot API，可以查看某一域名DNS设置的域名服务器（Name server）信息。
07_Python数据类型_集合
最新发布
fx_yzjy101的专栏
09-16 409
可以使用大括号 {} 或者 set() 函数来创建集合。如果使用大括号，则至少需要包含一个元素；如果使用 set()，则可以创建一个空集合。# 创建一个空集合# 创建一个包含一个元素的集合# 创建一个包含几个元素的集合。
C++面向对象程序设计实验指南
本实验主要针对C++语言的面向对象程序设计进行深入探讨，旨在帮助学生掌握面向对象编程的基本概念和实践技巧。实验内容涵盖了面向对象软件开发方法的核心特性，如抽象性、封装性、继承性和多态性，这些都是C++语言中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值