6.类和对象

类和对象

对象

对象: 一切事物都是对象

对象的属性: 对象具有的各种特征, 每个对象的每个属性都拥有特定的值.

对象的行为: 对象能够执行的操作

类

类: 现实生活中一类具有共同属性和行为的事物的抽象.

类的特点:

• 类是对象的数据类型
• 类是具有相同属性和行为的一组对象的集合

类与对象的关系

类: 现实生活中一类具有共同属性和行为的事物的抽象.

对象: 能够看得见摸得着的真实存在的实体.

类是对象的抽象, 对象是类的实体

类的定义

类: 是java 程序的基本组成单位

类的组成: 属性和行为

• 属性: 在类中通过成员变量来体现(类中方法外的变量)
• 行为: 在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)

类的定义步骤

• 定义类
• 编写类的成员变量
• 编写类的成员方法

public class 类名 {
	// 成员变量
	变量1数据类型 变量1;
	变量2数据类型 变量2;
	...
	
	// 成员方法
	方法1;
	方法2;
	...
}

示例

package ClassInstance;

public class Phone {
    // 成员变量
    String brand;
    Float price;
    
    // 成员方法
    public void call() {
        System.out.println("打电话");
    }
    
    public void sendMessage() {
        System.out.println("发短信");
    }
}

对象的使用

创建对象

• 格式: 类名 对象名 = new 类名();

• 范例: Phone p = new Phone();

使用对象

• 使用成员变量
  • 格式: 对象名.变量名
  • 范例:p.brand
• 使用成员方法
  • 格式: 对象名.方法名()
  • 范例: p.call()

package ClassInstance;

import org.w3c.dom.ls.LSOutput;

public class PhoneDemo {
    public static void main(String[] args) {
        // 创建对象
        Phone p = new Phone();

        // 使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);
        // 成员变量赋值
        p.brand = "apple";
        p.price = 5499.00;

        System.out.println(p.brand);
        System.out.println(p.price);

        // 使用成员方法
        p.call();
    }
}

对象内存图

单个对象

成员变量

成员方法

多个对象

多个对象指向相同

成员变量和局部变量

成员变量: 类方法外的变量

局部变量: 方法中的变量

区别	成员变量	局部变量
类中位置不同	类种方法外	方法内或方法声明上
内存中位置不同	堆内存	栈内存
生命周期不同	随着对象的存在而存在,随对象的消失而消失	随方法的调用而存在,随方法的调用完毕而消失
初始化值不同	有默认的初始化值	没有默认初始值,必须先定义,赋值,才能使用

封装

private关键字

• 一个权限修饰符
• 可以修饰成员(成员变量和成员方法)
• 作用是保护成员不被别的类使用,被private修饰的成员只能在本类中使用

针对private修饰的变量,如果需要被其他类使用,提供相应的操作

• 提供"get变量名()"方法, 用于获取成员变量的值,方法用public修饰
• 提供"set变量名(参数)"方法, 用于设置成员变量的值,方法用public修饰

package ClassInstance;

public class StudentPrivate {
    // 成员变量
    String name;
    private int age;

    // 提供get/set方法
    public void setAge(int a) {
        if (a<0 || a>120) {
            System.out.println("年龄输入有误!");
        }
        age = a;
    }

    public int getAge() {
        return age;
    }

    // 成员方法
    public void call() {
        System.out.println("人生谁无风雨时");
    }

    public void sendMessage() {
        System.out.println("守的云开见月明");
    }
}

使用private成员

package ClassInstance;

public class privateKeyword {
    public static void main(String[] args) {
        // 创建对象
        StudentPrivate s = new StudentPrivate();
        System.out.println(s.name);
        // System.out.println(s.age);  // 私有变量无法直接访问
        System.out.println(s.getAge());
        s.setAge(30);
        System.out.println(s.getAge());
    }
}

this关键字

this修饰的变量用于指代成员变量

• 方法的形参如果与成员变量同名, 不带this修饰的变量值的形参, 而不是成员变量
• 方法的形参没有与成员变量重名, 不带this修饰的变量指的是成员变量

什么时候this: 解决局部变量隐藏成员变量

this: 代表所在类的对象引用

• 方法被那个对象调用, this就代表那个对象.

package ClassInstance;

public class StudentThis {
    // 成员变量
    private String name;
    private int age;

    // 提供get/set方法

    public void setName(String name) {
        // name = name;  // 方法中会优先使用局部变量,
        this.name = name;  // 使用this才能指向成员变量
    }

    public String getName() {
        return name;
    }

    // 成员方法
    public void call() {
        System.out.println("人生谁无风雨时");
    }

    public void sendMessage() {
        System.out.println("守的云开见月明");
    }

    public void show(){
        System.out.println(name + ", " + age);
    }
}

This内存原理

s1对象调用内存原理

s2对象调用内存原理

最后

封装

1. 封装概述

面向对象的三大特征之一(封装, 继承, 多态)

面向对象编程语言对客观世界的模拟, 客观世界成员变量都是隐藏在对象内部的, 外部是无法直接操作的

2. 封装原则

将类的某些信息隐藏在类的内部,不允许外部程序直接访问, 而是通过类提供的方法来实现对隐藏信息的操作和访问.

3. 封装的好处

通过方法来控制成员变量的操作,提高了代码的安全性

把代码用方法进行封装, 提高代码的复用性

构造方法

概述

构造方法是一种特殊的方法,

• 作用: 用于创建对象

• 功能: 完成对象数据的初始化

格式

public class 类名 {
	修饰符 类名(参数) {
		// 构造方法内容
	}
}

示例:

package ClassInstance;

public class StudentCreateMethod {
    private String name;
    private int age;
    // 无参数构造方法
    public StudentCreateMethod () {
        System.out.println("无参数构造方法");

    }

    // 有参数构造方法
    public StudentCreateMethod (String name) {
        System.out.println("有参数构造方法");
        this.name = name;
    }

    // 有参数构造方法2
    public StudentCreateMethod (int age) {
        System.out.println("有参数构造方法2");
        this.age = age;
    }

    // 完整构造方法
    public  StudentCreateMethod(String name, int age) {
        System.out.println("有参数构造方法3");
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

测试类

package ClassInstance;

public class StudentCreateMethodTest {
    public static void main(String[] args) {
        // 创建对象
        StudentCreateMethod s = new StudentCreateMethod();
        s.show();

        //
        StudentCreateMethod s2 = new StudentCreateMethod("林青霞");
        s2.show();

        //
        StudentCreateMethod s3 = new StudentCreateMethod(30);
        s3.show();

        StudentCreateMethod s4 = new StudentCreateMethod("林青霞",30);
        s4.show();


    }
}

注意事项

构造方法的创建;

• 如果没有定义构造方法, 系统给出一个默认的无参数构造方法; 如果定义了,系统将不再提供默认构造方法.
• 构造方法需要和类名一致

构造方法的重载:

• 如果定义了带参数构造方法, 还要使用无参构造方法, 就必须再写一个无参数构造方法

推荐使用

• 无论是否使用,都手工书写无参数构造方法

标准类的制作

成员变量

• 使用private修饰

构造方法

• 提供一个无参构造方法
• 提供一个带多个参数的构造方法

成员方法

• 提供每一个成员变量对应的setXxx()/getXxx()
• 提供一个显示对象信息的show()

创建对象并且为成员变量赋值的两种方式

• 无参构造方法创建对象之后使用setXxx()赋值
• 使用带参构造直接创建带有属性值的对象

package ClassInstance;

public class StudentStandard {
    private String name;
    private int age;

    public StudentStandard() {};

    public StudentStandard(String name, int age) {
        this.name  = name;
        this.age = age;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
    
    public int getAge() {
        return this.age;
    }
    
    public void show() {
        System.out.println(name + "," + age);
    }
    
}