08. 【封装、构造方法】

最新推荐文章于 2024-07-10 21:37:49 发布

LiuszZZ

最新推荐文章于 2024-07-10 21:37:49 发布

阅读量144

点赞数

分类专栏： # Dark horse 文章标签： java

原文链接：http://www.itheima.com/

版权

Dark horse 专栏收录该内容

89 篇文章 0 订阅

订阅专栏

1. 封装

概述

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

原则

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

封装的步骤

使用private关键字来修饰成员变量。
对需要访问的成员变量，提供对应的一对getxxx方法、setxxx方法。

2. 封装操作：private

含义

private是一个权限修饰符，代表最小权限。
可以修饰成员变量和成员方法。
被private修饰后的成员变量和成员方法，只在本类中才能访问。

封装在Java当中的体现

封装就是将一些细节隐藏起来，对于外界不可见（达到省心的目的）。
例如封装一个方法，main只管调用即可（不需要关心方法的具体实现形式）

方法就是一种封装
关键字pravite也是一种封装

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

使用格式

private 数据类型 变量名;

1. 使用`private`修饰成员变量

代码：

public class Student {

    private String name;
    private int age;
    private boolean male;
}

2. 提供 `get/set` 方法,间接访问成员变量

定义一对getter/setter方法，必须叫setXxx或者是getXxx命名规则。

对于Getter来说，不能有参数，返回值类型和成员变量对应；
对于Setter来说，不能有返回值，参数类型和成员变量对应。

代码：

public class Student {

    private String name;
    private int age;
    private boolean male;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setMale(boolean b) {
        male = b;
    }

    public boolean isMale() { //注意是isXxx
        return male;
    }
}

访问pravite内容

Person

package cn.luis.demo3;

public class Person {

    String name;
    private int age;

    public void show() {
        System.out.println("我叫:" + name + "\t年龄:" + age);
    }

    //这个成员方法，专门用于向age设置数据
    public void setAge(int num) { //有参数无返回 参数类型和成员变量对应
        if (100 > num && num < 0) {
            age = num;
        } else{
            System.out.println("数据错误！！");
        }

    }

    //这个成员方法，专门用于获取age的数据
    public int getAge() {  //无参数有返回  返回值类型要和成员变量对应
        return age;
    }
}

Demo03Person

package cn.luis.demo3;

public class Demo03Person {

    public static void main(String[] args) {
        Person person = new Person();
        person.show();

        person.name = "小明";
        // person.age = 20; //直接访问pravite内容是错误的

        person.setAge(15);
        person.show();
    }
}

结果：

我叫:null	年龄:0
数据错误！！
我叫:小明	年龄:0

注意`boolean`值

对于基本类型当中的boolean值，getter方法要写成isXxx

Student

package cn.luis.demo3;

/*
    对于基本类型当中的boolean值，getter方法要写成isXxx
 */
public class Student {

    private String name;
    private int age;
    private boolean male;

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setMale(boolean b) {
        male = b;
    }

    public boolean isMale() { //注意是isXxx
        return male;
    }
}

Demo04Student

package cn.luis.demo3;

public class Demo04Student {

    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());
    }
}

结果：

姓名：钢铁侠
年龄：20
是不是爷们：true

案例：求出一个数组中的最大值

问题描述：定义person的年龄时，无法阻止不合理的数值被设置进来。

解决方案：用pravite进行修饰，那么本类当中仍然可以随意访问。

但是！超出本类之外就不能在直接访问了。

代码：

package cn.luis.demo3;

public class Demo02Method {

    public static void main(String[] args) {
        int[] array = {5,15,25,35,45,100};

        int max = getMax(array);
        System.out.println("最大值：" + max); // 最大值：100
    }

    //给我一个数组，我还给你一个最大值
    public static int getMax(int array[]) {

        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if (array[i] > max) {
                max = array[i];
            }
        }
        return max;
    }
}

3. 封装优化-- this

我们发现setxxx方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？代码如下：

public class Student {

    private String name;
    private int age;
    
    public void setName(String name) {
        name = name;
    }
    public void setAge(int age) {
        age = age;
    }
}

经过修改和测试，我们发现新的问题，成员变量赋值失败了。

也就是说，在修改了setxxx()的形参变量名后，方法并没有给成员变量赋值！

这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无法访问到成员变量，从而赋值失败。

所以，我们只能使用this关键字，来解决这个重名问题。

含义

this所在类的当前对象的引用（地址值），即对象自己的引用。

记住：方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

使用格式

使用this修饰方法中的变量，解决成员变量被隐藏的问题

this.成员变量名;

代码如下：

public class Student {

    private String name;
    private int age;
    
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

小贴士:方法中只有一个变量名时，默认也是使用this修饰，可省略不写。

理解

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

如果需要访问本类当中的的成员变量，需要使用格式：

在重名的情况下起到区分的作用

 this.成员变量名

注意

this关键字要写在方法的内部
“谁调用(含this)的方法，谁就是this”
person调用的sayHello --> person.sayHello("王思聪");

this.name 就相当于 person.name (但是不能这么写!)

System.out.println(this);  |  System.out.println(person);
 // cn.luis.demo4.Person@5594a1b5 : 类型@地址值

代码：

package cn.luis.demo4;

public class Person {
	//成员变量name是自己的名字
    String name;

    public void sayHello(String name) {  //参数name是对方的名字
        System.out.println(name + " 你好,我是 " + this.name);

        System.out.println("this ---> " + this);
        // this ---> cn.luis.demo4.Person@57829d67 : 类型@地址值
    }
}

Demo01Person

package cn.luis.demo4;

public class Demo01Person {

    public static void main(String[] args) {
        Person person = new Person();
        //设置自己名字
        person.name = " 钢铁侠";
        person.sayHello("蜘蛛侠");

        System.out.println("person ---> " + person);
        // person ---> cn.luis.demo4.Person@57829d67 : 类型@地址值
    }
}

结果：

蜘蛛侠 你好,我是  钢铁侠
this ---> cn.luis.demo4.Person@57829d67
person ---> cn.luis.demo4.Person@57829d67

4. 封装优化：构造方法

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

格式

方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void

public 类名称(参数类型 参数名称) {
       	 	方法体
}

代码：

public class Student {

    //成员变量
    private String name;
    private int age;

    //无参数的构造方法
    public Student() {
        System.out.println("默认无参构造方法执行啦！");
        //return 100; //错误的！！！
    }

    //全参数的构造方法
    public Student(String name,int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name; //把参数赋值给成员变量
        this.age = age;
    }  
}

注意事项

如果你不提供构造方法，系统会给出无参数构造方法。

无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法
如果你提供了构造方法，系统将不再提供无参数构造方法。

一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。
构造方法是可以重载的，既可以定义参数，也可以不定义参数。

理解

构造方法就是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实就是在调用构造方法。

构造方法的使用(调用)

 new Student(); | Student stu1 = new Student();

注意事项

构造方法的名称必须和所在的类名称完全一样（包括大小写）。
构造方法不要写返回值类型，连void都不要写
构造方法不能return一个具体的返回值
如果没有编写任何构造方法，那么编译器会默认赠送一个构造方法，没有参数，方法体什么都不会做。
```
  public Student() {}
```
一旦编写了至少一个构造方法，那么编译器将不再赠送
构造方法也是可以重载的

重载：方法名称相同，参数不同

代码：

package cn.luis.demo4;

public class Student {

    //成员变量
    private String name;
    private int age;

    //无参数的构造方法
    public Student() {
        System.out.println("默认无参构造方法执行啦！");
        //return 100; //错误的！！！
    }

    //全参数的构造方法
    public Student(String name,int age) {
        System.out.println("全参构造方法执行啦！");
        this.name = name; //把参数赋值给成员变量
        this.age = age;
    }

    //Getter Setter方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }
}

Demo02Student

package cn.luis.demo4;

public class Demo02Student {

    public static void main(String[] args) {

        //无参构造
        Student stu1 = new Student(); //new后面的类名称就是构造方法名

        System.out.println("=====================");

        //全参构造
        //利用构造方法直接传值给参数name和age，然后又传给this.name和this.age，比set\get简单
        Student stu2 = new Student("浩克",35);

        System.out.println("姓名：" + stu2.getName() + ",年龄：" + stu2.getAge());

        //如果需要给变成员变量对象中的内容，仍需要使用get/set方法
        stu2.setAge(36);
        System.out.println("姓名：" + stu2.getName() + ",年龄：" + stu2.getAge());
    }
}

结果：

默认无参构造方法执行啦！
=====================
全参构造方法执行啦！
姓名：浩克,年龄：35
姓名：浩克,年龄：36

5. 标准代码：JavaBean

JavaBean是Java语言编写类的一种标准规范。符合]avaBean的类

要求类必须是具体的和公共的，并且具有无参数的构造方法，提供用来操作成员变量的 set和get方法。

标准的类组成

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

这样的标准的类也叫做Java Bean

代码：

package cn.luis.demo5;

public class Student {

    //成员变量
    private String name; // 姓名
    private int age; // 年龄
    private boolean male;  // 性别

    //无参数构造方法
    public Student() {
    }

    //全参数构造方法
    public Student(String name, int age, boolean male) {
        this.name = name;
        this.age = age;
        this.male = male;
    }

    //Getter Setter方法
    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 boolean isMale() {
        return male;
    }

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

Demo01Student

package cn.luis.demo5;

public class Demo01Student {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("迪丽热巴");
        stu1.setAge(20);
        stu1.setMale(true);

        System.out.println("姓名：" + stu1.getName() + "\t年龄：" + stu1.getAge() + "\t是不是爷们：" + stu1.isMale());
        System.out.println("====================");

        Student stu2 = new Student();
        stu2.setName("古力娜扎");
        stu2.setAge(21);

        System.out.println("姓名：" + stu2.getName() + "\t年龄：" + stu2.getAge());
        stu2.setAge(22);
        System.out.println("姓名：" + stu2.getName() + "\t年龄：" + stu2.getAge());
    }

}

结果：

姓名：迪丽热巴	 年龄：20	是不是爷们：true
====================
姓名：古力娜扎	 年龄：21
姓名：古力娜扎	 年龄：22

LiuszZZ

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
08. 【封装、构造方法】

1. 封装概述面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。原则将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。封装的步骤使用private关键字来修饰成...
复制链接

扫一扫