[Java] 类和对象（简介，封装，内存机制，构造方法）

1 面向对象思想

1.1面向对象的思想概述

面向过程：当需要实现一个功能的时候，每一个具体的步骤都需要亲历亲为，详细处理每一个细节

面向对象：当需要实现一个功能的时候，我不关心具体的步骤，而是找一个已经具有该功能的人，引用他人的方法和类 直接使用

举例

打lol上分：

• 面向过程：青铜V ----> 努力上分 —> 黑铁 ---->努力上分 —>黄金
• 面向对象：青铜V ----> 找代练 -----> 钻石！

面向过程：强调上分的艰辛

面向对象：强调代练的nb，代练就是你的对象哈哈哈哈哈哈哈哈哈哈

特点

面向对象是一种更符合我们思考习惯的思想，它可以将复杂的思想简单化，并将我们从执行者变成了指挥者。

三大特性：封装、继承、多态

1.2 类和对象

由于Java和C++的类和对象的特性十分相似，因此这里我也快速过了，到了API类就可以开始详细学习，这里的话简单过一遍

类

• **类：**是一组相关属性与行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物
• 属性：该事物的状态信息
• 行为：该事物能够做什么

对象

• 对象：一类事物的具体体现。对象是类的一个实例

类和对象的关系

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

1.3 类的定义

成员变量：对应事物的属性

成员方法：对应事物的行为

格式：

public class ClassName{
	//成员变量
	//成员方法
}

package method.demo2;

public class Demo2 {

    public static class Student{
        public static String qwq = "我是你爹";
        public static void aaa(){
            System.out.println(qwq);
        }
    }

}

注意:要是成员变量没有赋值的话,会有一个默认值,默认值规则和数组是一样的

1.4 对象的创建以及使用

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

  例: import 包名称 .类名称;

• 创建格式: 类名称 名字 = new 类名称();

• 使用:不多解释

代码如下:

package method.demo1;

import method.demo2.Demo2;

public class Demo1 {

    public static void main(String[] args) {
        Demo2.Student stu = new Demo2.Student();
        System.out.println(stu.qwq);
        stu.aaa();
    }
}

手机类练习:

• 类的创建

• package method.demo2;
  
  public class Demo2 {
  
      //定义一个类，用来模拟手机事物
      //属性：品牌、价格、颜色
      //行为：打电话、发短信
  
      public static class Phone{
          String brand;
          double price;
          String color;
  
  
          public void call(String who){
              System.out.println("打电话给：" + who);
          }
  
          public void sendMessage(){
              System.out.println("群发短信");
  
          }
      }
  
  }
  
  

• 类的使用

• package method.demo2;
  
  public class qwq {
      public static void main(String[] args) {
          //创建Phone 类
          Demo2.Phone one = new Demo2.Phone();//对象的实例化
  
          one.brand = "苹果";
          one.price = 9999.9f;
          one.color = "黑色";
  
          one.call("乔布斯");
          one.sendMessage();
  
      }
  }
  
  

注意,我的类是定义在同一个包中的

1.5 对象的内存

一个对象的内存图:(刚才的手机对象) 对象里面的方法保存的是地址值!!,指向方法区

两个对象名引用同一个对象的内存

这个算是浅拷贝

1.6 类作为参数

例子:

package method.demo2;

public class Demo02PhoneParam {
    public static void method(Demo2.Phone param){
        param.brand = "华为";
        System.out.println(param.brand);
        System.out.println(param.price);
        System.out.println(param.color);
    }
    public static void main(String[] args) {
        Demo2.Phone one = new Demo2.Phone();
        one .brand = "苹果";
        one . price = 8388.0;
        one. color = "土豪金";
        System.out.println(one.brand);
        method(one);
        System.out.println(one.brand);
    }
}
结果:
苹果
华为
8388.0
土豪金
华为

注意

• 作为参数传进去之后,里面的形参的地址也是指向那个堆区中创建的对象的,也可以理解为**,传进去的是地址值,**也就是说,方法中可以对对堆区里面的对象的数据进行修改,这一点和c++的指针啥的是不一样的

1.7 类作为参数

返回值其实是地址值

1.8 成员变量的局部变量的区别

• 定义的位置不一样{局部变量在方法的内部或者作为参数,成员变量在方法的外部}
• 作用范围不一样{局部变量只有方法中可以使用,除了方法就释放了,成员变量整个类都可以使用}
• 默认值不一样:{局部变量一定要初始化,但是成员变量一定有默认值}

//前三点是重点

• 内存的位置不一样:局部变量在栈内存中,成员变量在堆区

• 声明周期不一样:局部变量就是进栈出栈而诞生消失,但是成员变量的话,随着对象的诞生和消失而诞生的消失

1.9 封装性

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

将过程**封装在一段代码里面, ** 调用就完事了,将里面的一些细节信息隐藏起来,对于外界不可见

private:

• 类内可以访问,类外不可以

private的属性可以通过方法来访问,方法的名字的第一个单词一定要是get或者set

private的练习

package method.demo2;

public class Demo02PhoneParam {

    //学生类
    public static class Student {
        private String name;
        private int age;
        private boolean male;//是不是男性

        public void setName(String str) {
            this.name = str;
        }

        public String getName() {
            return name;
        }

        public void setAge(int num) {
            this.age = num;
        }

        public int getAge() {
            return age;
        }

        public void setMale(boolean male) {
            this.male = male;
        }

        public boolean isMale() {
            return male;
        }
    }

    public static void main(String[] args) {

        Student stu = new Student();

        stu.setName("鹿晗");
        stu.setAge(20);
        stu.setMale(true);

        System.out.println(stu.getName());
        System.out.println(stu.getAge());
        System.out.println(stu.isMale());


    }


}

1.9.1 this的作用

• 当方法的局部变量和成员变量 重名的时候,成员变量一定要加上this.以区分

• this的归属: 通过谁调用的方法,谁就是this

1.9.2 构造方法

• 构造方法使用来创建对象的放大,当我们通过关键字new来创建对象的时候,其实就是在调用构造方法
• 语法: public 类名称(参数类型,参数名称){}
• 构造方法不能return
• 编译器会自动给我们的类创建一个构造方法
• 有 有参构造,无参构造

就是c++里面的构造函数

1.10 标准的类(Java Bean)

满足:

1. 所有的成员变量都要使用private关键字修饰
2. 为每一个成员变量编写一对 Getter/Setter方法
3. 编写一个无参数的构造方法
4. 编写一个全参数的构造方法

在IDEA 中有快捷键,按Alt + Insert可以直接创建Getter和Setter方法或者有创建构造方法等