面向对象；类和对象；访问对象；创建对象在内存中的理解；匿名对象；封装和this （Java Day06)

一，面向对象

• 面向过程：他是一种编程思想，强调的是做事的步骤和方法，如何从第一步做到最后一步得到想要的结果。
• 面向对象：他也是一种编程思想，强调的谁来做事情，强调的是结果。
• 举个例子：洗衣服
• 面向过程：首先找来盆，倒入水和洗衣粉，放入衣服开始揉搓，使用清水洗干净然后拧干，晾出去。
• 面向对象：找到洗衣机，把衣服放进去，按按钮，最终衣服就洗完了；找到女朋友，把脏衣服给她，直接得到干净的衣服
• 面向对象的好处：

1. 更符合人类的思想习惯：做事情的时候先去找对象，找工具
2. 复杂的问题简单化
3. ​执行者变为了指挥者
4. 面向对象是面向过程更高层次的编程思想。
5. 面向过程是面向对象的基础；面向对象基于面向过程。
6. 面向对象特征：封装、继承、多态

二，类和对象

• 类：

1. 类就是具备某些共同特征的实体的集合；
2. 它是一种抽象的数据类型；【他是引用数据类型的一种】
3. 它是对所具有相同特征实体的抽象；
4. 说白了类就是java用来描述一类事物的使用方式。比如：使用语言对母亲描述你的女朋友的相关信息。所以类是抽象的

• 类的内容：

1. 属性 ：事物静态特征的描述 比如：人 的姓名 年龄 身高 体重等
2. ​行为：事物的动态行为的描述 比如： 人的吃饭、唱歌、跑步等
3. 构造方法：用来创建事物对一个的具体的对象的

• 类的定义: 使用class关键字来定义类

1. 格式：修饰符 class 类名 {类描述的事物内容}
2. 属性：使用变量来体现事物的特征
3. 行为：使用方法来体现事物的行为

• 访问修饰符：定义类中可以写public，也可以什么都不写。注意：多个类可以同时定义在一个Java文件中，文件名必须与public修饰的类名要一致，其他类不能使用public修饰。

1. class关键字：含义是 类，class修饰的代码块就是类类型。
2. 类名：标识符，符合命名规则和规范，第一个英文首字母大写，第二个英文首字母也要大写，如此类推。
3. {...}：类定义的内容。
4. 属性：全局变量/全局变量。语法，访问修饰符 数据类型 变量名；与变量（局部变量）定义一致，也可以在声明的时候同时赋值，只是定义的位置不同，该变量定义在类中，其他方法之外。
5. 方法：与以前的方法定义一致，只是不需要使用static。

代码示例

public class Person {    //类的格式创建
    //静态特征
    String name;//姓名
    int age;//年龄
    //行为 
    public void getGrilFriend() { //使用方法来描述人的行为,用类描述事物行为方法则不需加 static
        System.out.println("人是可以搞对象的");
    }
    //构造方法
    //有参构造方法 【快捷键   alt+shift+s o】
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //空参构造方法【快捷键   alt+shift+s c】
    public Person() {   
    } 
}

• 构造方法：

1. ​格式：修饰符 构造方法名称（参数列表）{方法体}
2. 作用：创建对象；给对象的属性进行赋值值【有参构造赋值赋的传进来的具体值；空参赋值赋的是属性数据，类型对应的默认值】
3. 注意事项：

              3.1、方法名和类名一模一样【类有自己独有的构造】

​              3.2、没有返回值类型

​              3.3、方法体没有return语句

​              3.4、是被jvm（虚拟机）调用的【看到new 就是虚拟机自动调用了构造方法】

       4.  构造方法和普通方法的区别：

​            4.1、方法名不一样：构造方法名和类名一致 ；普通方法方法名自己起的

            4.2、返回值类型不一样: 构造方法没有返回值类型；普通方法必须得写返回值类型

​            4.3、方法体不同：构造方法的方法体是对属性进行赋值操作；普通方法方法体根据需求进行书写。

        

 练习 1：

• 使用类描述一个动物: 年龄 、毛色、吃东西行为

 代码示例  

public class Animal {
  //属性
  int age; //年龄
  String color; //毛色

  public void eat(String food) {  //使用方法定义行为
    System.out.println("动物正在吃"+food);
}
//构造方法，空参构造
  public Animal(){

}
  //有参构造
  public Animal (int age, String color) {
   this.age = age;
   this.color = color;
}

三，对象

• 是java中事物的具体代表。比如：Person 是的具体对象 张三
• 对象是依据我们的类的描述创建出来，创建对象的时候使用的是类的内容构造方法来创建的。
• 创建对象格式： 数据类型【 类名】   对象名 = new    数据类型【类名】  （参数列表）

代码示例

public class Person_Test {
    public static void main(String[] args) {
        //创建一个Person类的具体对象
        Person person = new Person();//使用空参构造方法创建一个对象
        
        Person person2 = new Person("金莲", 502);//使用有参构造创建另一个对象，502是年龄
    }
}

  

四， 访问对象中的内容

• 属性访问：就是去获取对应属性的具体的值

•  格式：对象名.属性名 比如：person.name

• 行为的访问：方法的调用【类中的方法是属于对象的调用资源】

• 格式：对象名.方法名（参数列表）

代码示例

public class Person_Test {
    public static void main(String[] args) {
        //创建一个Person类的具体对象
        Person person = new Person();//使用空参构造方法创建一个对象
        Person person2 = new Person("金莲", 502);//使用有参构造创建另一个对象
        //获取对象 person person1 的属性姓名的值
        System.out.println(person.name);//null
        System.out.println(person2.name);//金莲
        //行为的访问
        person.getGrilFriend();//方法的调用
        person2.getGrilFriend();
    }
}

 

练习 1:

• 定义一个汽车类，有颜色（color）、轮胎个数（num），跑（run：显示当前汽车的颜色和轮胎个数）
• 在测试类中，创建汽车对象，修改成员变量的值，调用run方法，查看当前汽车对象的各种属性
• 静态特征：颜色，轮胎个数
• 动态特征：跑

代码示例：

//定义测试类
public class Car_Test {
    public static void main(String[] args) {
        //使用描述的汽车类 必须先要找到代表汽车的对象
        Car car = new Car();//得到了一个汽车对象
        System.out.println(car.color); //null
        System.out.println(car.num); //0
        //修改对象的属性值
        car.color = "red";
        car.num = 3;
        System.out.println(car.color); //red
        System.out.println(car.num); //3
        //调用行为run
        car.run();
        
    }
}

//定义Car类
public class Car {
    //静态的特征
    String color;//颜色
    int num;//轮子的个数
    //行为
    public void run() {
        System.out.println("车子的颜色是"+color+";轮子是"+num+"个");
    }
}

• 注意：

1. 在使用类描述事物的时候如果没有提供任何的构造方法，在创建该事物的对象的时候系统会偷偷的补一个空参构造。
2. 如果描述事物的时候提供了构造方法，系统就不会补充空参构造。

五，创建对象的内存理解

一个对象的创建图：

• 创建过程：

                ​ 1、加载相关类信息到内存的方法区

​                 2、调用main方法进栈并执行创建类对象相关代码

​                 3、在栈空间开辟main方法的的变量空间【存放对象的地址值】

​                 4、jvm调用构造方法到堆空间开辟新的空间来存放对象属性具体值以及方法标记值，

​                 5、把初始的对象空间的地址值赋值给栈空间的变量，

• 访问过程：通过栈空间的变量来访问，变量中存放的类对象的地址值。

​                 1、变量通过地址值找到对象在堆空间中的对象空间

​                 2、通过属性名称找到对象空间对应的属性位置从而找对应的属性值【属性的访问】

                ​ 3、通过方法名称找到对象空间中的方法标记，通过方法标记找方法区的对应类的空间

​                      通过方法名称找到对应的方法，并调用方法进栈开始执行。【属于行为访问】

​                 4，<!--注意：构造器：jvm调用构造方法从而在堆空间开始创建对象空间-->

• 两个引用指向同一个对象的内存图（省略）

1. 两个引用：栈空间中有两个变量，
2. 指向同一个对象：这两个变量空间存放的是同一个对象的地址值

六，成员变量和局部变量

• 成员变量【全局变量】：定义在属性位置的变量
• 局部变量：定义在方法中的变量

1. 方法中：方法的参数列表和方法的方法体都属于方法中
2. 比如：形式参数就是典型的局部变量

• 不同点：

1. 定义位置不同：[局部变量：在方法中]  [成员变量：属性位置]
2. 空间不同：[局部变量：属于方法，执行的时候存在于栈空间]  [成员变量：属于对象，执行的时候存在于堆空间]
3. 生命周期不同：[局部变量：属于方法，随着方法的调用而产生，随着方法的执行完毕就消失]  [成员变量：属于对象，随着对象创建而创建，随着对象的消失而消失]
4. 初始化状态不同：[局部变量：没有初始化值，要想使用必须要赋值才可以使用]   [成员变量：有初始化值，没有赋值也可以拿来使用。]

• 常用数据类型的默认初始值：

1. 引用数据类型：null
2. 基本数据类型：
3. 整数类型：0
4. 小数类型：0.0
5. 布尔类型：false
6. 字符类型：’u0000’

七，匿名对象的理解和使用

• 匿名对象：没有名字的对象。就是创建出来的对象没有把地址值赋值给栈空间的变量
• 创建格式：new 类名（参数列表）
• 特点：创建出来使用完毕，就会被垃圾回收器及时的回收。下一次使用就找不到了。

  代码示例

//定义测试类
public class Car_Test {
    public static void main(String[] args) {
        //使用描述的汽车类 必须先要找到代表汽车的对象
        Car car = new Car();//得到了一个汽车对象
        System.out.println(car.color); //null
        System.out.println(car.num); //0
        //修改对象的属性值
        car.color = "red";
        car.num = 3;
        System.out.println(car.color); //red
        System.out.println(car.num); //3
        //调用行为run
        car.run();
        
    }
}

//定义Car类
public class Car {
    //静态的特征
    String color;//颜色
    int num;//轮子的个数
    //行为
    public void run() {
        System.out.println("车子的颜色是"+color+";轮子是"+num+"个");
    }
}

//匿名对象的使用
new Car().run();
System.out.println(new Car().color);
//这两个匿名对象不是同一个对象，每new一次就要创建一个新的空间

八，面向对象的三大特征：封装，继承，多态

• 第一大特征: 封装

• 定义：隐藏事物的属性和实现细节，对外提供统一的访问方式
• 好处：

1. 代码的安全性起来了
2. ​ 能够使代码的复用性提升
3. 可以隐藏一些细节
4. 提高代码的易用性

• 原则：

1. ​ 隐藏属性和细节
2. 对外提供对应的唯一访问方式

• 封装步骤

1. 使用private 关键字修饰属性
   1.1    private 是关键字，含义是私有的，关键字可以修饰属性和方法，该访问修饰符修饰属性和方啊，只能在本类中使用，其他类不能使用
   1.2   语法： private 数据类型  属性名；

• 如何隐藏？访问权限：private 关键字

1. 概述：意思是私有的，是权限修饰的一种，范围是只能在本类使用
2. 修饰的内容：属性、方法、内部类等

        代码示

//定义Student类
 public class Student {   
    String id;
    String name;//没有封装
     
    //属性的封装
    private int age;//封装了
    
}

//定义测试类：
public class Student_Test {
    public static void main(String[] args) {
        Student student = new Student();//创建学生类
       // System.out.println(student.age);//访问不了，因为age 被private修饰
        
    }
}

• getter和setter方法
• 概述：就是属性封装后看对外提供的唯一访问方式
• getter方法：外界对属性进行取值的时候要访问的方式
• setter方法：外界对属性进行赋值的时候要访问的方式

 getter，setter方法的使用代码示例：

//定义Student类
public class Student {
    private String id;
    private String name;
    private int age;

    //对外提供唯一的访问方式【getter和setter方法】

    //快捷键   alt+shift+s r

    //自动生成
    public String getId() {
        return id;  // 返回该属性名对应的值给调用者，返回值类型为string类型
    }
    public void setId(String id) {
        this.id = id;  //设置参数无返回值所以就是void,
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

//定义测试类
public class Student_Test {
    public static void main(String[] args) {
        Student student = new Student();
        //System.out.println(student.age);age 被private修饰
        //System.out.println(student.id);这里访问不了
        System.out.println(student.getId());//null，因为ID是string类型的
        //student.id="4";
        student.setId("4");//赋值
        System.out.println(student.getId());//4 取值
    }
}

• 变量的访问原则和 this 关键字
• 变量的访问原则：就近原则
• this关键字

1. 定义：代表当前调用对象。
2. 用于区分局部变量和成员变量同名的情况。使用this.属性名称的一定是成员变量，没有使用this.的变量，根据就近原则来确定使用哪个变量。
3. this他不是一个固定的对象。他一定代表的是类的一个对象。