面向对象编程

最新推荐文章于 2024-08-12 15:45:48 发布
最新推荐文章于 2024-08-12 15:45:48 发布
阅读量68 收藏
点赞数
分类专栏： 笔记 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42944538/article/details/120909777
版权
本文详细介绍了面向对象编程的基本概念，包括面向过程与面向对象的区别、方法的定义与调用、对象的创建与封装、继承、抽象类与接口、内部类的使用。通过实例解析了对象的引用传递、构造器的创建、多态的概念及其应用。此外，还探讨了抽象类与接口在约束和实现分离中的作用，以及内部类的三种类型。文章旨在帮助读者深入理解面向对象编程的核心思想和实践技巧。
摘要由CSDN通过智能技术生成

面向对象编程

目录：

一、初识面向对象

二、方法回顾和加深

三、对象的创建分析

四、面向对象三大特性

五、抽象类和接口

六、内部类及

一、初识面向对象

面向过程 & 面向对象

*面向过程思想

  1. 步骤清晰简单，第一步，第二部做什么…
  2. 面向过程 合适处理一些较为简单的问题

*面向对象思想

  1. 物以类聚，分类的思维模式，思考问题首先要思考解决问题需要哪些分类，然后对这些分类进行单独思考。最好，才对某个分类下的细节进行面向过程的思索。

  2. 面向对象时候处理一写较为复杂的问题，适合处理需要多人协作的问题！

    *对于描述复杂的事物，为了从宏观上把握，从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

二、方法回顾和加深

package OOP.demo01;

//Demo01 类
public class Demo01 {

    //main 方法
    public static void main(String[] args) {

    }

    /*写方法的语句格式：
    修饰符  返回值类型  方法名（参数）{
    //方法体
    return 返回值；
    }
     */
    public String sayHello(){
        return "hello,world";
    }
    //比较两个数大小的方法
    //return 结束方法，返回一个结果！
    public int max(int a,int b){
        return a>b ? a :b;//三元运算符  如果a>b，就输出a，否则b
    }


}

非静态方法调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oKe2kRkG-1634893705484)(C:\Users\86150\AppData\Roaming\Typora\typora-user-images\image-20211021162216940.png)]

静态方法调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KxHm35Hm-1634893705486)(C:\Users\86150\AppData\Roaming\Typora\typora-user-images\image-20211021163030328.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XKGoD7Iz-1634893705487)(C:\Users\86150\AppData\Roaming\Typora\typora-user-images\image-20211021163449153.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iWtl3fVp-1634893705488)(C:\Users\86150\AppData\Roaming\Typora\typora-user-images\image-20211021164312773.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Ly61DZZm-1634893705488)(C:\Users\86150\AppData\Roaming\Typora\typora-user-images\image-20211021165220770.png)]

三、对象的创建分析

package OOP.demo01;

//引用传递:对象，本质是传递值
public class Demo05 {
    public static void main(String[] args) {
        Perosn person = new Perosn();

        System.out.println(person.name);//null

        Demo05.change(person);

        System.out.println(person.name);
    }
    public static void change(Perosn perosn){
        //perosn是一个对象，指向的是===Perosn person = new Perosn();
        perosn.name = "龙华望";}


}

//定义了一个Perosn类  ，里面有一个属性：name
    class  Perosn{
     String name = "龙华望";

        }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gEa1je31-1634893705489)(C:\Users\86150\AppData\Roaming\Typora\typora-user-images\image-20211021191223658.png)]

*Alt + insert 新键一个构造器

package OOP.demo03;

//java--->clss
public class Person {

    //一个类即使什么都不写，它也会存在一个方法
    //显示的定义构造器
    String name;
    int age;


    //Alt + insert

    //1.使用new关键字，本质是在调用构造器、、
    //2.用来初始化值
    public Person(){

    }

    //有参构造：一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name = name;
    }

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

    }
}

package OOP.demo03;

public class Application {
    public static void main(String[] args) {

        //new 实列化一个对象
        Person person = new Person("龙华望",23);

        System.out.println(person.name);
    }
}

封装

  • 该漏的漏，该藏的藏

  • 我们程序设计要求”搞内聚，低偶合“。高内聚：就是类的内部结构数据操作细节自己完成，不允许外部干涩。低偶合：仅暴露少量的方法给外部使用。

  • 封装（隐藏的数据）

    • 通常，应禁止之间访问一个对象中实际的表示，而应通过操作接口来访问，这称为隐藏信息。

    • 记住这句话就够了：属性私有，get/set

      package OOP;

import OOP.demo04.Student;
/*
get set 封装的好处
1.提高程序的安全性，保护数据
2.隐藏代码实现的细节
3.统一接口
4.系统可维护增加了
 */
public class Application {
    public static void main(String[] args) {

        Student s1 = new Student();

        s1.setName("龙华望");
        System.out.println(s1.getName());
    }




}

      package OOP.demo04;

//类    private:私有
public class Student {
   //属性私有
    private String name; //姓名
    private int id;//学号
    private char sex; //性别

    //因为属性是私有的
    //我们要提供一些可以操作这些属性的方法！
    //也就是public的get和set方法

    //get获得这个数据
    public String getName(){
        return this.name;
    }
    //set方法给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

继承

  • 继承的本质是对某一批的抽象，从而实现对现实世界更好的建模。

  • extends的意思是“扩展”。子类是父类的扩展。

  • java中类只有单继承，没有多继承！

  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等。

  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示。

  • 子类和父类之间，从意义上讲应该具有“ is a”的关系。

    super（调用父类的方法）注意点

    1. super调用父类的构造方法，必须在构造方法的第一
    2. super必须只能出现在子类的方法或者构造方法中！
    3. super和thi不能同时调用构造方法！

    vs this：

    代表的对象不同：

    ​ this：本身调用者这个对象

    ​ super：代表父类对象的应用

    前提

    ​ this：没有继承也可以使用

    ​ super：只有在继承条件下才可以使用

    构造方法

    ​ this（）：本类的构造

    ​ super() ：父类的构造

    重写

    • 需要有继承关系，子类重写父类的方法！
    • 方法名必须相同
    • 参数列表必须相同
    • 修饰符：范围可以扩大：public (公共的)> protected（受保护的） > Default > private（私有的）
    • 抛出的异常：范围，可以被缩小，但不能扩大；ClassNotFoundException -->Exception…类找不到的异常
    • 重写，子类的方法和父类必须要一致，方法体不同！
    为什么需要重写：
    • 1.父类的功能，子类不一定需要，或者不一定满足！Alt + Insert;override

    多态

    • 即同一方法根据发送对象的不同而采用多种不同的行为方式。
    • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多
    • 多态存在的条件：
    1. 有继承关系
    2. 子类重写父类方法
    3. 父类引用指向子类对象

    • 注意：多态是方法的多态，属性没有多态性。

    • instanceof 类型转换····引用类型

    • package OOP;


import OOP.demo06.Person;
import OOP.demo06.Student;

public class Application {
    public static void main(String[] args) {
   //一个对象的实际类型是确定的
//   new Student();
//   new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类

        //子类Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //父类Person 可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s2.eat();//子类重写了父类的方法，执行了子类的方法
        s1.sun();

    }




}
      • 多态注意事项：

      1. 多态是方法的多态，属性没有多态

      2. 父类和子类，有联系 才能强制转换 否则会有异常：ClassCastException!

      3. 多态存在条件：继承关系，方法需要重写，父类引用指向子类对象！father f1 = new Son();

        不能重写的有哪些：

        1. static 方法，属于类，它不属于实列
        2. final 常量 不可以改变的
        3. private方法
package OOP;


import OOP.demo06.Person;
import OOP.demo06.Student;

public class Application {
    public static void main(String[] args) {
   //一个对象的实际类型是确定的
//   new Student();
//   new Person();
        //可以指向的引用类型就不确定了:父类的引用指向子类

        //子类Student 能调用的方法都是自己的或者继承父类的！
        Student s1 = new Student();
        //父类Person 可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s2.eat();//子类重写了父类的方法，执行了子类的方法
        s1.sun();

    }




}

五、抽象类和接口

抽象类

//abstract 抽象类 : extends: 单继承  （接口可以多继承） 比如：插座...
public abstract class Action{
//约束·~有人能帮我们实现
//abstract,抽象方法，只有方法名字，没有方法的实现
public void doSomething(){
    //1.不能new出这个抽象类，只能靠子类去实现它：约束作用
    //2.抽象类里面可以写普通方法~
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束
    //抽象类存在的意义：相当于抽象定义了一个模板，抽象出来~提高开发效率

}
}

接口

接口的关键字：interface

普通的类：只有具体实现

抽象的类：具体实现和规范（抽象方法）都有

接口：只有规范！自己无法写方法~专业的约束！ 约束和实现分离：面向接口编程~

  • 接口就是规范，定义的一组规则，体现了实现世界中“如果你是…则必须能…”的思想。如果你是天使，则必须能飞。如果你是船，则必须能下水，如果你是车，则必须能跑等…
  • 接口的本质是契约，就像我们人间的法律一样，制定好后大家都遵守。
  • OOP的精髓，是对对象的抽象，这一点最能体现的就是接口。为什么我们讨论设计 模式都只针对具备了抽象能力的语言（比如：C,C++,java,C#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
     //类 可以实现多接口 使用implements连接
    //实现了接口的类，就需要重写接口中的方法~
    public class UserServiceImpl implements UserService{
        
    }

package OOP.demo07;

//抽象的思维需要锻炼，
//定义接口的关键字：interface  ，接口都需要有实现类
public interface UserService {

    //接口中定义的属性都是常量~public static final
    int AGE = 99;

    //接口中的所有定义其实都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
  • 接口的作用：
    1. 约束
    2. 定义一些方法，让不同的人实现~
    3. 里面的方法都是public abstract
    4. 里面所有的常量都是public static final 静态常量
    5. 接口不能被实列化，接口中没有构造方法
    6. 接口可以实现多个接口，通过implements来实现
    7. 必须重写接口中的方法

六、内部类

内部类

  • 内部类就是在一个类的内部定义一个类，比如，A类中定义一个B类，那么B就是A类的内部类，相对的A类就是B类的外部类。
  1. 成员内部类
package OOP.demo8;

public class Outer {
    private int id = 10;
    public void out(){
        System.out.println("这是外部类的方法");
    }

    public class Inner{
        public void in(){
            System.out.println("这是内部类的方法");
        }

        //获得外部类的私有属性~
        public void getID(){
            System.out.println(id);
        }
    }
}

package OOP;


import OOP.demo8.Outer;

import static java.lang.System.out;

public class Application {
    public static void main(String[] args) {
        //调用外部类  new
        Outer outer = new Outer();

        //调用内部类，通过这个外部类来实例化内部类
        Outer.Inner inner = outer.new Inner();
        inner.getID();

    }




}

2.静态内部类

public class Inner{
    public void in(){
        System.out.println("这是内部类的方法");
    }

    //获得外部类的私有属性~
    pricate void getID(){   //吧public改成private
        System.out.println(id);
    }
}

3.局部内部类

package OOP.demo8;

public class Outer {

    //局部内部类
    public void method(){
        class Inner{

        }
    }
}
小城小人物
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
python面向对象程序设计实验总结_python面向对象编程小结
weixin_42501974的博客
01-13 1857
这个是跟着教程一步一步走过来的，所以记下自己学习的过程。一、类基础1、类的定义class :class (父类名)：>>>classhuman:...age=0...sex=''...name=''...>>>classstudent(human):...school=''...number=0......
python面向对象程序设计实验_实验七 面向对象程序设计
weixin_39715290的博客
11-29 3340
实验七 面向对象程序设计一、实验目的与要求1、了解面向对象编程思想，掌握类和对象的定义和使用。2、熟悉self的使用技巧，掌握构造方法的使用。3、了解如何使用封装保护属性，掌握单继承和多继承的使用。4、掌握类属性和实例属性的使用，熟悉类方法和静态方法的使用技巧。二、实验原理在程序中使用对象来映射现实中的事物，使用对象间的关系来描述事物之间的联系，这种思想就是面向对象。面向对象编程有两个非常重要的概...
C++面向对象程序设计 面向对象编程
热门推荐
qq_19656669的博客
09-12 1万+
1.1 面向过程的编程风格与面向对象的编程风格 C语言是面向过程语言，也称为命令型语言，面向过程通常采用自顶向下设计，问题复杂时不断运用自顶向下设计（即函数分解法）直到容易处理。自顶向下设计优点是直观有条理，缺点是难于进行软件维护，包括软件系统的测试、调试和升级等，牵一发而动全身。 模块化的组织方式：将整个系统分解为若干模块，模块之间通过接口传递信息，模块划分应尽可能高内聚，低耦合。 ...
C++ 面向对象程序设计
2201_75772333的博客
05-03 3590
在面向对象的思想中，我们把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。当然，一个应用程序会包含多个对象，通过多个对象的相互配合即可实现应用程序所需的功能，这样当应用程序功能发生变动时，只需要修改个别对象就可以了，使代码更容易维护。面向对象的程序设计思想可以帮助我们创建结构良好的，可复用的代码，更好地描述和理解真实世界的问题。封装可以隐藏对象的内部表示，只通过对象的方法暴露必要的操作和功能。这使得新类可以复用和扩展已存在的类的代码，提高了代码的复用性，并能够表达类之间的"is-a"关系。
Python 面向对象编程详解
CSDN
08-04 6507
面向对象,OOP英文全称(Object-Oriented Programming)是一种高效的编程思路,面向对象技术已经成为当今软件设计和开发领域的主流技术,面向对象编程是一种编程方式,使用 "类" 和 "对象" 来实现,所以面向对象编程其实就是对 "类" 和 "对象" 的使用,类就是一个模板,模板里可以包含多个方法(函数),方法里实现各种各样的功能,对象则是根据模板创建的实例,通过实例对象可以执行类中的方法,每个对象都拥有相同的方法,但各自的数据可能不同.
面向对象程序设计
qq_42883222的博客
12-09 1万+
之前复习面向对象的时候整理的，丢出来一起分享一下。因为复习得很赶，只是大致的整理，且大部分图片来自老师的ppt，可能不是很准确。如果要详细了解其中的某个知识点请另外搜索。 但是老师不讲武德啊，明明提纲给了不按提纲考，还从开卷变成闭卷。大意了，当时就不应该报啊。 一、面向对象程序设计的基本概念 1.面向对象的基本思想 (1)客观事物是由对象组成的，对象是在原事物基础上抽象的结果。 (2)对象是由属性和操作组成的，其属性反映了对象的数据信息特征，而操作则用来定义改变对象属性状态的各种操作方式。 (3)对象之间的
什么是面向对象编程（Java）
DICA的SEOer专栏
03-17 1004
Java中的多态是通过方法重载和方法重写来实现的，方法重载是指在一个类中定义多个同名方法，但参数列表不同，方法重写是指在子类中重写父类的方法，从而实现不同的行为。在Java面向对象编程中，类是创建对象的模板，它定义了对象的属性和行为。Java面向对象编程是一种编程范式，它的核心思想是将程序中的数据和操作数据的方法组织成一个相互依存的对象集合，并通过对象间的交互来实现程序的功能。在Java面向对象编程中，对象是程序的基本单元，每个对象由数据和操作数据的方法组成，数据表示对象的状态，方法表示对象的行为。
面向对象程序设计概念
kangjialong_的博客
11-02 2345
一. 程序设计范型   面向对象程序设计（object-oriented programming，OOP）是一种新的程序设计的范型。程序设计范型是设计程序的规范、模型和风格，它是一类程序设计语言的基础。 面向对象设计范型的主要特征是：  程序=对象+消息   面向对象程序的基本元素是对象。面向对象程序的主要结构特点是：一、程序一般由类的定义和类的使用两部分组成；二、程序中的一切操作都是向对象发送消息来实现的，对象收到消息后，启动有关方法完成相应的操作。   需要说明的是，某一种程序设计语言不一定与一种程
java面向对象程序设计 论文_基于JAVA面向对象程序设计
weixin_28687251的博客
02-13 1409
内容介绍原文档由会员 xiaowei 发布基于JAVA面向对象程序设计------------科学养兔项目分析2.3万字 31页摘要 本文报道了对面向对象程序设计思想的基本阐述，就科学养兔项目的开发以及开发过程中所遇到的关于JAVA面向对象程序设计的问题作出详细的报道。一个系统作为一个对象来进行分析，由多个部分组成，作好系统分析工作再进一步确定各个对象的功能以及各个对象之间的关系，利用...
《面向对象程序设计》教学资源汇总（2024/2023）
教学 & 技术专栏
03-06 2055
面向对象程序设计》教学资源汇总（2023）
Labview面向对象编程
10-31
Labview面向对象编程是NI...通过学习和掌握Labview面向对象编程，开发者可以构建出更复杂、更易于维护的应用程序，适应不断变化的需求，并利用Labview的强大功能进行数据分析、控制工程、测试测量等领域的项目开发。
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
本项目是基于C++的面向对象程序设计实现，旨在教授学生如何运用面向对象编程思想来构建实际的应用程序。** **一、面向对象编程基础** 面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，其核心思想...
java面向对象编程pdf
04-16
面向对象编程（Object-Oriented Programming，OOP）是一种编程范式，它将程序设计看作是对象的交互，对象之间的关系和行为。 一、对象和类 在Java中，对象是指具有某些特征和行为的实体，例如人、学生、大象、冰箱...
Java面向对象程序设计+源代码+课后习题答案)
10-31
Java面向对象程序设计是计算机科学中的一个重要领域，它基于面向对象编程（OOP）的概念，是一种强大的编程范式。在Java中，OOP的核心概念包括类、对象、封装、继承、多态等。这本书"Java面向对象程序设计"由耿祥义和...
Delphi面向对象程序设计课件 第三章Delphi面向对象编程思想.ppt
08-16
Delphi面向对象程序设计课件
Java面试篇（JVM相关专题）
聂可以的博客
08-09 2740
Java面试篇（JVM相关专题）
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 318
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 463
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
最新发布
supercool7的博客
08-12 458
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小城小人物

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值