• day06_面向对象基础

    今日内容

    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 类名 {
    // 属性;
    // 即变量
    
    // 方法;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在类中定义属性和方法

    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("睡觉" );
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    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("移动起来" );
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    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();     
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    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);
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    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);// 王思聪
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    2.5.3 使用对象的方法

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

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

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

    • 如果有参数,调用时传入参数
    • 如果有返回值,调用时接收返回值
           People p1 = new People( ); 
       /**
         * 调用方法
         */
        p1.sleep();
        String r = p1.eat("米饭");
        System.out.println("吃饭的结果: " + r );

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    三、练习

    总结面向开发:

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

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

    创建一个学生对象,学号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 "完成";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    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("战争指挥");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23

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

    可不可以直接在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 );

    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

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

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

    image-20231016160659446

    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 );// 二哈
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

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

    image-20231016161011587

    给属性赋值

    image-20231016161141137

    再次取值,查看属性值

    image-20231016161312301

    4.3 调用方法内存图

    方法执行进栈

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

    image-20231016161829119

    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("小鸡");
    }

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

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

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

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

    image-20231016163311000

    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 );

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    image-20231016165647342

    总结:

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

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

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

    五、总结

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    六、作业

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

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

    • 1
    • 2
    • 3
    • 4

    七、单词

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
  • 相关阅读:
    【GridMask】《GridMask Data Augmentation》
    Python学习
    【车辆动力】基于Matlab模拟停车动力学
    声明式事务
    欧洲历史脉络
    Promise详解：手写Promise底层-实现Promise所有的功能和方法
    ros2 代码风格检查
    【670. 最大交换】
    day-01 Docker
    Cholesterol-PEG-DBCO,CLS-PEG-DBCO,胆固醇-聚乙二醇-二苯基环辛炔一种环炔烃
  • 原文地址：https://blog.csdn.net/weixin_39641494/article/details/133863819