java基础——day05-1 类与对象、封装、构造方法

java基础——day05-1 类、对象、封装、构造方法

面向对象思想概念

概述：

　　面向对象是一种程序设计思想，这里的对象泛指现实中的一切事物，每种事物都有自己的属性和行为。其思想就是在计算机程序设计过程中，参照事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。其区别于面向过程的思想，强调的是通过调用对象的行为来实现功能，而不是亲力亲为。　　

　　* 面向过程：当需要实现一个功能时，每一个步骤都要亲力亲为，详细到每个步骤。
　　* 面向对象：当需要实现一个功能时，不关心具体步骤，而是找人做事。

举例：洗衣服

　　面向过程：脱衣服——放入桶里——放洗衣粉——放水——浸泡——搓洗——拧干——晾衣服

　　面向对象：脱衣服——打开洗衣机——放衣服——按钮——晾衣服

　　面向过程：强调步骤

　　面向结果：强调对象，这里的对象是洗衣机

特点：

面向对象更符合我们思考习惯，可将复杂的东西简单化，并将我们从执行者变为指挥者。面向对象包含三大特征，即封装、继承、多态。

package day05;

import java.lang.reflect.Array;
import java.util.Arrays;

public class day05_1 {
    /**
     * 面向过程：当需要实现一个功能时，每一个步骤都要亲力亲为，详细到每个步骤
     * 面向对象：当需要实现一个功能时，不关心具体步骤，而是找人做事
     */
    //举例 打印数组[1,2,3,4,5] 按数组的完整格式打印
    public static void main(String[] args) {
        //面向过程 首先建立数组
        int[] arr = {1,2,3,4,5};
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if(i == arr.length-1){
                System.out.print(arr[i]+"]");
            }else {
                System.out.print(arr[i]+",");
            }
        }
        System.out.println("====================");
        //通过面向对象的方式 直接调用Arrays的toString方法 即可快速实现
        System.out.println(Arrays.toString(arr));
    }
}

类和对象

什么是类

　　类：是一组相关属性和行为的集合。可以看成是一类事物的模板。使用事物的属性特征和行为来描述该类事物。

　　现实中，描述一类事物：

　　属性：事物的状态信息；

　　行为：事物能够做什么；

　　例如：猫。

　　属性：名字、年龄、性别、体重、颜色；

　　行为：叫、跑、吃；

什么是对象

　　对象：是一类事物的具体体现。对象是一个类的实例，具备该类事物的属性和行为。

　　例如：一只猫

　　属性：名字-小咪；体重-4kg；年龄：1year；颜色：yellow；

　　行为：漫步；蹦跶的猫；喵喵叫；

类与对象的关系　　

　　类——对一类事物的描述，是抽象的；

　　对象--对一类事物的实例化，是具体的；

　　类是对象的模板，对象是类的实体

类的定义

　　

类的定义格式

　　public class className{

　　　　//成员变量;

　　　　//成员方法;}

　　定义类：指定义类的成员，包括成员变量和成员方法；

　　成员变量：与之前定义的几乎一样，只不过位置发生改变，在类中，方法外。

　　成员方法：与之前定义的几乎一样，只是去掉了static.

package day05;

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

    //成员方法
    //学生具有学习的行为属性 即成员方法
    public void study(){
        System.out.println("人生苦短，我爱学习");
    }
    //学生具有吃饭的行为属性

    public void eat() {
        System.out.println("学累了，我要去撸串");
    }
}

　　注意：不要像写方法那样，写在同一个class文件中，否则会报错："cannot be referenced from a static....." 不能从静态引用

对象的使用(实例化)

创建（实例化）对象：

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

使用对象访问类中的成员：

　　对象名.成员变量;

　　对象名.成员方法();

package day05;

//类中
public class day05_2 {
    //方法外
    public static void main(String[] args) {
        //实例化一个类 可以理解为生成一个学生对象
        Student s1 = new Student();
        //定义学生的姓名、年纪、学号
        s1.name = "海清";  //不赋值 则输出null
        s1.age = 30;    //不赋值 则输出 0
        s1.s_id = 1705180129; //不赋值 则输出0
        //输出学生对象s1的成员变量信息
        System.out.println("姓名："+s1.name);
        System.out.println("年龄："+s1.age);
        System.out.println("学号："+s1.s_id);
        //调用对象s1的成员方法
        s1.study();
        s1.eat();
    }

}

成员变量的默认值

　　

 

　　//以上皆是成员可使用的变量

类与对象的练习

　　定义手机类　　

package day05;

public class Phone {
    //成员变量 品牌 价格 颜色
    String brand;
    int price;
    String color;

    //成员方法
    //打电话
    public void call(String name){
        System.out.println("给"+ name +"打电话");
    }
    //发短信
    public void sendMessage(String name){
        System.out.println("给"+name +"发送短信");
    }
}

　　实例化手机类

package day05;

public class day05_3 {
    //实例化手机类
    public static void main(String[] args) {
        //实例化一个手机 生成一个对象
        Phone phone = new Phone();
        //为phone 成员变量赋值 品牌 价格 颜色
        phone.brand ="Huawei";
        phone.price = 1388;
        phone.color = "白色";

        //调用phone的成员方法 打电话 发送短信 两个成员方法
        phone.call("刘飞");
        phone.sendMessage("刘学农");
    }
}

对象内存图

一个对象，调用一个方法的内存图

　　通过上图，我们可以理解，在栈内存中运行的方法，遵循“先进后出，后进先出”的原则。变量P指向堆内存的空间，寻找方法信息，去执行该方法。执行完方法后，该方法会被移出栈内存——出栈(以免造成栈内存的资源浪费)

　　所以当创建多个对象时，如果对象内部都保存一份方法信息，就会非常浪费内存，因为所有对象的方法信息都是一样的。

 两个对象，调用同一个方法的内存图

　　

 

　　对象调用方法时，根据对象中 方法标记(地址值)，去类中寻找方法信息。这样哪怕再多对象，方法信息只保存一份，节约内存空间。

package day05;

public class day05_4 {
    public static void main(String[] args) {
        //实例化手机对象 1
        Phone phone =new Phone();
        phone.brand = "Huawei";
        phone.price = 1399;
        phone.color = "白色";

        //实例化手机对象2
        Phone iphone = new Phone();
        iphone.brand = "iphone7 plus";
        iphone.price = 4250;
        iphone.color = "黑色";

        //输出地址值 Phone@6d6f6e28
        System.out.println(phone);
        //输出地址值Phone@135fbaa4
        System.out.println(iphone);
    }
}

一个引用，作为参数传递到方法中内存图

 　　

 

　　引用类型作为参数，和数组一样传递的是地址值。

 注意：　　

package day05;

public class day05_4 {
    public static void main(String[] args) {
        //实例化手机对象 1
        Phone phone =new Phone();
        //打印输出未赋值的对象
        System.out.println(phone.brand); //null
        System.out.println(phone.price); //0
        System.out.println(phone.color); //null
        phone.brand = "Huawei";
        phone.price = 1399;
        phone.color = "白色";
        System.out.println(phone.brand); //Huawei
        System.out.println(phone.price); //1399
        System.out.println(phone.color); //白色

        Phone iphone = phone;
        System.out.println(phone.brand); //null Huawei
        System.out.println(phone.price); //0 1399
        System.out.println(phone.color); //null 白色
        iphone.brand = "iphone7 plus";
        iphone.price = 4250;
        iphone.color = "黑色";
        System.out.println(iphone.brand); //null Huawei
        System.out.println(iphone.price); //0 1399
        System.out.println(iphone.color); //null 白色


        //输出地址值 Phone@6d6f6e28
        System.out.println(phone);
        //输出地址值Phone@135fbaa4
        System.out.println(iphone);
        /**未new的iphone 地址会指向同一个地址
         * 
         */
    }
}

　　注意：方法和数组是一样的，都是引用类型，所以传递的都是地址值，所以Phone iphone = phone时,相当于把phone的地址值赋值给iphone，所以当修改iphone的时候，phone的参数也在改变，因为他们指向同一个地址。