类、对象和构造方法（JAVA基础三）

一、引言

1.1 什么是程序

程序是为了模拟现实世界，解决现实问题而使用计算机语言编写的指令集合。

1.2 现实世界的组成

• 世界是由什么组成的？
  • 有人说：“世界是由无数原子组成的”。
  • 有人说：“世界是由无数事物组成的”。
  • 有人说：“世界是由无数物体组成的”。
  • 有人说：“世界是由一切有生命的和一切没有生命的组成的”。
  • 有人说：“你、我、他、大家组成的”。

所有回答都很抽象，没有特别明确的答案。

在程序员的眼里，世界的组成最为明确：“世界是由无数个对象组成的”。

二、什么是对象

2.1 什么是对象

• 面向对象思想（Object Oriented Programming）:
  • 一切客观存在的事物都是对象，万物皆对象。
  • 任何对象，一定具有自己的特征和行为。

2.2 现实中的对象

请分析以下对象都有哪些属性和方法？

2.3 程序中的对象

• 如何使用程序模拟现实世界，解决现实问题？
  • 首先，在程序当中，必须具有和现实中相同的对象，用以模拟现实世界。
  • 然后，使用程序中的对象代表现实中的对象，并执行操作，进而解决现实问题。

现实中的对象多数来自于“模板”，程序中的对象也应该具有“模板”。

三、什么是类【重点】

3.1 什么是类

3.2 类的抽取

在一组相同或类似的对象中，抽取出共性的特征和行为，保留所关注的部分。

3.3 类的定义

• 属性：通过变量表示，又称实例变量。
• 语法：数据类型 属性名;
• 位置：类的内部，方法的外部。

• 方法：通过方法表示，又称实例方法。
• 语法：
  public 返回值类型 方法名(形参){
  //方法的主体
  }
• 注意：不再书写static，后续详解。

3.4 类与对象的关系

• 类：定义了对象应具有的特征和行为，类是对象的模板。
• 对象：拥有多个特征和行为的实体，对象是类的实例。

四、类的组成【重点】

4.1 实例变量–属性

思考：之前学习局部变量时，要求必须先赋值再使用，否则编译错误。对于实例变量而言，未赋值并不会编译错误，能否直接访问？

4.2 实例变量与局部变量的区别

4.3 实例方法

​ 方法的定义

练习1：

package com.qfedu.object1;

//1.啥是个对象
    //万事万物皆对象
    // 对象： 具体的, 抽象
//2. 对象的表象形式: 类
    // 人： Person
    // 教室 ClassRoom
    // 英雄： Hero
    // Edg:  Egd

public class TestObjectHero {
    // 用来描述对象的
    //1.属性    全局变量
    String heroName;//英雄名
    int live; // 生命值
    int typeId; //定位的id   法师; 刺客........
    String skinName ; //皮肤的名字
    int attack; //攻击值
    int skill ; //技能值

    //2. 方法，方法指的是这个类有哪些功能
    //注意：没有static
    //跑
    public  void move() {
        System.out.println("移动了");
    }


}

练习1的测试：

package com.qfedu.object1;

import java.util.Scanner;

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

        // 1. 先有对象==》 类
        // 2. 类的实例   具体哪个实际的对象
        // 类名   对象名(实例 名) = new  类名();
        TestObjectHero  hero = new TestObjectHero();
        //3. 给属性赋值
        // 对象名.属性名
        hero.heroName="小乔";
        hero.typeId=7;
        hero.live=3000;
        hero.attack=10000;
        hero.skill=123;
        hero.skinName="天鹅梦";

        //4.输出这些属性的值
        System.out.println(hero.skinName);
        System.out.println(hero.heroName);
        System.out.println(hero.live);
        System.out.println(hero.attack);
        System.out.println(hero.skill);
        System.out.println(hero.typeId);

        //5. 调用里边的方法
        // 对象名(实例名).方法名();
        hero.move();

    }
}

练习2

package com.qfedu.object1;
//人的类
public class TestObjectPeroson {

    //描述这个类的;  属性
    String name ; //姓名
    String sex ; //性别
    int  age ; //年龄
    int weight;//体重
    boolean cool = true; // 是否帅

    // 功能： 方法
    public  void eat(String eatName) {
        System.out.println("吃"+eatName);
    }
    public  void sleep() {
        System.out.println("睡");
    }
    public  String  playGame() {
        System.out.println("打游戏");

        return "人生巅峰";
    }

    public static void main(String[] args) {

        //1.定义一个本类的对象名或者实例名
        TestObjectPeroson peroson  = new TestObjectPeroson();
        //2.给属性赋值
        peroson.name="小乔";
        peroson.sex="男";
        peroson.age=80;
        peroson.weight=180;

        // 访问 属性： 对象名(实例 名).属性名
        System.out.println(
                "你叫"+peroson.name+
                 "性别："+peroson.sex+
                 "年龄"+peroson.age+
                 "体重"+peroson.weight

        );

        //3.访问方法： 对象名（实例名）.方法名()
        peroson.eat("三秦套餐");
        peroson.sleep();
        String s = peroson.playGame();
        System.out.println(s);

        System.out.println(peroson.cool);
    }

}

练习3

1.1.创建一个学生类
1.2.属性有两份个: name  age
1.3.方法：  学生  没有参数，没有返回值

2.地址类  address
2.1 属性名 ： 省  市
2.2 方法： 输出你的老家的省市 ： 参数， 省和市 ， 返回String

4.4 案例

• 定义学生类：
  • 属性：姓名(name)、年龄(age)、性别(sex)、分数(score)
  • 方法：打招呼(sayHi) //打印学生所有信息
• 创建多个学生对象，为其各个属性赋值，并调用方法。

五、方法重载

5.1 方法重载概念

有些情况下，对象的同一种行为可能存在多种实现过程。

例如：人对象的“吃”行为，吃饭和吃药的过程就存在差异。

到底采用哪种实现过程，需要取决于调用者给定的参数

5.2 方法重载

重载（Overload）： 一个类中定义多个相同名称的方法。

要求：

• 方法名称相同。
• 参数列表不同(类型、个数、顺序)。
• 与访问修饰符、返回值类型无关。

调用带有重载的方法时，需要根据传入的实参去找到与之匹配的方法。

好处：灵活、方便、屏蔽使用差异。

package com.qfedu.test1;

import java.util.Scanner;

//写方法
    // 计算两个数的和
    // 计算三个数的和
    //计算三四数的和
public class NumCount {

    //方法的重载： 方法名要求相同  Overload
    // 参数的个数不同；参数的类型不同
    //计算两个数的和
    public  void sum(int a,int b) {
        int sum = a+b;
        System.out.println("a+b="+sum);
    }
    //
    public   void sum(int a,int b ,int c) {
        int sum = a+b+c;
        System.out.println("a+b+c="+sum);
    }

    public  void sum(int a,int b,int c,int d) {
        int sum = a+b+c+d;
        System.out.println("a+b+c+d="+sum);
    }

    // 计算两个int  和double的和
    public  void sum(int a,double b) {
        System.out.println(a+b);
    }
    public  void sum(double a ,int b) {
        System.out.println(a+b);
    }

    public static void main(String[] args) {

        NumCount a = new NumCount();
        a.sum(1,1);
        a.sum(1,2,3);
        a.sum(1,2,3,4);
        a.sum(1,1.0);

    }

}

六、构造方法【重点】

可以实现属性赋值

6.1 构造方法

构造方法： 类中的特殊方法，主要用于创建对象。

特点：

• 名称与类名完全相同。
• 没有返回值类型。
• 创建对象时，触发构造方法的调用，不可通过句点手动调用。

注意：如果没有在类中显示定义构造方法，则编译器默认提供无参构造方法

6.2 默认构造方法：

• 在类中，如果没有显示定义构造方法，则编译器默认提供无参构造方法。
• 如已手动添加有参构造方法，则无参构造方法不再默认提供，可根据需求自行添加。

6.4 构造方法重载

构造方法也可重载，遵循重载规则。

创建对象时，根据传入参数，匹配对应的构造方法。

package com.qfedu.test1;

public class TestCostruct {

    int id;
    String name;
    int age;

    //默认情况下，构造器的方法是空参的
    // 如果不写无参构造器：
    // 1. 如果没有有参的，默认可用无参的
    // 2. 如果有有参的，无参就失效了.
    public  TestCostruct() {}

    //构造器的重载
    public  TestCostruct(int id) {
        this.id = id;
    }
    public  TestCostruct(int id,String name){
        this(id);
        this.name = name;
    }
    public  TestCostruct(int id,String name,int age) {
        // this除了 调属性和方法（表示当前对象或者实例名）  还可以在构造器中调用其它构造器
        // 调用时，必须写在第一行的位置
        // 简化代码
        this(id,name);
        /*this.id =id;
        this.name = name;*/
        this.age = age;

    }

    public static void main(String[] args) {
        TestCostruct c1 = new TestCostruct();

        TestCostruct c2 = new TestCostruct(1001,"小乔",11);

        System.out.println(c2.age);
        System.out.println(c2.name);
        System.out.println(c2.id);

    }

}

6.2 分析：对象创建过程

对象的创建过程：

• 内存中开辟对象空间
• 为各个属性赋予初始值
• 执行构造方法中的代码
• [将对象的地址赋值给变量]

参考以上代码：进行理解：

6.3 分析：对象的内存分配

存储对象的变量s（引用）中保存对象的地址，通过变量中的地址访问对象的属性和方法。

画图理解：

七、this关键字

7.1 this关键字

• 类是模板，可服务于此类的所有对象；
• this是类中的默认引用，代表当前实例；
• 当类服务于某个对象时，this则指向这个对象

7.2 this关键字的两种用法

//this的功能：
System.out.println(testEquip1.getEquipName());//铁剑
System.out.println(testEquip2.getEquipName()); //搏击拳套
System.out.println(testEquip3.getEquipName()); //末世

// 写一个方法，方法的功能： 获取equipName 的值，并返回
public  String getEquipName() {
    return  this.equipName;
}

7.2.1 第一种用法

this第一种用法：调用实例属性、实例方法。如：this.equipName

• 当实例变量和局部变量重名时，优先访问局部变量。
• 此时，如需访问实例变量，需要增加this.前缀。
• 不存在重名时，则可省略this。

7.2.2 第二种用法

this第二种用法：调用本类中的其他构造方法。如：this()、this(实参)。

• this()：调用无参构造
• this(实参)：调用有参构造
• 注：必须在构造方法的首行

package com.qfedu.test1;

public class TestCostruct {

    int id;
    String name;
    int age;

    //默认情况下，构造器的方法是空参的
    // 如果不写无参构造器：
    // 1. 如果没有有参的，默认可用无参的
    // 2. 如果有有参的，无参就失效了.
    public  TestCostruct() {}

    //构造器的重载
    public  TestCostruct(int id) {
        this.id = id;
    }
    public  TestCostruct(int id,String name){
        this(id);
        this.name = name;
    }
    public  TestCostruct(int id,String name,int age) {
        // this除了 调属性和方法（表示当前对象或者实例名）  还可以在构造器中调用其它构造器
        // 调用时，必须写在第一行的位置
        // 简化代码
        this(id,name);
        /*this.id =id;
        this.name = name;*/
        this.age = age;

    }

    public static void main(String[] args) {
        TestCostruct c1 = new TestCostruct();

        TestCostruct c2 = new TestCostruct(1001,"小乔",11);

        System.out.println(c2.age);
        System.out.println(c2.name);
        System.out.println(c2.id);
        
    }

}