day06_面向对象_类_创建对象_对象内存图

沐沐霸

已于 2023-10-19 17:44:43 修改

阅读量222

点赞数 2

分类专栏： # Java2313 文章标签： java

于 2023-10-16 17:44:08 首次发布

本文链接：https://blog.csdn.net/weixin_39641494/article/details/133863819

版权

Java2313 专栏收录该内容

38 篇文章 13 订阅

订阅专栏

今日内容

1 复习
2 面向对象编程介绍
3 面向对象

类,属性,方法 ,创建对象,使用对象
内存关系

一、复习

周一: jdk,配置环境变量,idea,HelloWorld
变量,基本数据类型
周二: 运算符,if,if-else
周三: if-elseif-elseif-else,循环(while,dowhile,for)
周四: 方法设计(参数,返回值),数组入门
周五: 数组(创建,存取,内存,遍历,排序,Arrays)

java的基本数据类型有哪些: 8种
java的引用数据类型有哪些: 数组,类,接口
变量什么作用: 装数据的
数组什么作用: 装多个数据的
如何获得数组的长度: 数组名.length
数组的两种常用的创建方式

指定长度,不指定元素,数据类型[] 数组名 = new 数据类型[长度];
指定元素,不指定长度,数据类型[] 数组名 = {元素1,元素2,…};
Arrays.sort()什么作用
将数组按照升序排序

Arrays.toString()什么作用

不是遍历数组,不是将数组元素输出的
toString(),将数组元素按照字符返回

再次强调,数组的特点

数组只能存储同种类型数据
数组长度固定,创建数组后,长度不能改变

二、面向对象编程的介绍

2.1 面向对象编程介绍

面向过程开发: C

主要关注实现的步骤
例如: 吃包子
考虑面粉,和面,肉,剁肉馅,包包子,开火蒸包子,出锅吃包子

面向过程开发,简单项目,逻辑不复杂,功能模块少适合用
如果项目功能越来越多,越来越复杂,那么面向过程就会异常麻烦
应用场景: 硬件操作,PLC,操作系统

面向对象编程(Object-oriented programming oop): Java

主要关注的是对象
例如: 吃包子
找到卖包子的老板(对象),告诉他来个包子(功能),吃包子

面向对象就适合做大项目,项目中功能交给不同的对象去做
面向对象底层其实还是面向过程,即面向过程是基础,面向对象是包装升级后的产物
应用场景: 网站,小程序,app

今天学完,敲完代码之后,再来读一遍(这周都要不断去思考)

2.2 面向对象中的一些概念

类

类: (人以群分,物以类聚,商品归类)

其实具有相同特征和行为的一些列东西的统称
可以理解类为一个模版,是一个统称

例如:

好多东西具有相同特征(名字,重量)以及相同的行为(说话,工作,吃饭,睡觉) —> 人类
具有相同属性(价格,颜色,品牌)已经相同行为(打字,玩游戏,编程,看电影) —> 电脑类

属性

属性就是特征,即描述类特征的

即属性是类中的东西(类里边有属性)

例如

人类的属性: 身高,体重,年龄,性别,肤色
电脑属性: 价格,颜色,品牌,重量

功能

功能: 功能就是完成一些事情/动作的能力,

即就是一些方法
类中有方法

例如

人类的方法/行为/功能: 吃饭,睡觉,工作
电脑类方法/功能 : 开机关机,玩游戏,编程

对象

对象: 就是某个类的具体体现, 对象拥有具体的属性和行为

对象有具体的属性值,能将行为表现出来

例如:

王思聪属性(姓名:王思聪,身高175cm,体重70kg,性别男,肤色黄,财产不少)
王思聪行为(吃饭,睡觉,工作,玩)
在这里王思聪就是人类的对象,王思聪对象就能够将人类的属性和行为具体表现出来
你面前正在使用的这个电脑就是一个电脑类的对象

类,属性,方法,对象之间的关系?

类中包含属性和方法
对象是由类创建出来的(得先定义类,属性,方法,之后才能创建对象)
对象中也有属于自己的属性和方法

2.3 第一个类: 人类

面向对象中类的定义

// class 是类标识
public class 类名 {
    // 属性;
    // 即变量
    
    // 方法;
}

在类中定义属性和方法

package com.qf.oop;

/**
 * @desc 人类
 * 类名: 见名知意,首字母大写
 * class 类标识
 * 类中包含属性和方法
 */
public class People {
    /**
     * 属性: 就是变量
     * 定义属性其实就在定义变量
     * 只不过类中的属性有个特殊语法,
     * 就是可以在变量前加访问修饰符public,也可以不加
     */
    public int age;
    String name;

    /**
     * 方法: 就是之前的方法定义,
     * 只不过现在定义的方法不再写static
     * --------------------
     * 根据需求设计参数和返回值
     */
    public String eat(String food){
        System.out.println("吃饭,吃"+food );
        return "吃饱";
    }

    public void sleep() {
        System.out.println("睡觉" );
    }
}

ps: 一个java文件中建议只写一个类

重新新建java类,再写一个类: 动物类

属性: 名字,年龄,颜色
动作: 觅食,睡觉,移动

public class Animal {

    /**
     * 属性
     */
    public String name;
    public int age;
    public String color;

    /**
     * 方法
     */
    public void mishi(){
        System.out.println("觅食" );
    }

    public void xiumian() {
        System.out.println("休眠" );
    }

    public void move() {
        System.out.println("移动起来" );
    }
}

2.4 由类创建出对象

类定义完,就可以通过类创建出对象,从而使用对象

语法: 类名对象名 = new 类名();

类名就是自己定义的类名,People,Animal
对象名就是变量名,随便定义,见名知意
= 赋值
new 固定语法,意思新建
类名() 固定语法,跟前面类名一致

// 建议创建对象动作,单独创建一个测试类,再写代码
/**
 * @desc 演示创建对象
 */
public class Demo1 {

    public static void main(String[] args) {
        // 类名 对象名 = new 类名();
        // 创建人类对象
        People p1 = new People();
        People p2 = new People();
        
        // 创建动物类对象
        Animal animal = new Animal();     
    }
}

2.5 使用对象

创建出对象,对象中也有属性和方法,就可以使用对象的属性和方法

所谓使用对象,其实就是在使用对象的属性和方法

使用属性,其实使用变量
无非就是取值赋值

使用方法,方法是完成某个功能的
无非就是调用让其执行

2.5.1 取出对象的属性

数据类型变量 = 对象名.属性名;

    public static void main(String[] args) {
        People p1 = new People( );
        // p1就是创建出来的对象
        // p1里边就有属性和方法
        // 新创建的对象,属性即变量,会被系统自动赋默认值
        /**
         * 取出属性值
         * 数据类型 变量 = 对象名.属性;
         * ------------------------
         * 新创建的对象,属性即变量,会被系统自动赋默认值
         * 基本类型中: 整型默认值0,浮点型默认值0.0
         * 引用类型: 默认值都是null
         */
        String name = p1.name;
        int age = p1.age;
        System.out.println(name );// null(闹)意思是空
        System.out.println(age );// 0

        // ----- 练习 -----
        // 创建动物对象,取出属性,输出看属性值是什么
        Animal animal = new Animal();
        String color = animal.color;// null
        String aName = animal.name;// null
        int aAge = animal.age; //0
        System.out.println( color);
        System.out.println( aName);
        System.out.println( aAge);
    }

2.5.2 给对象属性赋值

属性赋值

对象名.属性 = 值;

    public static void main(String[] args) {
        People p1 = new People( );
        /**
         * 给属性赋值
         * 对象.属性 = 值;
         */
        p1.age = 18;
        p1.name = "王思聪";

        System.out.println("--- 重新取值 ---" );
        // 再次取出看看
        System.out.println(p1.age);// 18
        System.out.println(p1.name);// 王思聪
    }

2.5.3 使用对象的方法

以前我们学习方法有static,在main方法中使用方法名直接调用的

今天定义的方法没有static,不能直接通过方法名调用,而是需要对象来调用

数据类型变量名 = 对象名.方法(参数);

如果有参数,调用时传入参数
如果有返回值,调用时接收返回值

       People p1 = new People( ); 
       /**
         * 调用方法
         */
        p1.sleep();
        String r = p1.eat("米饭");
        System.out.println("吃饭的结果: " + r );

三、练习

总结面向开发:

先建类
类中定义属性和方法
通过类创建对象,对象调用属性和方法

定义学生类,属性( 学号,姓名,班级),行为 (学习,做作业)

创建一个学生对象,学号20230105,姓名叫麦克阿瑟,班级,战争学院1班,调用方法使其方法执行

public class Student {
    public String stuNo;// 学号
    public String name;
    public String banji;// 班级

    public void study(String subject){// subject 专业/科目
        System.out.println("学习" + subject );
    }

    public String doHomework(int hour){
        System.out.println("做"+hour+"小时的作业" );
        return "完成";
    }
}

public class Demo3 {

    public static void main(String[] args) {
        // 创建对象
        Student s1 = new Student();

        // 属性赋值
        s1.stuNo = "20230105";
        s1.name = "麦克阿瑟";
        s1.banji = "战争学院1班";

        // 属性取值
        System.out.println(s1.name );
        System.out.println(s1.stuNo );
        System.out.println(s1.banji );

        // 调用方法
        String s = s1.doHomework(4);
        System.out.println("做作业的结果: " + s );

        s1.study("战争指挥");
    }
}

现在编写一个类,定义完属性和方法,测试就会单独写个类,写主方法创建对象测试.

可不可以直接在People类,Student类下面直接写主方法测试? 可以!!!

四、面向对象内存分析

只定义类,属性和方法,不去创建对象不调用属性方法,即不执行它.那么定义类其实没有意义.

分析的内存其实代码运行的动态效果

现在面向对象开发,代码运行起来之后的动作,无非就是创建对象,属性取值,属性赋值,调用方法

即分析面向对象内存其实就分析上面这些动作过程

以Dog类为例,定义Dog类,设置属性和方法,创建对象

4.1 创建对象内存图

public class Dog {
    int age;// 寿命
    String name;// 狗的名字

    public void eat(){
        System.out.println("狗吃骨头" );
    }

    // main方法
    public static void main(String[] args) {
        // 创建对象
        Dog dog = new Dog();
        System.out.println(dog );

    }
}

java内存叫做java虚拟机(jvm),其中分为好多区域,暂时只考虑堆,栈

方法执行进栈
凡是 new 都会进堆
在堆中开辟空间,分配地址
将对象的属性赋初始值(默认值)

4.2 属性取值赋值内存图

public class Dog {
    int age;// 寿命
    String name;// 狗的名字

    public void eat(String food){
        System.out.println("狗吃"+food );
    }

    // main方法
    public static void main(String[] args) {
        // 创建对象
        Dog dog = new Dog();
        System.out.println(dog );

        // 取出查看
        System.out.println(dog.age );//0
        System.out.println(dog.name );// null
        // 赋值
        dog.name = "二哈";
        dog.age = 1;
        System.out.println(dog.age );// 1
        System.out.println(dog.name );// 二哈
    }
}

先取值查看,发现是默认值

给属性赋值

再次取值,查看属性值

4.3 调用方法内存图

方法执行进栈

方法调用时,有参数要传参数,相当于是给参数赋值

4.4 每个类可以创建多个对象

 // main方法
    public static void main(String[] args) {
        // 创建1个狗类对象
        Dog dog = new Dog();
        System.out.println(dog );
        // 赋值
        dog.name = "二哈";
        dog.age = 1;
        System.out.println(dog.age );// 1
        System.out.println(dog.name );// 二哈
        System.out.println("------------------" );
        // 再创建一个狗类对象
        Dog dog2 = new Dog();
        System.out.println(dog2 );
        dog2.name = "小金毛";
        dog2.age = 2;
        System.out.println(dog2.name );
        System.out.println(dog2.age );
        dog2.eat("小鸡");
    }

每个类可以创建出多个对象

每次new都会创建一个全新的对象,对象和对象之间互不影响

每个对象都有属于自己的属性和方法,与其他无关

4.5 多个引用(对象名)可以指向同一个对象

public class Car {

    double price;// 价格
    String type;// 款型

    public void driver() {
        System.out.println("驾驶" );
    }

    public static void main(String[] args) {
        // 创建一个对象,car叫做对象名
        // 输出car,是地址值,即其实内存会有一个对象,
        // 此时car其实通过地址指向内存的对象
        // 在这里这个car相当于引用了内存的对象
        Car car = new Car();
        car.type = "大众朗逸";
        car.price = 100000;

        // 将引用赋值另外一个引用
        // 即将对象名赋值给两位一个对象名
        // 多个引用指向同一个对象
        // car和car2指向同一个对象
        Car car2 = car;
        System.out.println("car -->" + car );
        System.out.println("car2 -->" + car2 );
        System.out.println(car2.type );
        System.out.println(car2.price );

        car2.type = "梅赛德斯奔驰";
        car2.price = 1000000;

        System.out.println(car.price );
        System.out.println(car.type );

    }
}

总结:

这就是引用类型的特点,这就是为什么将数组,类,接口定义引用类型

因为数组,类,接口都是new出来,平时用的数组名,对象名其实都是地址,是在引用堆中的对象

通过对象名调用属性和方法,其实都在通过地址找到堆中的对象在操作对象的属性和方法

五、总结

今天要掌握的的,就是
	如何定义类,属性和方法
	如何通过类创建对象
	如何调用对象的属性和方法
	类创建多个对象
	和多个引用指向同一个对象
	理解内存图

六、作业

重复今日代码2遍(定义类,属性,方法,创建对象调用属性方法)
图(读代码,看图,清楚每一个步骤,讲出来)

完成作业pdf5 T4，T5，T7，T9

七、单词

people 人
student 学生
teacher 老师
doctor 医生
worker 工人
dog 狗
pig 猪
cat 猫
car 车
phone 手机
price 价格
brand 品牌
type 类型
height 高
width 宽
weight 重量 
color 颜色

沐沐霸

关注

2
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
day06_面向对象_类_创建对象_对象内存图

java面向对象基础,介绍面向对象开发,如何定义类,属性方法,如何创建对象,使用对象,以及对象内存关系
复制链接

扫一扫

专栏目录