类的定义

定义一个类,用来模拟“学生”事务。其中就有两个组成部分:

属性(是什么):

姓名

年龄

行为(能做什么):

吃饭

睡觉

学习

对应Java当中:

成员变量(属性):

String name; // 姓名

int age; // 年龄

成员方法(行为):

public void eat() {} // 吃饭

public void sleep {} // 睡觉

public void stydy {} // 学习

注意事项:

  1. 成员变量是直接定义再类当中,再方法外边。
  2. 成员方法不要写static关键字。

public class Student {
    // 成员变量
    String name;    // 姓名
    int age;        // 年龄

    // 成员方法
    public void eat() {
        System.out.println("吃饭饭!!");
    }

    public void sleep() {
        System.out.println("睡觉觉!!");
    }

    public void study() {
        System.out.println("学习!!!");
    }

}

类的使用

通常情况下,类并不能直接使用,需要根据类创建一个对象才能使用。

1. 导包

导包:就也是指出需要使用的类,再什么位置。

import 包名称.类名称;
import cn.com.wkcto.Student;

对于和当前属于同一个包的情况,可以省略导包语句不写。

2. 创建

类名称 对象名 = new 类名称();
Student stu = new Student();

3. 使用

使用分为两种情况:

  • 使用成员变量:对象名.成员变量名
  • 使用成员方法:对象名.成员方法名()

注意事项:

如果成员变量没有进行赋值,那么将会有一个默认值,规则和数组一样。

整数默认初始化为0

小数默认初始化为0.0

字符是u000

Boolean为false

引用值为null

案例

package com.wkcto;
//import cn.com.wkcto.Student;

public class Demo01Student {
    public static void main(String[] args) {
        // 1.导包
        // 我需要使用的Student类,和我自己Demo01Student位于同一个包下,所以省略语句不写

        // 2.创建
        // 类名称 对象名 = new 类名称();
        // 根据Student类创建了一个名为stu的对象
        Student stu = new Student();

        // 3. 使用其中的成员变量
        // 对象名.成员变量名
        stu.age = 19;
        stu.name = "Fivk";
        System.out.println(stu.name);
        System.out.println(stu.age);

        // 4. 使用成员变量的成员方法
        // 对象名.方法名()
        stu.eat();
        stu.sleep();
        stu.study();
    }
}

运行结果

使用类作为方法的返回值

依旧采用了Phone类

package com.wkcto.demo02;

public class Demo05PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        putPhone(two);
    }
    public static Phone getPhone() {
        Phone one = new Phone();
        one.brand = "小米 10";
        one.price = 3999.00;
        one.color = "海洋蓝";
        return one;
    }
    public static void putPhone(Phone param) {
        System.out.println("品牌: " + param.brand);
        System.out.println("价格: " + param.price);
        System.out.println("颜色: " + param.color);
    }
}

有CPP基础毫无压力呀是吧哈哈哈哈哈。

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

  • 定义的位置不一样

局部变量:在方法内部定义

成员变量:在方法外部定义(直接写在类当中)

  • 作用范围不一样

局部变量:只有被定义的方法当中才能使用

成员变量:在整个类当中都能使用(不能在其他类使用)

  • 默认值不一样

局部变量:没有默认值,想要使用必须先赋值

成员变量:会有默认值,规则和数组一样。

  • 内存的位置不一样

局部变量:位于栈内存

成员变量:位于堆内存

  • 生命周期不一样

局部变量:随着方法进栈而诞生,随着方法出栈而消失。

成员变量:随着对象创建而诞生,随着对象释放而回收。

package com.wkcto.demo03;

public class Demo01ValiableDifferennce {
    String name;    // 成员变量

    public static void main(String[] args) {
        int num = 20;    // 局部变量
        int num1;
        System.out.println(num);
        System.out.println(num1);   // Error
    }

    public void method01(int param) {
        System.out.println(name);
        System.out.println(num);  // Error
        System.out.println(param);  // 参数就是局部变量
        // 参数在方法调用时,必然会被赋值
    }
}

面向对象的三大特性之封装性

面向对象三大特征: 封装、继承、多态。

封装是什么?

封装就是将一些细节信息隐藏起来,对外界不可见。

封装性在java当中的体现:

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

private 关键字的作用

package com.wkcto.demo03;

public class Person {
    String name;    // 姓名
    int age;        // 年龄
    public void show() {
        System.out.println("我叫" + name);
        System.out.println("今年" + age + "岁");
    }
}
package com.wkcto.demo03;

public class Demo03Person {
    public static void main(String[] args) {
        Person  person = new Person();
        person.name = "Fivk";
        person.age = -18;
        person.show();
    }
}

输出-18

输出显然不合理。

问题描述:定义Person的年龄时,无法阻止不合理的数值被设置。

解决方案:用private关键字将需要保护的成员变量进行修饰。

一旦使用private进行修饰,那么本类当中仍然可以随意访问。但是,超出了本类范围之外就不能再直接访问了。(只能间接访问)

设置方法:新增一个类,set+被privet修饰的变量名(第一个要大写),用来修改数据;或者定义一个get+被privet修饰的变量名(第一个要大写),用来获取数据。

间接访问privte成员变量,就是定义一对getter/setter方法

setTer(auto) 有参数无返回 参数类型和成员变量对应

getTer(void) 无参数有返回 返回类型和成员变量对应

package com.wkcto.demo03;

public class Person {
    String name;    // 姓名
    private int age;        // 年龄
    public void show() {
        System.out.println("我叫" + name);
        System.out.println("今年" + age + "岁");
    }

    // 这个成员方法专门用来向age设置数据
    public void setAge(int num) {
        if (num < 100 && num >= 0) {
            age = num;
        } else {
            System.out.println("数据不合理");
        }
    }

    // 这个成员方法专门用来获取age的数据
    public int getAge() {
        return age;
    }
}
package com.wkcto.demo03;

public class Demo03Person {
    public static void main(String[] args) {
        Person  person = new Person();
        person.name = "Fivk";
        // person.age = -18;  [Error]
        person.setAge(-18); // 不合理
        person.setAge(18);
        person.show();
    }
}

this 关键字的作用

package demo01;

public class Person {
    String name;    // 自己名字

    // who是对方的名字,name是自己的名字
    public void sayHello(String who) {
        System.out.println(who + "你好。我是" + name);
    }
}
package demo01;

public class Demo01Person {
    public static void main(String[] args) {
        Person person = new Person();
        // 设置自己的名字
        person.name = "马云";
        person.sayHello("马化腾");
    }
}

这两行代码运行结果

当方法局部变量和类的成员变量重名时候,根据“就近原则”,优先使用局部变量。

如果需要访问本类当中的变量,需要使用格式:

this.成员变量名

public class Person {
    String name;    // 自己名字

    // who是对方的名字,name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + "你好。我是" + this.name);
    }
}

“通过谁调用的方法,谁就是this。”

// 我们这个代码里面 this 和 person 地址一样

最后修改:2021 年 10 月 04 日
如果觉得我的文章对你有用,请随意赞赏