面向对象基础（JAVA笔记第十七期）

已于 2024-10-11 21:37:13 修改
阅读量407 收藏 7
点赞数 15
文章标签： java 笔记
于 2024-10-11 21:23:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_87139271/article/details/142738325
版权

p.s.这是萌新自己自学总结的笔记，如果想学习得更透彻的话还是请去看大佬的讲解

目录

面向对象概念

面向对象是一种编程思想
面向对象即在编程过程中使用某些具有特定功能的代码（即对象）来帮助程序员完成想做的事情
比如：如果我们想洗衣服的话就会使用具有洗衣服功能的洗衣机来帮助我们完成洗衣服这件任务

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

设计对象并使用

JAVA本身就提供了许多对象可供我们使用，但百密总有一疏。而当我们发现没有合适的对象可供我们使用时，我们便可以自力更生，自己设计对象并进行使用

类和对象

如果我们想造一个洗衣机的话，就必须先要有洗衣机的图纸
而类便是设计对象时使用的图纸
类（图纸）是对象共同特征的描述；而对象则是真实存在的具体东西

想要获得洗衣机，就得先设计图纸
因此：在JAVA中，必须先设计类，才能获得对象

类的定义（设计）

格式如下

public class 类名 {
  1.成员变量(代表属性,一般是名词)
  2.成员方法(代表行为,一般是动词)
  //3.构造器
  //4.代码块
  //5.内部类
}

举例

public class washingMachine {
    //  属性(成员变量)
    String brand;
    double price;
    //因为这是属性,所以不要赋值

    //  行为(方法)
    public void wash(){
        System.out.println("洗衣服ing..");
    }
    public  void dry(){
        System.out.println("甩干ing..");
    }
    washingMachine w = new washingMachine();
}

获取类的对象

格式如下

类名 对象名 = new 类名();

举例

washingMachine w = new washingMachine();

使用类的对象

  1. 访问属性：对象名.成员变量
  2. 访问行为：对象名.方法名(...)

创建并使用不同类里的对象举例

先设计一个类（洗衣机）

public class washingMachine {
    //  属性(成员变量)
    String brand;
    double price;
    //因为这是属性,所以不要赋值

    //  行为(方法)
    public void wash(){
        System.out.println("洗衣服ing..");
    }
    public  void dry(){
        System.out.println("甩干ing..");
    }
}

然后在类（测试） 里创建并使用**类（洗衣机）**的对象

public class test {
    public static void main(String[] args) {
        //创建洗衣机的对象(洗衣机1，即w)
        washingMachine w = new washingMachine();

        //给洗衣机赋值
        w.brand = "海尔";
        w.price = 1688;

        //获取洗衣机对象中的值
        System.out.println(w.brand);
        System.out.println(w.price);

        //调用洗衣机中的方法
        w.wash();
        w.dry();
    }
}

输出结果为

海尔
1688.0
洗衣服ing..
甩干ing..

当然，我们还可以创建洗衣机2
即

public class test {
    public static void main(String[] args) {
        //创建洗衣机的对象
        washingMachine w = new washingMachine();

        //给洗衣机赋值
        w.brand = "海尔";
        w.price = 1688;

        //获取洗衣机对象中的值
        System.out.println(w.brand);
        System.out.println(w.price);

        //调用洗衣机中的方法
        w.wash();
        w.dry();

        //创建第二个洗衣机对象
        washingMachine w1 = new washingMachine();

        //给洗衣机二赋值
        w.brand = "美的";
        w.price = 1976;

        //调用洗衣机中的方法
        w.wash();
        w.dry();
    }
}

类的定义（补充）

javabean类：是用来描述一类事物的类
在javabean类里是不写main方法的
测试类：即编写main方法的类
可以在测试类里面创建javabean类的对象并进行赋值调用
上述的 类(洗衣机) 就是一个javabean类
.
类的命名也应遵循变量的命名规则，即：见名知意、驼峰规则。
一个java文件可以定义多个class类，但只能有一个类有public修饰，而且public修饰的类名必须为代码文件名
实际开发中还是建议一个文件里就定义一个class类就行了
,
成员变量的完整定义格式为
修饰符 数据类型 变量名 = 初始化值; 一般无需指定初始化值（因为存在默认初始化值）

封装思想

封装告诉了我们如何正确地设计对象的属性和方法

对象代表什么，就得封装对应的数据，并提供数据所对应的行为
举例
人画圆，根据这个需求进行面向对象设计
那么问题来了：画圆这个行为应该是在 类（人） 里还是 类（圆） 里
而根据封装思想，画圆这一行为需要的数据是圆的半径，人只是调用了画圆的这一行为（方法）
因此：画圆这一方法应该在 类（圆） 里

封装思想的好处
让编程更加简单。有什么事，找对象，调方法就行
不用死记对象有哪些方法，需要时去找就行

关键字

public关键字

public是一个权限修饰符，表示修饰的成员在所有类里都能使用

private关键字

private是一个权限修饰符，其可以修饰成员(成员变量和成员方法)
被private修饰的成员只能在本类中才能访问
如果在别的类中调用此成员，则会报错：'成员'在'类'中具有private访问权限

还是举洗衣机的例子。如果有人"不小心"给洗衣机的价格赋值成0了，洗衣机那不就免费了吗
这时我们可以使用private修饰price来阻止别人赋不正确的值
但是用private修饰price后我们自己也不能给价格赋值了。那怎么办呢？
我们可以通过一个判断来检测赋值是否合理
而根据封装思想，这个判断应该放在washingMachine类里
而这个判断我们可以使用set方法和get方法来实现

public class washingMachine {

    private int price;

    //set方法(给price赋值)
    public void setPrice(int a){
        if (price>0){
            price = a;
        }
        else {
            System.out.println("错误:非法数据");
        }
    }
    
    //get方法(得到price的值)
    public int getPrice(){
        return price;
    }
    
}

针对每一个私有化的成员变量，都要提供get和set方法

所以**类(洗衣机)**以及调用便可优化成以下内容

public class washingMachine {
    //  属性(成员变量)
    private String brand;
    private double price;
    //因为这是属性,所以不要赋值

    //针对每一个私有化的成员变量，都要提供get和set方法
    //set方法:给成员赋值
    //get方法:对外提供成员变量的值
    public void setBrand(String b){
        brand = b;
    }
    public String getBrand(){
        return brand;
    }

    public void setPrice(double p){
        if (p>0){
            price = p;
        }
        else {
            System.out.println("非法数据!!");
        }
    }
    public double getPrice(){
        return price;
    }

    //  行为(方法)
    public void wash(){
        System.out.println("洗衣服ing..");
    }
    public  void dry(){
        System.out.println("甩干ing..");
    }

}

public class test {
    public static void main(String[] args) {
        //创建洗衣机的对象
        washingMachine w = new washingMachine();

        //给洗衣机赋值(   对象名.set成员名(进行赋值)  )
        w.setBrand("海尔");
        w.setPrice(1688);

        //获取洗衣机对象中的值(   对象名.get成员名()  )
        System.out.println(w.getBrand());
        System.out.println(w.getPrice());

        //调用洗衣机中的方法
        w.wash();
        w.dry();

        //创建第二个洗衣机对象
        washingMachine w1 = new washingMachine();

        //给洗衣机二赋值
        w.setBrand("美的");
        w.setPrice(1976);

        //调用洗衣机中的方法
        w.wash();
        w.dry();
    }
}

好处:不局限于对象属性的数量，可以通过键盘随意录入对象的属性数量

成员变量和局部变量

成员变量：定义在类下面的变量
局部变量：定义在方法下面的变量
二者区别

在这里插入图片描述

当成员变量和局部变量重名时又会怎样呢？
举例
先创建一个类（朋友）

public class friend2 {
     int height = 165;
     public void h(){
         int height = 170;
         System.out.println(height);
     }
}

再创建并使用**类(朋友)**的对象

public class friendTest2 {
    public static void main(String[] args) {
        friend2 friend2 = new friend2();

        friend2.h();
    }
}

那此时输出的结果为170
这就涉及到了一个原则

就近原则

其概念为：当有上方有两个同名的变量时(一般是一个成员变量和一个局部变量)，使用最近的变量
即：谁离我近，我就用谁

那如果我想用成员变量怎么办呢？
此时就要加上this关键字
即

public class friend2 {
     int height = 165;
     public void h(){
         int height = 170;
         System.out.println(this.height);
     }
}

此时的输出结果即为165

因此**类(洗衣机)**还可以再次优化

public class washingMachine {
    //  属性(成员变量)
    private String brand;
    private double price;
    //因为这是属性,所以不要赋值

    //针对每一个私有化的成员变量，都要提供get和set方法
    //set方法:给成员赋值
    //get方法:对外提供成员变量的值
    public void setBrand(String brand){
        this.brand = brand;
        //局部变量表示测试类中调用方法传递过来的数据
        //而等号的左边就表示的是成员变量的name
    }
    public String getBrand(){
        return brand;
    }

    public void setPrice(double price){
        if (price>0){
            this.price = price;
        }
        else {
            System.out.println("非法数据!!");
        }
    }
    public double getPrice(){
        return price;
    }

    //  行为(方法)
    public void wash(){
        System.out.println("洗衣服ing..");
    }
    public  void dry(){
        System.out.println("甩干ing..");
    }

}

经过优化后变量的命名便都遵守了见名知意的规则了

构造方法

构造方法也叫构造器、构造函数
作用：在创建变量时给成员变量进行初始化，即赋值
而且还可以让你更加简便地对对象的属性进行赋值
格式

public class 类名 {

    修饰符 类名(参数) {
        方法体;
    }

}

特点：1.方法名和类名相同，大小写也要一致
没有返回值类型，连void都没有
没有具体的返回值，即不能由return带回结果数据

如果我们调用构造方法时没有任何构造方法时，虚拟机会自动给我们一个空参构造方法
创建对象的时候由虚拟机调用，不能手动调用构造方法
每创建一次对象，就会调用一次构造方法

使用构造方法的好处

  1. 我们便可以不用使用set方法而对成员变量进行赋值
  2. 我们可以将一个对象所需要的所有属性全写在一个构造方法里，在进行赋值时只需要：调用构造方法创建对象并赋值即可，从而大大简化了代码

局限性:只能用于知道了对象所有属性的情况，且不能改变属性的数量

所以我们又又可以类(洗衣机)以及类(测试)的代码进行简化

public class washingMachine {
    //  属性(成员变量)
    private String brand;
    private double price;
    //因为这是属性,所以不要赋值


    public washingMachine(String brand,double price){
        this.brand = brand;
        //局部变量表示测试类中调用方法传递过来的数据
        //而等号的左边就表示的是成员变量的name
            if (price>0){
                this.price = price;
            }
            else {
                System.out.println("非法数据!!");
            }
    }
    public String getBrand(){
        return brand;
    }


    public double getPrice(){
        return price;
    }

    //  行为(方法)
    public void wash(){
        System.out.println("洗衣服ing..");
    }
    public  void dry(){
        System.out.println("甩干ing..");
    }

}

public class test {
    public static void main(String[] args) {
        //调用构造方法创建洗衣机对象并赋值
        washingMachine w = new washingMachine("海尔",1688);

        //获取洗衣机对象中的值(   对象名.get成员名()  )
        System.out.println(w.getBrand());
        System.out.println(w.getPrice());

        //调用洗衣机中的方法
        w.wash();
        w.dry();

        System.out.println("========================================");

        //调用构造方法创建第二个洗衣机对象并赋值
        washingMachine w1 = new washingMachine("美的",1976);

        //获取洗衣机对象中的值(   对象名.get成员名()  )
        System.out.println(w1.getBrand());
        System.out.println(w1.getPrice());

        //调用洗衣机中的方法
        w.wash();
        w.dry();
    }
}

注意事项
.
如果没有定义构造方法，系统将给出一个默认的无参数构造方法
如果定义了构造方法，系统将不再提供默认的构造方法
.
构造方法的重载
带参数构造方法和无参数构造方法，两者方法名相同(都是类名)，但是参数不同，这叫做构造方法的重载
.
无论是否使用，都建议手动书写无参数构造方法和带全部参数构造方法(因为就算你用不到无参构造方法,别人也可能会用到)
.
任何类定义出来，默认就自带了无参数构造器，不论写不写都有
一旦定义了有参数构造器，无参数构造器就没有了，此时就需要自己写无参数构造器了
所以建议无论是否使用，都建议手动书写无参数构造方法和带全部参数构造方法

标准的javabean类

标准的javabean类应该符合以下要求

  1. 类名需要见名知意
  2. 成员变量使用private修饰
  3. 提供至少两个构造方法
    • 无参构造方法
    • 带全部参数的构造方法
  4. 成员方法
    • 提供每一个成员变量对应setXxx()/getXxx()
    • 如果还有其他行为，也要写上

下面为一个标准的javabean及其快捷键

public class user{

    //属性
    private String userName;
    private int password;
    private String email;
    private String gender;
    private int age;

    //空参构造方法
    public user(){}
    //带全部参数的构造
    public user(String userName, int password, String email, String gender, int age) {
        this.userName = userName;
        this.password = password;
        this.email = email;
        this.gender = gender;
        this.age = age;
    }
    //Alt+Fn+Insert或者Alt+Insert
    //选择构造函数
    //如果点击"无选择"则会写一个空参构造方法
    //全部选择并点击确定则会写出带全部参数的构造方法


    //get和set方法
    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getPassword() {
        return password;
    }

    public void setPassword(int password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getAge() {
        return age;
    }

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


    //Alt+Fn+Insert
    //选择Getter and Setter
    //全部选择并点击确定则会写出所有参数的get方法和set方法

    //一键生成javabean类
    //下载ptg插件然后右键点击"ptg to javabean"就可以一键生成了

}

对象内存图

看黑马教程P87-90

不会聊天真君647
关注
Java OOP 面向对象编程 第二章笔记
Chun1999的博客
07-09 190
在Java中万物皆对象 class Person{ public String name; public void test(){ } } Person p = new Person(); Person() 构造方法 this(); 重载 在同一个类中方法名相同，参数列表不同（数量，类型，顺序） public void test(int a,double b){ } public void test(double a,int b){ } test(1,2.1);
JAVA基础学习笔记（五）面向对象
ww981580010的博客
02-17 1279
java面向对象
《Java面向对象程序设计》学习笔记
weixin_45940369的博客
07-31 8487
备考某学校的 817程序设计Java 专业课，在学习耿祥义老师的《Java面向对象程序设计（第3版）-微课视频版》。 发一些自己的学习笔记到专栏（一篇文章对应书上一章），可能不会及时更新，见谅。 笔记可能有错误，看看就得，现在懒得浓缩精炼了，以后再说吧🧐
Java 复习笔记 - 面向对象篇
梁辰兴的博客
09-01 1112
Java是一种面向对象的编程语言，面向对象是一种编程范式，它将程序设计看作是对象的集合，每个对象都有自己的状态和行为，并通过相互之间的消息传递来进行交互。在面向对象的编程中，可以通过定义类来创建对象。类是一种模板或者蓝图，描述了对象的属性和行为。对象是类的实例化，它具有类所定义的属性和行为。面向对象的编程有以下几个核心概念：类（Class）：类是对象的抽象，描述了一类具有相同属性和行为的对象。它定义了对象的结构和行为。对象（Object）：对象是类的实例化，是具体的实体，具有类定义的属性和行为。
Java基础知识之笔记总结分享（超详细）
热门推荐
iswitched的博客
05-03 7万+
给大家分享一篇我在学习java过程中的关于java基础部分的笔记，包含面向对象思想，集合，接口，抽象方法等等详细知识点
动力节点老杜Java零基础笔记第二章 初识Java
A_coding的博客
06-01 1010
计算机是一种现代化的电子设备，它能够接受、存储、处理和输出数据。计算机由硬件和软件两部分组成，硬件包括中央处理器（CPU）、内存、硬盘、显示器、键盘、鼠标等部件，软件则包括系统软件和应用软件。计算机可以进行各种操作，如文字处理、图形设计、音视频播放、游戏等，并且可以通过网络连接进行通信和数据交换。计算机技术的发展对人类社会的影响非常深远，它已经成为现代化社会中不可或缺的一部分。硬件是计算机系统的物理部分，主要包括以下组件：还有其他硬件组件，如声卡、网卡、显卡、光驱、散热器等。这些硬件组件共同工作，使计算机能
java学习笔记2--面向对象编程
weixin_45027619的博客
01-13 2446
面向对象编程
Java超全的面向对象复习笔记
HelloWorld
08-04 1125
文章目录Java 面向对象学习1. 类与对象1.1 面向对象简介1.2 类与对象简介1.3 类与对象的使用*1.4 对象内存分析*1.5 对象引用分析1.6 引用与垃圾产生分析2 深入分析类与对象2.1 成员属性封装2.2 构造方法和匿名对象3 this关键字3.1 this调用本类属性3.2 this调用本类方法3.3 简单Java类4 static关键字4.1 声明static属性4.2 声明static方法5 代码块5.1 普通代码块5.2 构造代码块5.3 静态代码块6 面向对象案例分析7 数组7.
【Java】【阿里云大学】面向对象编程全套笔记（更新中）
嗨Sirius
10-29 1222
之前在阿里云大学公开课上学了一些Java面向对象编程，决定把笔记和代码更新下 本文从面向对象编程开始记录（ps.阿里云老师讲的很有趣 = w =），阿里云大学Java网课网址链接 第一章 类与对象 课时2：面向对象简介 面向过程 面向对象 面对一个问题的解决方案更多情况是面对一个问题的解决方案 模块化设计，可以重用配置 面向对象有三个主要特性： 封装性：内部操作对外部不可...
Java学习笔记第三章:面向对象(动力节点)
m0_51638271的博客
04-17 1112
自用学习笔记,用来记录和复习。
小码哥-任小龙Java笔记-面向对象的全部笔记
03-12
### 小码哥-任小龙Java笔记-面向对象的核心知识点 #### 一、面向对象基础概念 **1. 成员变量** - **定义位置**：成员变量定义在类中但不在任何方法内，分为类成员变量（使用`static`修饰）和实例成员变量（不使用...
Java 基础 第1阶段：基本语法-尚硅谷学习笔记（含面试题） 2023年
05-09
十、面向对象编程基础 Java是完全面向对象的语言，包括类、对象、封装、继承、多态等概念。类是对象的蓝图，对象是类的实例。封装是隐藏内部实现细节，提供公共接口。继承允许子类继承父类的属性和方法。多态是指...
Java基础笔记总结
09-23
面向对象是Java的核心特性，通过定义类来描述对象的属性和行为。类的实例化（new关键字）产生对象，对象之间可以通过继承和多态实现代码复用和灵活设计。 九、异常处理 Java使用try-catch-finally语句块处理异常，...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 946
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
最新发布
杨荧的CSDN博客
10-10 1002
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1275
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 376
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 711
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
基于JavaWeb开发的java springmvc+mybatis酒水商城管理系统设计和实现
央顺科技官方博客
10-08 1512
基于JavaWeb开发的java springmvc+mybatis酒水商城管理系统设计和实现
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值