面向对象

最新推荐文章于 2024-09-24 08:39:48 发布
最新推荐文章于 2024-09-24 08:39:48 发布
阅读量139 收藏
点赞数
分类专栏： Java基础部分 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TiAmonal/article/details/107794277
版权

1.面向对象

  1. 面向对象思想概述

    Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下,使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想.它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

  2. 特点:

    面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态.

  3. 面向对象和面向过程

    • 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节。

    • 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事儿。

      //用打印数组来举例 : 说明面向对象的思想和面向过程思想的区别
public class Demo01PrintArray {

    public static void main(String[] args) {
        int[] array = { 10, 20, 30, 40, 50, 60 };

        // 要求打印格式为：[10, 20, 30, 40, 50]
        // 使用面向过程，每一个步骤细节都要亲力亲为。
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if (i == array.length - 1) { // 如果是最后一个元素
                System.out.println(array[i] + "]");
            } else { // 如果不是最后一个元素
                System.out.print(array[i] + ", ");
            }
        }
        System.out.println("==============");

        // 使用面向对象
        // 找一个JDK给我们提供好的Arrays类，
        // 其中有一个toString方法，直接就能把数组变成想要的格式的字符串
        System.out.println(Arrays.toString(array));
    }

}

2.类与对象

  1. 类与对象 :

    类是对象的抽象,对象是类的具体 . 可以直观理解为 : 类是一个集合,比如学生类,是一个概述.而对象就是类的具体描述, 具体到某一个学生 小明 就是一个鲜活的对象.

  2. ​ 对象的使用场景: 通常情况下，一个类并不能直接使用，需要根据类创建一个对象，才能使用。创建对象的具体过程.

    1. 导包：也就是指出需要使用的类，在什么位置。
      import 包名称.类名称;
      import cn.itcast.day06.demo01.Student;
      对于和当前类属于同一个包的情况，可以省略导包语句不写。

    2. 创建，格式：
      类名称 对象名 = new 类名称();
      Student stu = new Student();

    3. 使用，分为两种情况：
      使用成员变量：对象名.成员变量名
      使用成员方法：对象名.成员方法名(参数)
      （也就是，想用谁，就用对象名点儿谁。）

    注意事项：

    如果成员变量没有进行赋值，那么将会有一个默认值，规则和数组一样。

    public class Demo02Student {

    public static void main(String[] args) {
        // 1. 导包。
        // 我需要使用的Student类，和我自己Demo02Student位于同一个包下，所以省略导包语句不写

        // 2. 创建，格式：
        // 类名称 对象名 = new 类名称();
        // 根据Student类，创建了一个名为stu的对象
        Student stu = new Student();

        // 3. 使用其中的成员变量，格式：
        // 对象名.成员变量名
        System.out.println(stu.name); // null
        System.out.println(stu.age); // 0
        System.out.println("=============");

        // 改变对象当中的成员变量数值内容
        // 将右侧的字符串，赋值交给stu对象当中的name成员变量
        stu.name = "赵丽颖";
        stu.age = 18;
        System.out.println(stu.name); // 赵丽颖
        System.out.println(stu.age); // 18
        System.out.println("=============");

        // 4. 使用对象的成员方法，格式：
        // 对象名.成员方法名()
        stu.eat();
        stu.sleep();
        stu.study();
    }

}

  3. 成员变量和局部变量的区别:

    1. 定义的位置不一样【重点】
      局部变量：在方法的内部
      成员变量：在方法的外部，直接写在类当中

    2. 作用范围不一样【重点】
      局部变量：只有方法当中才可以使用，出了方法就不能再用
      成员变量：整个类全都可以通用。

    3. 默认值不一样【重点】
      局部变量：没有默认值，如果要想使用，必须手动进行赋值
      成员变量：如果没有赋值，会有默认值，规则和数组一样

    4. 内存的位置不一样（了解）
      局部变量：位于栈内存
      成员变量：位于堆内存

    5. 生命周期不一样（了解）
      局部变量：随着方法进栈而诞生，随着方法出栈而消失
      成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失

    
   public class Demo01VariableDifference {

    String name; // 成员变量

    public void methodA() {
        int num = 20; // 局部变量
        System.out.println(num);
        System.out.println(name);
    }

    public void methodB(int param) { // 方法的参数就是局部变量
        // 参数在方法调用的时候，必然会被赋值的。
        System.out.println(param);

        int age; // 局部变量

   //        System.out.println(age); // 没赋值不能用

//        System.out.println(num); // 错误写法！
        System.out.println(name);
    }

}

3.三大特性 - 封装

  1. 封装概述:

    面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。

    封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

  2. 封装在Java中的体现:

    方法就是一种封装

    public class Demo02Method {
	public static void main(String[] args) {
    int[] array = {5, 15, 25, 20, 100};

    int max = getMax(array);
    System.out.println("最大值：" + max);
}

// 给我一个数组，我还给你一个最大值
public static int getMax(int[] array) {
    int max = array[0];
    for (int i = 1; i < array.length; i++) {
        if (array[i] > max) {
            max = array[i];
        }
    }
    return max;
	}
}

    关键字private也是一种封装

  3. 面向对象三大特征：封装、继承、多态。

    封装性在Java当中的体现：

    1. 方法就是一种封装
    2. 关键字private也是一种封装

    封装就是将一些细节信息隐藏起来，对于外界不可见。

  4. 原则:

    将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

  5. 封装的步骤

    使用 private 关键字来修饰成员变量。

    对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

    //定义一个学生类,属性用privte关键字来修饰.提供对外访问的方法 
//对于基本类型当中的boolean值，Getter方法一定要写成isXxx的形式，而setXxx规则不变。
public class Student {

    private String name; // 姓名
    private int age; // 年龄
    private boolean male; // 是不是爷们儿

    public void setMale(boolean b) {
        male = b;
    }

    public boolean isMale() {
        return male;
    }

    public void setName(String str) {
        name = str;
    }

    public String getName() {
        return name;
    }

    public void setAge(int num) {
        age = num;
    }

    public int getAge() {
        return age;
    }
}

    //定义一个测试类
public class Demo04Student {

    public static void main(String[] args) {
        Student stu = new Student();

        stu.setName("鹿晗");
        stu.setAge(20);
        stu.setMale(true);

        System.out.println("姓名：" + stu.getName());
        System.out.println("年龄：" + stu.getAge());
        System.out.println("是不是爷们儿：" + stu.isMale());
    }

}

  6. 定义访问的规则,如果规则不满足,则无法对内部的属性等进行相关操作

    问题描述：定义Person的年龄时，无法阻止不合理的数值被设置进来。

    解决方案：用private关键字将需要保护的成员变量进行修饰。

    一旦使用了private进行修饰，那么本类当中仍然可以随意访问。
    但是！超出了本类范围之外就不能再直接访问了。

    间接访问private成员变量，就是定义一对儿Getter/Setter方法

    必须叫setXxx或者是getXxx命名规则。
    对于Getter来说，不能有参数，返回值类型和成员变量对应；
    对于Setter来说，不能有返回值，参数类型和成员变量对应。

    public class Person {

    String name; // 姓名
    private int age; // 年龄

    public void show() {
        System.out.println("我叫：" + name + "，年龄：" + age);
    }

    // 这个成员方法，专门用于向age设置数据
    public void setAge(int num) {
        if (num < 100 && num >= 0) { // 如果是合理情况
            age = num;
        } else {
            System.out.println("数据不合理！");
        }
    }

    // 这个成员方法，专门私语获取age的数据
    public int getAge() {
        return age;
    }

}

    public class Demo03Person {

    public static void main(String[] args) {
        Person person = new Person();
        person.show();

        person.name = "赵丽颖";
//        person.age = -20; // 直接访问private内容，错误写法！
        person.setAge(20);
        person.show();
    }

}

4.构造方法

  1. ​ 构造方法的作用:

    构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

    格式：
public 类名称(参数类型 参数名称) {
    方法体
}

  2. 注意事项：

    1. 构造方法的名称必须和所在的类名称完全一样，就连大小写也要一样
    2. 构造方法不要写返回值类型，连void都不写
    3. 构造方法不能return一个具体的返回值
    4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体什么事情都不做。
      public Student() {}
    5. 一旦编写了至少一个构造方法，那么编译器将不再赠送。
    6. 构造方法也是可以进行重载的。
      重载：方法名称相同，参数列表不同。
    public class Student {

    // 成员变量
    private String name;
    private int age;

    // 无参数的构造方法
    public Student() {
        System.out.println("无参构造方法执行啦！");
    }

    // 全参数的构造方法
    public Student(String name, int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name;
        this.age = age;
    }

    // Getter Setter
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

}

    public class Demo02Student {

    public static void main(String[] args) {
        Student stu1 = new Student(); // 无参构造
        System.out.println("============");

        Student stu2 = new Student("赵丽颖", 20); // 全参构造
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        // 如果需要改变对象当中的成员变量数据内容，仍然还需要使用setXxx方法
        stu2.setAge(21); // 改变年龄
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());

    }

}

  3. 当方法的局部变量和类的成员变量重名的时候,会发生什么 ???

    public class Person {

    String name; // 我自己的名字,成员变量

    // 参数name是对方的名字
    // 成员变量name是自己的名字
    public void sayHello(String name) { // 形式参数 name 和 成员变量 重名情况  ...
        System.out.println(name + "，你好。我是" + name);
    }

}

    public class Demo01Person {

    public static void main(String[] args) {
        Person person = new Person();
        // 设置我自己的名字
        person.name = "王健林";
        person.sayHello("王思聪");
    }

}

    //打印结果 :
王思聪，你好。我是王思聪 ----- . 根据“就近原则”，优先使用局部变量产生这个结果.
com.briup.If.Person@133314b
com.briup.If.Person@133314b

  4. 如何解决上述问题? ------ this 关键字

    如果需要访问本类当中的成员变量，需要使用格式：
    this.成员变量名

    “通过谁调用的方法，谁就是this。”

    public class Person {

    String name; // 我自己的名字

    // 参数name是对方的名字
    // 成员变量name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + "，你好。我是" + this.name);
        System.out.println(this);
    }

}

    public class Demo01Person {

    public static void main(String[] args) {
        Person person = new Person();
        // 设置我自己的名字
        person.name = "王健林";
        person.sayHello("王思聪");

        System.out.println(person); // 地址值
    }

}

//结果为 :
王思聪，你好。我是王健林
com.briup.If.Person@133314b
com.briup.If.Person@133314b

5.标准的JavaBean

  1. 定义一个标准的类

    一个标准的类通常要拥有下面四个组成部分：

    1. 所有的成员变量都要使用private关键字修饰
    2. 为每一个成员变量编写一对儿Getter/Setter方法
    3. 编写一个无参数的构造方法
    4. 编写一个全参数的构造方法

    这样标准的类也叫做Java Bean

    public class Student {

    private String name; // 姓名
    private int age; // 年龄

    public Student() {
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


    public class Demo01Student {

    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("迪丽热巴");
        stu1.setAge(20);
        System.out.println("姓名：" + stu1.getName() + "，年龄：" + stu1.getAge());
        System.out.println("=================");

        Student stu2 = new Student("古力娜扎", 21);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
        stu2.setAge(22);
        System.out.println("姓名：" + stu2.getName() + "，年龄：" + stu2.getAge());
    }

}
灬洋洋
关注
专栏目录
c加加属于面向对象的程序设计语言吗,下列语言中属于面向对象的程序设计语言是______。A、Visual BasicB、PASCALC、CD、FORTRAN...
weixin_39910523的博客
05-18 1651
下列语言中属于面向对象的程序设计语言是______。A、Visual BasicB、PASCALC、CD、FORTRAN更多相关问题经纬仪如存在指标差，将使观测结果出现( )。德治的约束作用主要通过内心信念、传统习俗、社会舆论对人的影响体现出来，表现为( )和体现出来。在Excel2010工作表中，如果双击输入有公式的单元格或先选择单元格再按F2键，则单元格显示下面关于订单功能描述正确的是卡内基梅...
Vue 生命周期流程(面向对象编程)
weibuo的博客
04-24 2082
Vue 面向对象编程 面向对象的程序设计实质就是选用一种面向对象程序设计语言(OOPL)，采用对象、类及其相关概念所进行的程序设计。 其中面向对象语言是以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。OOPL包括：java、golang、python、c++ 等服务端当下流行的语言。 面向对象的思想中有两个重要概念：类、对象 new Vue()所有程序都会在其中执行，挂载到主干html上然后根据代码进行局部刷新，实现（SPA单页面应用），此时.
什么是面向对象的程序设计语言？
又一颗葱的根据地
08-08 3780
一种真正的面向对象程序设计语言，要符合四个条件： 抽象：有效管理一个问题的负责性，做法是划分出于该问题相关的一组对象。 封装：将一个抽象的内部实现隐藏在特定的对象之内。 多态：提供相同方法的多种操作实作。如：不同的对象会拥有一个save方法，但每个save方法会执行不同的操作。 继承：VS2005最令人兴奋之处就是继承的特性，可以重复使用一个类的实例。 【多态与重载的区别】： 网上看到
HTML与程序设计语言有何区别,面向对象的程序设计语言是一种什么语言？与面向过程的语言有什么区别？...
weixin_33267830的博客
05-31 1101
小伙伴们知道面向对象语言是一种什么语言吗?除了面向对象语言，我们知道还有面向过程的语言，你们知道它们有什么区别吗?下面听小编说一说自己的理解吧。面向对象程序设计语言是什么语言?面向对象程序设计语言它是一种以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，对象就是程序运行时刻的基本成分。在面向对象程序设计语言中有以下四大主要特点：-识认性--多态性--类别性-继承性使用面向对...
面向对象的语言主要有哪些
NCTU_to_prove_safety的博客
01-07 2万+
面向对象程序设计(Object Oriented Programming，OOP)的实质是选用一种面向对象程序设计语言(OOPL)，采用对象、类及其相关概念所进行的程序设计。主要有Smalltalk、Eiffel、C++、Java、PHP等。 1、Smalltalk 一种面向对象的程序设计语言：它是一种面向对象的语言，包含语言的语法和语义。一些编译器可以通过Smalltalk源程序产生可执行文...
面向对象基础
无简介
05-13 1万+
面向对象和面向过程是两种不同的编程范式，它们在代码组织、设计思想和解决问题的方式上有很大的区别。1. 抽象层次不同：面向过程编程以过程或函数为中心，强调程序的执行顺序和步骤。代码主要是一系列的过程（函数）调用，以完成特定的任务。面向对象编程以对象为中心，强调事物之间的关系和交互。代码主要是由对象组成，每个对象包含数据和操作数据的方法。2. 数据处理方式不同：数据和函数（过程）是分开的，数据通过函数进行处理和操作。数据和操作数据的方法被封装在一起，通过对象进行处理和操作。
【愚公系列】软考中级-软件设计师 047-面向对象技术（考点简介）
热门推荐
时光隧道
01-25 5万+
面向对象技术（Object-oriented technology）是一种软件开发方法论，也是一种编程范式，它通过将系统中的实体抽象为对象，并将对象之间的关系和行为通过封装、继承和多态等机制进行描述和实现。概念描述封装数据和方法封装在一个对象中，通过限制对对象内部的访问来隐藏实现细节，提高了程序的模块化和安全性。继承一个类可以从另一个类派生而来，并继承父类的属性和方法。继承可以提高代码的重用性和扩展性。多态同一类型的对象在不同的上下文环境下可以表现出不同的行为。
面向对象的思维过程
03-02
本文是关于面向对象思维过程系列文章的第一部分，选择这个主题作为书籍或专栏的标题是一个重大的决定，做出这个选择并不简单，因为已经有很多面向对象主题的好书和文章了，包括面向对象分析、面向对象设计、面向对象...
java班级管理系统(java+面向对象+源码)
08-04
java班级管理系统(java+面向对象+源码) java班级管理系统(java+面向对象+源码) java班级管理系统(java+面向对象+源码) java班级管理系统(java+面向对象+源码) java班级管理系统(java+面向对象+源码) java班级管理...
面向对象程序设计上海交大谢振华
07-01
面向对象程序设计上海交大谢振华课后简答题答案
漫画面向对象编程 Java
06-16
借助于漫画展示的形式，面向对象的简、由类创建一个对象的方法、类的编写与对象的创建、类的构造函数、类的方法、修饰符、Java中的封装/继承/多态等特征、Java中的线程、用Java创建一个小世界、多线程共享数据，以及...
plc面向对象编程架构与实现
01-19
面向对象编程是计算机语言的一种先进的编程模式，在工业控制系统的PLC程序中也可以采用这种设计思想，虽然我们无法实现面向对象的很多特点如“继承”，甚至于它根本就不具备面向对象编程语言的特点，但面向对象编程...
Git学习笔记
TiAmo_Lyj的博客
08-05 173
一直想系统性的再学习一遍Git的基本操作的，此前Git的一些操作都是借助webstrom这样的开发工具来完成的，所以昨天在b站上过了一遍相关视频后，总结一下相关收获，供自己随时翻阅。 我是看的这个学习的基本操作，点击跳转 1. Git相关知识 Git可分为以下四个工作区域： 1）工作目录（Working Directoty）：平时存放代码的地方，也就是项目文件夹里面的内容 2）暂存区（Stage/Index）：本质就是一个文件，用于临时存放改动 3）资源库（Repository）：用于存放数据的地方，H.
Arthas sysenv（查看JVM的环境变量）
刘大猫
09-21 389
Arthas sysenv（查看JVM的环境变量）
JDK17新增语法特性
2201_76124988的博客
09-20 772
从springboot3.0开始，已经不支持JDK8，转变为JDK17参考资料：官方博客。
Java Alibaba Druid 数据库连接池
最新发布
miracle的专栏
09-24 548
在Java开发中，数据库连接池是性能优化的重要一环。而作为一款强大的数据库连接池解决方案，凭借其和对多种数据库的支持，成为了许多企业级应用的首选。本篇文章将介绍Druid的核心特性，并结合不同数据库的实际用法。
faiss安装 （CPU版本）
CSDN_WHB的博客
09-20 294
faiss版本 faiss-v1.7.4。
面试突击-多线程和IO专题(至尊典藏版)
人生若只初相见@的博客
09-18 2606
金九银十多线程和IO大厂面试专题
SpringCloud config native 配置
rita_0567的博客
09-19 726
- Eureka-Server 依赖 -->org.springframework.cloudspring-cloud-starter-netflix-eureka-server
面向对象测试方法解析
"面向对象的测试" 面向对象的测试是一种针对使用面向对象技术开发的软件进行验证和确认的方法。在软件工程中，由于面向对象（OO）系统的特点，如对象的独立性、松散耦合以及可能的复用，使得面向对象测试与传统的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值