day06-面向对象基础（一）

day06_笔记

一、面向对象

（一）面向对象思想

1、面向对象：就是一种编程思维

2、面向对象和面向过程：

（1）面向对象：面向对象强调做事情的主体，更强调的是谁来解决问题，强调的是数据，强调的是谁拥有数据和操作数据的权利

（2）面向过程：强调做事情的基本步骤，强调的是解决问题的基本方式

3、面向对象的好处

（1）更符合现代人的生活习惯：方便，凡事喜欢找对象，找人，而不是找方法

（2）复杂问题简单化

（3）由执行者变成了指挥者

4、面向对象的特点：

（1）封装

（2）继承

（3）多态

二、类和对象

（一）类和对象的比较

| ------------------------------------------------------------ |

1、类：类型，对具体事物的一些抽象认识。概括的是一类事物的属性和行为。类：是一个抽象的概念，并非实际存在

2、对象：一个真实存在的事物，是属性和行为的具体体现。是属性的载体，行为的执行者

（二）类的说明

1、类：就是一组属性和行为的集合

2、格式：

public class 类名 {
    
}

3、属性：对事物特征的描述，一般是变量

Java中，属性其实就是一个成语变量，只不过定义的位置发生了变化，以前书写在方法中，现在书写在类中方法外

4、行为：对事物特征的描述，是方法

Java中，功能实际上就是方法，和以前定义的位置一样，只不过取消静态【static】

5、举例：

人类

属性（成员变量）：姓名、年龄、性别

行为（成员方法）：吃饭、睡觉、学习

6、说明：

（1）每一个类编译之后都会生成一个【.class】文件

（2）在一个【Java】文件中，只能有一个【public class】，可以有多个【class】

（3）public class是当前Java文件的入口

package com.hqyj.demos;

public class Demo01_Class {

}

/**
 * 人类
 * 属性（成员变量）：姓名、年龄、性别
 * 行为（成员方法）：吃饭、睡觉、学习
 */
class Person {
    //属性（成员变量）：姓名、年龄、性别
    String name;
    int age;
    String sex;

    //行为（成员方法）：吃饭、睡觉、学习
    public void eat() {
        System.out.println("吃擀面皮");
    }

    public void sleep() {
        System.out.println("睡席梦思");
    }

    public void study() {
        System.out.println("学R闪");
    }
}

（三）对象的创建和使用

1、对象：是一个实实在在存在的个体，是属性的载体，是行为的执行者

2、格式：

类名 对象名 = new 类名();
Scanner sc = new Scanner(System.in);

3、说明：

（1）类名：创建的是哪个类的对象，就写哪个类的类名

（2）对象名：就是一个变量名，遵循见名知意，小驼峰原则

（3）=：对象是引用数据类型，所以赋值符号是将右侧对象的地址值赋值给左侧对象名

（4）new：只要一看到new就在堆内存中开辟空间，创建对象

（5）注意：目前为止，前后类名保持一致【多态的时候产生变化】

（6）()：在封装的时候，构造方法会在其中添加内容

4、对象访问属性的格式

（1）访问：对象名.属性名

（2）修改：对象名.属性名 = 属性值;

5、访问方法：对象名.方法名(实际参数);

package com.hqyj.demos;

/**
 * 代码格式调整：ctrl + alt + L
 */
public class Demo01_Class {
    public static void main(String[] args) {
        //类名 对象名 = new 类名();
        Person p  = new Person();
        //修改属性
        p.name = "张三丰";
        p.age = 30;
        p.sex = "女";
        //访问属性
        System.out.println(p.name + "..." + p.age + "..." + p.sex);
        //调用方法
        p.eat();
        p.sleep();
        p.study();
    }
}

/**
 * 人类
 * 属性（成员变量）：姓名、年龄、性别
 * 行为（成员方法）：吃饭、睡觉、学习
 */
class Person {
    //属性（成员变量）：姓名、年龄、性别
    String name;
    int age;
    String sex;

    //行为（成员方法）：吃饭、睡觉、学习
    public void eat() {
        System.out.println("吃擀面皮");
    }

    public void sleep() {
        System.out.println("睡席梦思");
    }

    public void study() {
        System.out.println("学R闪");
    }
}

（四）练习

定义一个汽车类，有颜色（color）、有轮胎数（num），跑（run：输出打印汽车牌跑）

在主方法中创建对象，修改成员变量，调用方法

package com.hqyj.demos;

public class Demo02_Exercise {
    /**
     * 定义一个汽车类，有颜色（color）、有轮胎数（num），跑（run：输出打印汽车牌跑）
     * 在主方法中创建对象，修改成员变量，调用方法
     */
    public static void main(String[] args) {
        //类名 对象名 = new 类名();
        Car c = new Car();

        c.color = "黑色";
        c.num = 4;

        System.out.println(c.color + "..." + c.num);
        c.run();
    }
}

/**
 * 汽车类
 */
class Car {
    //属性
    String color;
    int num;

    //行为
    public void run() {
        System.out.println("汽车跑");
    }
}

三、创建对象的内存理解

（一）创建对象的内存理解

1、创建对象的步骤

（1）将要创建的对象所属的类型的字节码文件加载进方法区

（2）在栈内存中创建对象的引用，将来用于存储对象的地址值

（3）在堆内存中开辟一块空间，为成员变量赋予默认值

（4）将对象的地址值赋值给对象名所指代的空间中

2、说明

（1）第一次使用某个类型的时候，会将这个类型的字节码文件加载进方法区，第二次使用的时候不用重复加载，一般情况下，一个类只加载一次

（2）在创建对象的过程中，对象内部会默认隐含一份所属类型的字节码文件的地址值，将来可以通过这个地址值找到所属的类型

（3）每一个对象都具有一份类的成员变量

（4）每次使用new关键字，都会在堆内存中开辟一块全新的空间，这意味着不同的对象具有不同的地址值

package com.hqyj.demos;

public class Demo02_Exercise {
    /**
     * 定义一个汽车类，有颜色（color）、有轮胎数（num），跑（run：输出打印汽车牌跑）
     * 在主方法中创建对象，修改成员变量，调用方法
     */
    public static void main(String[] args) {
        //类名 对象名 = new 类名();
        Car c = new Car();

        c.color = "黑色";
        c.num = 4;

        System.out.println(c.color + "..." + c.num);
        c.run();
    }
}

/**
 * 汽车类
 */
class Car {
    //属性
    String color;
    int num;

    //行为
    public void run() {
        System.out.println("汽车跑");
    }
}

（二）两个引用指向同一个对象的内存

package com.hqyj.demos;

public class Demo02_Exercise {
    public static void main(String[] args) {
        //类名 对象名 = new 类名();
        Car c = new Car();

        c.color = "黑色";
        c.num = 4;

        Car c2 = c;

        c2.color = "红色";
        c2.num = 6;

        System.out.println(c.color + "..." + c.num);//黑色   4   红色   6
        System.out.println(c2.color + "..." + c2.num);//红色   6   红色   6

        c.run();
    }
}

/**
 * 汽车类
 */
class Car {
    //属性
    String color;
    int num;

    //行为
    public void run() {
        System.out.println("汽车跑");
    }
}

四、其他内容

（一）成员变量和局部变量区别

1、成员变量：是一个变量，定义在类中方法外，属于类的成员

2、局部变量：是一个变量，定义在方法中，属于方法的成员；对于类而言，方法只是其中一部分，所以该变量属于局部变量

3、不同点：

（1）代码层面：定义位置不同

• 成员变量：定义在类中方法外
• 局部变量：定义在方法中

（2）内存层面：内存空间不同

• 成员变量：随着对象创建在堆内存中
• 局部变量：随着方法创建在栈内存中的方法中

（3）内存层面：内存时间不同，生命周期不同

• 成员变量：属于对象，随着对象的创建而创建，随着对象的消亡而消亡
• 局部变量：属于方法，随着方法的进栈而创建，随着方法的出栈而消亡

（4）初始化状态不同：

• 成员变量：具有默认值
• 局部变量：没有默认值，必须先赋值后调用

package com.hqyj.demos;

public class Demo03_Variable {
    public static void main(String[] args) {
        Demo_Test dt = new Demo_Test();

        System.out.println(dt.b);
        System.out.println(dt.s);
        System.out.println(dt.i);
        System.out.println(dt.l);
        System.out.println(dt.f);
        System.out.println(dt.d);
        System.out.println("" + dt.c1 + dt.c2);
        System.out.println(dt.boo);
    }
}

class Demo_Test {
    byte b;
    short s;
    int i;
    long l;

    float f;
    double d;

    char c1 = '\u4e2d';
    char c2 = '\u56fd';
    boolean boo;
}