day07_面向对象_成员变量局部变量_构造方法_对象创建过程_方法重载

今日内存

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

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

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

二、成员变量&局部变量

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

}

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

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

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

使用局部变量(就近)

使用this调用成员变量

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

三、构造方法【重点】

3.1 构造方法

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

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

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

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

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

怎么写的?

public 类名(){
    
}

写在哪?

• 在类中,与方法一样,与其他方法平级定义即可
• 每个类都有,默认是隐藏的

 /*
 * @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 );
    }
}

3.2 有参构造

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

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

写法

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

 /* @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 );
    }
}

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

• 相同点: 都是可以创建对象,都可以将属性初始化
• 不同点:
  • 无参构造方法创建出的对象属性值是默认值(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( );
    }
}

// 结果如下
ClassA()
ClassC()
ClassB()

五、方法的重载

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

六、总结

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

七、作业

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