• day07_oop

    今日内存

    1.作业
    2.成员变量局部变量
    3.构造方法
    4.对象创建过程
    5.重载

    零、复习

    昨天

    • 介绍面向对象编程
    • 类,属性,方法,对象
    • 定义类,设置属性,设置方法,创建对象
    • 使用对象,调用属性,调用方法
    • 内存图(创建对象,创建多个对象,多个引用指向一个对象)

    类和属性,方法的关系

    • 类是模板,其中包含属性和方法

    类和对象的关系

    • 类是模板,是一个模糊统称
    • 对象是具体的实例(instance)
    • 由类创建出对象

    创建对象的语法

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

    一个类创建的多个对象之间的关系

    • 一个类可以创建多个对象(无数个)
    • 它们多个对象直接没有关系,互不影响

    什么叫引用?

    • 引用就是地址
    • 引用就是在使用堆中的对象
    • 使用的对象名其实就是在引用堆中的对象

    一、作业

    详见代码

    解决关于引用类型的题目或者读懂代码,前提知识

    • 方法执行进栈,方法执行完出栈/弹栈消失
    • 每次new都会在堆中创建对象
    • 使用的对象其实是在通过地址找到堆中的对象
    • 基本数据类型，赋值动作，是将数据本身复制一份传递给另一个变量
    • 引用数据类型，赋值动作，是将对象的地址值复制一份传递给一个变量

    T5

    class MyClass {
    int value;
}

public class TestRef {
    public static void main(String args[]) {
        int a = 10;
        int b = a;// b=10,基本数据类型是直接将数据赋值出去
        b++;// b=11
        System.out.println(a);// 10
        System.out.println("-----------" );


        MyClass mc1 = new MyClass( );
        mc1.value = 10;

        MyClass mc2 = mc1;// 引用类型,是将地址值赋值出去
        // 即mc1和mc2是指向同一个对象

        mc2.value++; // mc2通过地址操作对象的属性
        System.out.println(mc1.value);// 11
    }
}

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

    T7

    class ClassA {
    // 属性有初始值
    // 当创建对象时,value就等于10
    int value = 10;
}

public class TestReturnRef {
    public static void main(String args[]) {
        ClassA ca = new ClassA( );
        ca = getObject( );
        ca = getObject( );
        ca = getObject( );
        System.out.println(ca.value);
    }

    // 方法的返回值是写数据类型的
    // 数据类型分为基本和引用
    // 引用包含(类,数组,接口)
    // 返回值类型是可以写一个类
    public static ClassA getObject() {
        ClassA newObject = new ClassA( );
        newObject.value += 10;

        // 当方法返回值类型是类的时候
        // 要返回该类对象
        return newObject;
    }
}

    • 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

    T9

    class ClassAA{
    // 创建出对象后属性值value默认是0
    int value;
}

public class TestClassAA {
    public static void main(String args[]){
        int value = 10;
        /**
         * 1)调用方法传参数,等于给方法的参数赋值
         * 2)基本类型传参数,将数据直接赋值出去
         * 3)变量有作用域
         */
        changeInt(value);
        System.out.println(value);// 10
        System.out.println("------" );

        ClassAA ca = new ClassAA();
        ca.value = 10;
        /**
         * ClassAA是类,是引用类型
         * 引用类型赋值,其实是将地址值赋值
         */
        changeObject(ca);
        System.out.println(ca.value);// 11
    }
    public static void changeInt(int value){// value=10
        value++;// 11
    }

    public static void changeObject(ClassAA ca){
        // ca操作还是内存中那个对象
        ca.value++;
    }
}

    • 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

    二、成员变量&局部变量

    2.1 介绍

    成员变量局部变量
    解释类的属性，例如int age；局部是指方法，
    即该变量只能在方法这一局部范围内使用
    位置类中方法外方法内以及方法的参数
    初始值在创建对象时会赋初始值主动赋初始值
    内存位置不一样随着对象创建在堆中出现随着方法执行进栈
    public class Dog {

    /**
     * 类中有属性和方法,那么属性和方法就是类的成员
     * 即属性又叫成员属性/成员变量
     *   方法又叫成员方法
     *
     * age 就是成员变量
     */
    int age;

    public void eat(String food){
        /**
         * num就是局部变量
         */
        int num = 1;
    }

    // 看门
    public void seeDoor() {
        int num = 2;
    }

}

    • 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.2 使用成员变量

    在类中的方法里面可以直接使用成员变量

    public class Cat {
    // 成员变量
    String name;
    int age;

    // 方法内可以直接使用成员变量
    public void play() {
        System.out.println("小猫"+name+"在玩,今年"+age+"岁" );
    }
}
class TestCat {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "Tom";
        cat.age = 2;
        cat.play();
    }
}

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

    image-20231017111815778

    2.3 成员变量和局部变量重名

    • 首先成员变量和局部变量可以重名
    • 如果重名,那么方法内优先自己内部局部变量 --> 就近原则
    • 如果就只想要用对象的成员变量,需要使用this来单独调用属性
      • this代表当前对象

    使用局部变量(就近)

    image-20231017112339440

    使用this调用成员变量

    image-20231017112912839

    public class Cat {
    // 成员变量
    String name;
    int age;

    // 方法内可以直接使用成员变量
    public void play() {
        System.out.println("小猫"+name+"在玩,今年"+age+"岁" );
    }

    public void catchMouse() {
        String name = "加菲";
        // 默认就近原则,使用自己的name属性
        System.out.println(name+"猫抓老鼠 " );
        // 只用成员变量,使用this来调用
        // 因为this是代表当前对象
        // this.属性就是对象调用属性
        System.out.println(this.name+"猫抓老鼠 " );
        System.out.println("this--->"+this );
    }
}
class TestCat {
    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.name = "Tom";
        cat.age = 2;
        //cat.play();
        System.out.println("cat -->" + cat );
        cat.catchMouse();
    }
}

    • 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

    三、构造方法【重点】

    3.1 构造方法

    构造方法,又叫构造器或者构造函数

    是什么? 它就是方法,不过有点特殊

    • 方法名是当前类,类名
    • 没有返回值,连void都没有

    干什么? 用来构造 ,也就是创建对象的,以及会将属性初始化

    • 类名 对象名 = new 类名();
    • 类名 对象名 = new 构造方法();
    • 即通过调用构造方法来创建对象的

    怎么写的?

    public 类名(){
    
}

    • 1
    • 2
    • 3

    写在哪?

    • 在类中,与方法一样,与其他方法平级定义即可
    • 每个类都有,默认是隐藏的
     /*
 * @desc 演示构造方法的使用
 */
public class Pig {

    // 属性
    int age;
    String name;

    // 构造方法
    // 创建对象,并会将属性初始化
    public Pig(){
        System.out.println("Pig类构造方法执行" );
        age = 1;
        name = "GGBand";
    }

    // 方法
    public void eat(){
        System.out.println("猪拱白菜" );
    }
}
class TestPig{
    public static void main(String[] args) {
        // new 后面调用类的构造方法来创建对象的
        Pig pig = new Pig();
        System.out.println(pig.age );
        System.out.println(pig.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
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    3.2 有参构造

    刚才的构造方法是无参构造,创建出的对象属性值都是默认值

    可以使用有参数的构造方法,这样创建出的对象属性值是指定的值

    写法

    public 类名(数据类型 变量){
    this.属性 = 变量;
}

    • 1
    • 2
    • 3
     /* @desc 演示构造方法的使用
 */
public class Pig {
    // 属性
    int age;
    String name;

    // 构造方法
    // 创建对象,并会将属性初始化
    public Pig(){
        System.out.println("Pig类构造方法执行" );
        age = 1;
        name = "GGBand";
    }

    /**
     * 有参构造,通过指定变量,让创建出对象的
     * 属性是指定值
     */
    public Pig(int age,String name){
       this.age = age;
       this.name = name;
    }


    // 方法
    public void eat(){
        System.out.println("猪拱白菜" );
    }
}
class TestPig{
    public static void main(String[] args) {
        // new 后面调用类的构造方法来创建对象的
        Pig pig = new Pig();// 无参构造
        System.out.println(pig.age );
        System.out.println(pig.name );

        System.out.println("-------------" );
        // 调用有参构造创建对象
        Pig pig2 = new Pig(2,"猪大强");
        // 输出后直接就是指定数据
        System.out.println(pig2.age );
        System.out.println(pig2.name );

        Pig pig3 = new Pig(3,"猪博士");
        System.out.println(pig3.age );
        System.out.println(pig3.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
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    image-20231017145349200

    总结无参和有参构造的异同

    • 相同点: 都是可以创建对象,都可以将属性初始化
    • 不同点:
      • 无参构造方法创建出的对象属性值是默认值(0,null,0.0等)
      • 有参构造方法创建出的对象属性值是调用方法时指定的

    3.3 注意事项

    1. 每个类都隐藏提供一个无参构造方法
    2. 但是当你显式写出任何一个构造方法,上面隐藏的构造方法不再提供
    3. 所以建议 自己主动将有参无参构造同时给出

    四、对象创建过程

    1. 调用构造方法创建对象
    2. 先初始化类的属性
    3. 再执行构造方法
    class ClassA { // 类A
    public ClassA() {// 无参构造
        System.out.println("ClassA()");
    }
}
class ClassB {// 类B
    public ClassB() {// 无参构造
        System.out.println("ClassB()");
    }
}
class ClassC {// 类C
    // 成员变量(属性)
    // 属性a有值,且值是new出来的,初始值是地址值
    ClassA a = new ClassA( );
    // 属性b,没有值,初始值是null
    ClassB b;

    public ClassC() {// 无参构造
        System.out.println("ClassC()");
        b = new ClassB( );// 创建对象给属性b赋值
    }
}

public class TestConstructor {
    public static void main(String[] args) {
        /**
         * -------------------------
         *  构造方法目的是: 创建对象,属性初始化
         * 创建对象过程: 
         *  先属性初始化,再执行构造方法内部代码
         * -------------------------
         * 1 调用ClassC()构造方法,但是先初始化ClassC类中的属性
         * 2 为了给属性ClassA a赋值,会执行new ClassA(),调用ClassA()构造方法
         * 3 属性ClassB b初始化为null
         * 4 属性初始化完后,再执行构造方法里边代码
         */
        ClassC cc = new ClassC( );
    }
}

    • 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
    • 37
    • 38
    • 39
    // 结果如下
ClassA()
ClassC()
ClassB()

    • 1
    • 2
    • 3
    • 4

    五、方法的重载

    重载(Overload)

    public class TestOverload {

    public static void main(String[] args) {
        /**
         * 输出语句就是非常经典的重载
         * -----
         * 重载就是,同一个类中方法名一样,参数列表不一样
         *      参数的个数,数据类型,顺序不一样即可
         *      与返回值没有关系
         * -----
         * 好处就是: 方便使用
         * -----
         * 程序运行会根据参数,找到对应的方法执行
         */
        System.out.println( );
        System.out.println(1 );
        System.out.println(1.1 );
        System.out.println(true );
        System.out.println("哈哈" );
        System.out.println(new Dog() );

        test( 1);

    }

    public static void test(){
        System.out.println("test()" );
    }

    public static void test(int a){
        System.out.println("test(int a)" );
    }

    public static void test(String a){
        System.out.println("test(String a)" );
    }

    public static void test(String a,int b){
        System.out.println("test(String a,int b)" );
    }

    public static void test(int a, String b){
        System.out.println("test(int a,String b)" );
    }
}

    • 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
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45

    六、总结

    构造方法是重点,注意语法的特殊写法(无返回值,方法名是类名)
有参无参的区别
在有参构造中了解 成员变量和局部变量的应用

    • 1
    • 2
    • 3

    七、作业

    pdf5的 t6，t12，t13（研究，讲），t14（引用相关，复习t4579）

    • 1
  • 相关阅读:
    XJAR 混淆加密
    linux权限深度解析——探索原理
    唯一索引、普通索引
    Hadoop 集群一直处于安全模式，强制退出后出现数据丢失警告。解决方法
    开发工程师必备————【Day37】Django补充（九）
    【小程序源码】圣诞节头像框制作生成支持多模板
    LVS和keepalived
    HAL_UART_Receive不能正常超时返回
    React Swiper.js使用（详细版）3D聚焦特效，自定义导航按钮等
    Postman如何发送Https请求
  • 原文地址：https://blog.csdn.net/weixin_39641494/article/details/133888776