Java之类和对象（上）

已于 2023-01-04 14:12:06 修改
阅读量152 收藏
点赞数 1
文章标签： java
于 2023-01-01 19:11:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quanydi/article/details/128512915
版权

文章目录

类和对象

面向对象的初步认知

img

什么是面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

面向对象与面向过程

传统洗衣服过程

在这里插入图片描述

传统洗衣服所注重的是过程，每个过程都需要注意细节，多一步，少一步都可能出现问题。按照该种方式来写代码，将来扩展或者维护起来会比较麻烦。

现代洗衣服过程

在这里插入图片描述

在这里插入图片描述

这里有四个对象：人，衣服，洗衣服，洗衣机

与传统洗衣服过程不同的是虽然都是由洗衣机，衣服，人，洗衣粉都有参与进来。人只需要把洗衣粉，放进洗衣机，并开启洗衣机就行，人不用关心洗衣机是如何洗衣服的过程

🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉🍉

以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的。

注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

类定义和使用

面相对象程序设计关注的是对象，而对象是现实生活中的实体。如小猫

查看源图像

猫的品种，颜色，体重，猫会抓老鼠，吃饭…

这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述。

🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱

简单认识类

类是用来对一个实体(对象)来进行描述的，主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)。这样的话计算机就可以进行识别了。

描述一只小猫

猫的属性有： 品种
           体重
           颜色
 猫的行为有：吃饭
           玩耍
           睡觉          

class Cat{
    public String varieties;//成员变量
    public int weight;//成员变量
    public String color;//成员变量
    public void eat() {
        System.out.println("吃饭");//成员方法
    }
        public void play(){
            System.out.println("玩耍");//成员方法
        }
        public void sleep(){
            System.out.println("睡觉");//成员方法
        }
}

通常情况下我们把猫的属性称为成员变量（这与局部变量不同不用赋初值，后面会讲到），把猫的行为成员方法，

注意事项

类名注意采用大驼峰定义

成员前写法统一为public

一般一个文件当中只定义一个类

main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)

public修饰的类必须要和文件名相同

不要轻易去修改public修饰的类的名称，如果要修改，通过开发工具修改

🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱

类的实例化

什么是实例化

定义了一个类，就相当于在计算机中定义了一种新的类型，与int，double类似，只不过int和double是java语言自

带的内置类型，而类是用户自定义了一个新的类型。如上面的猫，它们都是类(一种新定义的类型)有了这些自定义的类型之后，就可以使用这些类来定义实例(或者称为对象)。

用类类型创建对象的过程，称为类的实例化，在Java中采用new关键字，配合类名来实例化对象。

class Cat{
    public String varieties;
    public int weight;
    public String color;
    public void eat() {
        System.out.println("吃饭");
    }
        public void play(){
            System.out.println("玩耍");
        }
        public void sleep(){
            System.out.println("睡觉");
        }
}
public class study {
    public static void main(String[] args) {
        Cat cat1 =new Cat();
        cat1.varieties="布偶";
        cat1.weight=20;
        cat1.color="白色";
        cat1.eat();
        cat1.play();
        cat1.sleep();
        Cat cat2 =new Cat();
        cat2.varieties="缅因";
        cat2.weight=15;
        cat1.color="黄色";
        cat2.eat();
        cat2.play();
        cat2.sleep();
    }
}

注意事项

new 关键字用于创建一个对象的实例.

使用 . 来访问对象中的属性和方法.

同一个类可以创建对个实例.（我在这里实例化了俩个对象cat1和cat2）

类和对象的说明

  1. 类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.

  2. 类是一种自定义的类型，可以用来定义变量.

  3. 一个类可以实例化出多个对象，实例化出的对象 占用实际的物理空间，存储类成员变量

  4. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东

西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

在这里插入图片描述

我画了一个内存图来举例子

在这里插入图片描述

每个对象都有自己的成员

cat1和cat2是引用变量在栈上开辟空间用来存它俩对象（即成员变量或（称为局部变量)）的地址。成员方法在方法区上不占用内存，何时用合适再调。

每次new一次即实例化一次就开辟一次空间

这与数组的引用基本一样，我的上一篇文章中提到过 对了

1.当一个对象赋值null的时候这个引用不知向任何对象。

2.一个引用只能指向一个对象

3.引用不能指向引用
img

🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱

this引用

this引用指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该

引用去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

class Cat{
    public void birth(int year,int month,int day){
        System.out.println("猫的生日是"+year+""+month+""+day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat1 =new Cat();
        cat1.birth(2023,1,1);
        Cat cat2 =new Cat();
       cat2.birth(2022,12,31);
    }
}

以这个为基础在方法后面改一下

class Cat{
    int year;
    int month;
    int day;
    public void birth(Cat this,int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
        System.out.println("猫的生日是"+year+""+this.month+""+this.day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat1 =new Cat();
        cat1.birth(2023,1,1);
        Cat cat2 =new Cat();
       cat2.birth(2022,12,31);
    }
}

在这里插入图片描述

运行成功

通过这个可以知道

每个方法第一参数是this

this代表的是当前对象的引用

this.year=year; this.month=month; this.day=day;

this代表当前引用的对象，即cat1调用这个方法的话就是给cat1当前的对象year赋值，cat2调用这个方法的话就是给cat2当前的对象year赋值，如上面的内存图所视，year为cat1和cat2引用的对象，cat1和cat2所引用的对象之间是互不干扰。

this引用的特性

  1. this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

  2. this只能在"成员方法"中使用。//在静态方法不能使用。

  3. 在"成员方法"中，this只能引用当前对象，不能再引用其他对象

  4. this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法

    对象的引用传递给该成员方法，this负责来接收

    除此之外this可以访问成员方法

    class Cat{
    int year;
    int month;
    int day;
    public void func(){
        System.out.println("ok");
        this.get(2023,1,1);
    }
    public void get(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
        System.out.println("猫的生日是"+year+""+this.month+""+this.day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat1 =new Cat();
        cat1.func();

    }
}

    注意：this不能再静态方法中使用

    this可以访问构造方法 这个下面再讲

对象的构造及初始化

构造方法

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且

在整个对象的生命周期内只调用一次。总而言之就是必须与类名一样，没有返回值。如果自己写了构造方法编译器，便不会提供，仅会调用自己写的。

class Cat{
    int year;
    int month;
    int day;
    public Cat(){//这个为构造方法
        System.out.println("iii");
    }
    public void birth(Cat this,int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
        System.out.println("猫的生日是"+year+""+this.month+""+this.day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat1 =new Cat();
        cat1.birth(2023,1,1);
        Cat cat2 =new Cat();
       cat2.birth(2022,12,31);
    }
}

在这里插入图片描述

出现了俩次iii即cat1和cat2都调用了一次

注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

特性

  1. 名字必须与类名相同

  2. 没有返回值类型，设置为void也不行

  3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)

  4. 构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

class Cat{
    int year;
    int month;
    int day;
    public Cat(){
        System.out.println("ok");
    }
    public Cat(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
        System.out.println("猫的生日是"+year+""+this.month+""+this.day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat1 =new Cat(2023,1,1);
        Cat cat2=new Cat();
    }
}

public Cat(){ }

public Cat(int year,int month,int day){

}

这俩个实现了重载。

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

  1. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法

**注意：**一旦用户定义，编译器则不再生成。

  1. 构造方法中，可以通过this调用其他构造方法来简化代码

    class Cat{
    int year;
    int month;
    int day;
    public Cat(){
        this(2023,1,1);
        System.out.println("ok");
    }
    public Cat(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
        System.out.println("猫的生日是"+year+""+this.month+""+this.day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat2=new Cat();
    }
}

在这里插入图片描述

this(2023,1,1);调用了public Cat(int year,int month,int day)

因此可以说明this可以调用构造方法。

this(…)必须是构造方法中第一条语句

并且不能形成环

如

class Cat{
    int year;
    int month;
    int day;
    public Cat(){
        this(2023,1,1);//不能这样用
        System.out.println("ok");
    }
    public Cat(int year,int month,int day){
        this();//不能这样用
        this.year=year;
        this.month=month;
        this.day=day;
        System.out.println("猫的生日是"+year+""+this.month+""+this.day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat2=new Cat();
    }
}

这是错误的 当this(2023,1,1);调用public Cat(int year,int month,int day)的时候 this();又想调用 public Cat()形成闭环会导致编译错误

  1. 绝大多数情况下使用public来修饰，特殊场景下会被private修饰

就地初始化

在声明成员变量时，就直接给出了初始值

class Cat{
    int year=2022;
    int month=1;
    int day=1;
    public void func(){
        System.out.println("ok");
        this.get(2023,1,1);
    }
    public void get(int year,int month,int day){
        this.year=year;
        this.month=month;
        this.day=day;
        System.out.println("猫的生日是"+year+""+this.month+""+this.day);
    }
}
public class study {
    public static void main(String[] args) {
        Cat cat1 =new Cat();
        cat1.func();

    }
}

🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱🐱
img
今天是2023年的第一天。祝大家新年快乐。
我今天本来想把类和对象都搞定的😔才整了一半，这篇也是今年我的第一篇博客，我在此重新立下flag 这一年要好好学习，在新的一年我们一起努力吧。

小心翼翼...
关注
Java类和对象之对象组合之求圆柱体积
我写写哈的博客
10-17 2999
任务描述 相关知识 类的组合 类的关联关系 编程要求 测试说明 任务描述 本关任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。 圆柱的体积公式：S=πr 2 h。 相关知识 复用代码是 Java 众多引人注目的功能之一。Java 解决问题都围绕类展开的，对于复用代码，可以创建新的类来复用，也可以使用别人已经开发并调试好的类。方法的关键在于使用类而不破坏现有程序代码。有两种方式达成此方法的目的：组合和继承。本实训主要讲解类的组合。 类的组合 组合：新的类由现有类的对象所组成（复用现有代码的功能，
12、Java——对象和类案例代码详解
不迁怒，不贰过。小知识，大智慧。
09-18 1907
对象和类学习后的配套练习代码详解
学习java的第十一课——认识类与对象
redredredr21的博客
10-14 303
认识类与对象 学习方法 理解类和对象的关系是本次课内容的前提， 放眼身边，多举例，多联想，多理解 定义类和对象，固定模板需要记忆，套用模板，多定义几个类以及对象，举一反三 代码规范意识很重要，一定要遵守（如定义类、方法、取名） 1.面向对象编程概述 软件开发阶段 ​ 需求分析 ​ 软件设计 ​ 软件开发 ​ 软件测试 ​ 软件的部署和维护 身边的对象和类 java程序中的类就是显示生活中的类别，是一个笼统的概念 java中的对象就是现实生活中的个体，他是一个类别下的一个具象 2.类和对象 在现实中
Java之类和对象
qq_53190275的博客
11-09 838
类和对象
java第十一章类和对象_JAVA逻辑 第十一章:类和对象
weixin_39802055的博客
02-27 305
对象：用来描述客观事物的一个实体,由一组属性和方法构成。类的特征(属性)和行为(方法)：类的属性：对象所拥有的静态特征在类中表示时称为类的属性。类的方法：对象执行的操作称为类的方法。类和对象的关系是抽象和具体的关系。类是对象的类型，对象是类的实例。对象的属性和方法被共同封装在类中，相辅相成，不可分割。面向对象程序设计的优点如：1：与人类的思维习惯一致。2：隐藏信息，提高了程序的可维护性和...
第十一章 类和对象
angshou7239的博客
08-07 704
一、本章技能目标掌握类和对象理解封装会创建和使用对象二、内容1 对象分类是人们认识世界的一个很自然的过程，在日常生活中会不自觉地进行分类什么是对象，对角是用来描述客户事物的一个实体Java是一种面向对象的编程语言1.1 身边的对象用向对象方法来解决问题是，首先要对现实世界中的对象进行分析与归纳，找出哪些对象与要解决的问题是相关的对象都有一些特征，这些特征是有别于其他对象所以对象由特征和...
第十一章类和对象
dasanke1762的博客
08-10 178
（1） 1.万物皆对象：（地球上有什么？我们会不自觉的将地球上的事物归为具体类别） 2.对象：顾客 ， 收银员； 官方定义：用来描述客观事，由一组属性和方法构成。 3.类就是对象的类型。 4.封装：封装就是把一事物包装起来和涵盖属性的方法。 5.类的命名规则：（1）不能使用java关键字。 ...
java基础-类和对象的定义
05-21
通过书籍，个人整理的java基础之类的对象的定义的有关知识点
Educoder题目：Java面向对象 - String类答案解析.md
11-09
Educoder题目：Java面向对象 - String类答案解析
练习-Java类和对象之对象组合之求圆锥体表面积
qwe13931834862的博客
02-23 1964
** 任务：已知圆锥的母线为 15，底面半径为 8，求圆锥的表面积。 */ // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码 /********** Begin **********/ // 定义一个圆类，类名为 Circle class Circle{ // 定义两个量，分别为半径和π值 double r; double pi=Math.PI； Cone con; // 有参构造器 public Circle(double r){ this.r=r; } // 定义一个方法，实
使用Java理解程序逻辑第11章.zip
04-20
【原创作者田超凡，未经许可请勿转发，侵权仿冒必究】
第11章复习 类和对象
qq_36074163的博客
09-07 609
1 对象   描述客观事物的一个实体,由一组属性(静态特征)和方法(动态特征)构成.2  类( 骆驼命名法)   定义书对象将会拥有的 (属性)和(方法)     (帕斯卡命名法)3 类和对象的关系抽象的和具体的关系 类是对象的类型 对象是类的实例4 封装对象的属性和方法被共同封装在类中 相铺相成 不可分割 5 面向程序设计的优点 与人类的思维习惯一致 隐藏信息,提高了程序的可维护性和安全性 提高
java类和对象上机作业_Java学习（一）--类与对象（1）(示例代码)
weixin_31032799的博客
02-27 421
一。面向对象编程的三大特性1.封装性面向对象编程的核心思想之一就是将数据和对数据的操作封装在一起。通过抽象，即从具体的实例中抽取出共同的性质形成一般的概念，例如类的概念。2.继承继承体现了一种先进的编程模式。子类可以继承父类的属性和行为，即继承父类所具有的数据和数据上的操作，同时又可以增添子类独有的数据和数据上的操作。3.多态多态是面向对象编程的又一重要特征，有两种意义的多态。一种多态是操作名称的...
第11章上机练习
qq_36074157的博客
09-07 1187
package wz; public class Administrator { String name;//姓名 String password;//密码 // 显示信息方法 public void show() { System.out.println("姓名:" + name + ",密码:" + password); } /*public stat
JAVA第十一章复习
qq_36074092的博客
09-07 393
封装:把一个事物包装起来,并尽可能隐藏内部细节. 对象的属性和方法是相辅相成的,不可分割的,他们共同组成了实体对象.因此,对象具有封装性. 类定义了对象将会拥有的特征(属性)和行为(方法). 类的属性:对象所拥有的静态特征在类中表示时称为累的属性. 类的方法              对象执行的操作为类的方法. 类和对象的关系   一个类为它的对象给出了一个统一的定义,而它每个对象则
java-第十章-类和对象-定义客户类
weixin_33860722的博客
06-14 504
package上机练习; publicclassA02class{ intIntegral; StringCard; publicvoidA02(){ System.out.println("积分:"+Integral+",卡类型:"+Card); } } 转载于:https://blog.51cto.com/765133133/142...
【JavaSE】初识类和对象——this引用、构造方法
qq_41233305的博客
11-10 748
【JavaSE】类和对象——this 引用、构造方法
java中的this关键字
最新发布
EXECEL的博客
11-14 621
this关键字
Java类与对象：属性和方法解析
本文将深入探讨Java中的类和对象，这是Java编程的基础概念。类是对象的蓝图，定义了对象的属性（数据成员）和方法（功能）。对象则是类的实例，具备类所定义的特性。 在Java中，类用于封装数据和行为。描述中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值