类与对象

面向对象思想

简例：

package ObjectOriented;

import java.util.Arrays;  //自动引进

public class POandOO {
    public static void main(String[] args) {

        //面向过程：每个细节亲历亲为
        System.out.print("[");
        int []a = {1,2,34,567,8910};
        for (int i = 0; i < a.length; i++) {
            if (i == a.length - 1){
                System.out.println(a[a.length - 1] + "]");
            }
            else {
                System.out.print(a[i] + ", ");
            }
        }

        System.out.println("===============");
        
        //面向对象：直接使用现成的功能，不关心具体步骤
        System.out.println(Arrays.toString(a));
    }
}

/*
结果：
[1, 2, 34, 567, 8910]
===============
[1, 2, 34, 567, 8910]
*/

面向对象的三大特征

封装性、继承性、多态性

封装性在Java中的体现

1. 方法就是一种封装
2. 关键词private也是一种封装

类与对象

• 类：一组相关属性和行为的集合
• **对象：**具体的实例化事物，例如猫。

关系：

• 类对事物的描述是抽象的，对象是是一类事物的实例 —> 类是对象的模板， 对象是类的实体。

类的定义

package Class;
/*
定义一个类来模拟学生
属性：
姓名、年龄
行为：
吃饭、睡觉、学习
成员变量：
String name;
int age;
成员方法：
public void eat()
public void sleep()
public void study()
*/
public class defination {
    //成员变量
    String name;
    int age;

    //成员方法  （不用写static关键字）
    public void eat(){
        System.out.println("Having dinner.");
    }
    public void sleep(){
        System.out.println("Go to sleep.");
    }
    public void study(){
        System.out.println("Work hard.");
    }
}

根据类创造对象

1.导包

也就是指出需要使用的类， 在什么位置。

import 包名称.类名称;

import Array.one

对于和当前类同属一个包的情况，可以省略导包语句不写。

2.创建

格式：

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

Student stu = new Student();

3.使用

使用成员变量：对象名.成员变量名;

使用成员方法：对象名.成员方法名(参数);

Code:

package Class;

public class Student {
    public static void main(String[] args) {
        //1.导包
        //使用的类“defination”和此文件位于同一个包内，
        // 所以省略导包语句不写

        //2.创建
        defination stu = new defination();
        //意思是根据defination类创建了一个名为stu的对象

        //3.使用成员变量
        stu.age = 19;
        stu.name = "John Wu";
        System.out.println(stu.name);
        System.out.println(stu.age);

        //4.使用成员方法
        stu.eat();
        stu.study();
        stu.sleep();
    }
}

调用对象的内存图解

注意， 成员方法并不会进入堆， 堆只会记录方法的地址