06-类与对象；封装；构造方法

最新推荐文章于 2022-03-15 14:39:52 发布
最新推荐文章于 2022-03-15 14:39:52 发布
阅读量371 收藏 1
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42375099/article/details/106185066
版权

文章目录

1. 面向对象思想

  1. 面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲历亲为，详细处理每一个细节。
  2. 面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个具有该功能的人，来帮我做事。
  3. 面向对象的三大特征：封装、继承和多态。

1.1. 类和对象

1.1.1. 什么是类

  • 类：是一组相关属性和行为的集合。可以堪称是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。
  • 属性：就是该事物的状态信息。
  • 行为：就是该事物能够做什么。
    • 举例—小猫
    • 属性：名字、体重、年龄、颜色。
    • 行为：走、跑、叫。

1.1.2. 什么是对象

  • 对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

    例如：现实中，一致猫就是一类事物的一个实例；

    属性：tom、5kg、2 years、yellow；行为：溜墙根走、蹦跶的跑、喵喵的叫。

1.1.3. 类与对象的关系

  1. 类是一类事物的描述，是抽象的。
  2. 对象是一类事物的实例，是具体的。
  3. 类是对象的模板，对象是类的实体。

1.2. 类的定义

  • 现实世界的一类事物：

    1. 属性：事物的状态信息。

    2. 行为：事物能够做什么。

  • Java中用class描述事物也是如此：（和Python的类中的属性和方法一样）

    1. 成员变量：对应事物的属性。（定义在类之中，在方法外，区别于局部变量）
    2. 成员方法：对应事物的行为。（在定义方法时候，没有static关键字就是成员方法！有static关键字的话，这个方法不需要对象实例就可以直接调用！一句话概括static关键字：方便在没有创建对象的情况下进行调用(方法/变量）
package cn.itcast.day06.demo01;

public class Student {
    // 1. 成员变量：
    String name;
    int age;
    // 2. 成员方法：
    public void eat() {
        System.out.println("吃饭");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
    public void study() {
        System.out.println("学习");
    }
}
  • 注意事项：
    1. 成员变量是直接定义在类当中的，在方法外边。
    2. 成员方法不要写static关键字！（有static关键字的话，这个方法不需要对象实例就可以直接调用！）

1.3. 类的创建及其使用

步骤：

  1. 导包：指出需要的类在什么位置。import 包名称.类名称；对于和当前类属于同一个包的情况，可以省略导包语句不写。
  2. 创建：类名称 对象名 = new 类名称();
  3. 使用：两种情况
    • 如何使用成员变量：对象名.成员变量名
    • 如何使用成员方法：对象名.成员方法名(参数)
package cn.itcast.day06.demo01;

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

        // 2. 创建：
        Student stu = new Student();

        // 3. 使用其中的成员变量：
        System.out.println(stu.name); // null
        System.out.println(stu.age); // 0
        System.out.println("====================");
        // 改变对象啊当中的成员变量数值内容：
        stu.name = "赵丽颖";
        stu.age = 18;
        System.out.println(stu.name); // 赵丽颖
        System.out.println(stu.age); // 18

        // 4. 使用成员方法：
        stu.eat();
        stu.study();
    }
}

1.4. 类与对象的练习

  • 定义手机类：
public class Phone {
    // 1. 成员变量：
	String brand; //品牌
	double price; //价格
	String color; //颜色
    
	// 2. 成员方法：
	//打电话
	public void call(String who) {
		System.out.println("给"+who+"打电话");
	}
	//发短信
	public void sendMessage() {
		System.out.println("群发短信");
	}
}
  • 定义测试类：
public class Demo01PhoneOne {
	public static void main(String[] args) {
        //创建对象
        Phone one = new Phone();
        //输出成员变量值
        System.out.println(one.brand); // null
        System.out.println(one.price); // 0.0
        System.out.println(one.color); // null
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
        //给成员变量赋值
        p.brand = "苹果";
        p.price = 8388.0;
        p.color = "黑色";
        //再次输出成员变量值
        System.out.println(pone.brand); // 苹果
        System.out.println(one.price); // 8388.0
        System.out.println(one.color); // 黑色
        System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
        //调用成员方法
        one.call("乔布斯");
        one.sendMessage();
	}
}

1.5. 对象的内存图

  • 上面练习的内存图：

在这里插入图片描述

1.5.1. 两个对象使用同一个内存图

  • 这里我们新建了另外一个对象”two“。

在这里插入图片描述

1.5.2. 两个引用指向同一个对象的内存图

  • 左侧红圈：将one的内存中的地址赋值给two。

在这里插入图片描述

1.5.3. 使用对象类型作为方法的参数

在这里插入图片描述

  • 注意：在定义方法时候，没有static关键字就是成员方法！有static关键字的话，这个方法不需要对象实例就可以直接调用！

1.5.4. 使用对象类型作为方法的返回值

package cn.itcast.day06.demo02;

public class Demo05PhoneReturn {
    public static void main(String[] args) {
        Phone two = getPhone();
        System.out.println(two.brand); // 苹果
        System.out.println(two.price); // 8388.0
        System.out.println(two.color); // 玫瑰金
    }
    // 返回值类型是Phone类型：
    public static Phone getPhone() {
        Phone one = new Phone();
        one.brand = "苹果";
        one.price = 8388.0;
        one.color = "玫瑰金";
        // 谁调用我，我就把one的地址值交给谁：
        return one;
    }
}

在这里插入图片描述

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

区别有五点：

  1. 定义的位置不一样【重点】：

    局部变量：在方法的内部。

    成员变量：在方法的外部，直接写在类当中。

  2. 作用范围不一样【重点】：

    局部变量：只有方法当中才可以使用，出了方法就不能再用了。

    成员变量：整个类全都可以通用。

  3. 默认值不一样【重点】：

    局部变量：没有默认值，如果想要使用，必须手动进行赋值。

    成员变量：如果没赋值，会有默认值。

  4. 内存的位置不一样【了解】：

    局部变量：位于栈内存。

    成员变量：位于堆内存。

  5. 生命周期不一样【了解】：

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

    成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失。

package cn.itcast.day06.demo03;

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

    public void methodA() {
        int num = 20; // 局部变量
        System.out.println(num);
    }
    public void methodB() {
        int age;
        // System.out.println(age); // 没赋值不能用！
        // System.out.println(num); // 错误写法！num不在这个方法中！
        System.out.println(name);
    }
}

2. 封装

  • 封装性在Java当中体现有两点：

    1. 方法就是一种封装。

    2. 关键字private也是一种封装。

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

2.1. private关键字；Getter/Setter

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

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

  • 一旦使用了private关键字进行修饰，那么本类当中仍然可以随意访问。但是！一旦超出了本类的范围就不能进行访问了。但是可以间接访问。

  • 间接访问private成员变量：就是定义一对Getter/Setter方法。命名规则：必须叫setXxx和getXxx。

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

  • 例如：定义一个Person类，假如age的数值不合理：

package cn.itcast.day06.demo03;

public class Person {
    String name;
    private int age;

    public void show() {
        System.out.println("我叫" + name + "年龄" + age);
    }
    // 这个方法，专门用于向age设置数据：
    public void setAge(int num) {
        if (num < 100 && num >= 0) {
            age = num;
        } else {
            System.out.println("数据不合理！");
        }
    }
    // 这个方法，专门用于获取age数据：
    public int getAge() {
        return age;
    }
}
  • 使用Person类：
package cn.itcast.day06.demo03;

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

        person.name = "赵丽颖";
        // person.age = -20; // 直接访问private方法是错误的
        person.setAge(-20);
        person.show();
    }
}
  • 注意事项：对于基本类型当中的boolean，它的Getter方法一定要写成isXxxx的形式，而setXxx规则不变。例如：创建一个Student类，看是不是男的
package cn.itcast.day06.demo03;

public class Student {
    private String name;
    private int age;
    private boolean male; // 是不是男的

    public void setMale(boolean b){
        male = b;
    }
    // 注意：布尔类型Getter方法一定要写成isXxxx的形式
    public boolean isMale(){
        return 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;
    }
}
  • 使用Student类：
package cn.itcast.day06.demo03;

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

2.2. 封装优化1—this关键字

  • 当方法的局部变量和类的成员变量重名的时候，根据”就近原则“，优先使用局部变量。如果需要访问本类当中的成员变量，需要使用格式：this.成员变量名。对比：在Python中遇到成员变量和局部变量重名的情况：使用global关键字。
  • 通过哪个对象调用的方法，那个对象就是this。
  • 示例：创建一个Person类，成员变量和局部变量同名，都为name：
package cn.itcast.day06.demo04;

public class Person {
    String name;
    // 参数name是对方的名字
    // 成员变量name是自己的名字
    public void sayHello(String name) {
        System.out.println(name + "你好，我是" + this.name); //王思聪你好，我是王健林
    }
}
  • 使用Person类：
package cn.itcast.day06.demo04;

public class Demo01Person {
    public static void main(String[] args) {
        Person person = new Person();
        // 设置我自己的名字：
        person.name = "王健林";
        person.sayHello("王思聪");
    }
}

2.3. 封装优化2—构造方法

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

  • 格式：

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

  • 注意事项：

    1. 构造方法的名称必须和所在类的名称完全一致，就连大小写也要一样。
    2. 构造方法不要写返回值类型，也不能写void。
    3. 构造方法不能return一个具体的返回值。
    4. 如果没有编写任何构造方法，那么编译器将会默认赠送一个构造方法，没有参数、方法体，什么事情都不做。
    5. 一旦编写了至少一个构造方法，那么编译器将不再赠送构造方法。
    6. 构造方法也是可以进行重载的。重载：方法名称相同，参数列表不同。

  • 示例：创建一个Student类，并且重写构造方法：

package cn.itcast.day06.demo04;

public class Student {
    // 1. 成员变量：
    private String name;
    private int age;

    // 2. 无参数的构造方法：
    public Student() {
        System.out.println("无参数的构造方法执行了！");
    }
    // 3. 有参数的构造方法：
    public Student(String name, int age) {
        System.out.println("有参数的构造方法执行了！");
        this.name = name;
        this.age = age;
    }
    // 4. 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;
    }
}
  • 使用Student类：
package cn.itcast.day06.demo04;

public class Demo02Student {
    public static void main(String[] args) {
        // 1. 无参构造：
        Student stu1 = new Student();
        System.out.println("==================");
        // 2. 有参构造：
        Student stu2 = new Student("赵丽颖", 20);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge()); // 姓名赵丽颖年龄20
        // 如果需要改变对象当中的的成员变量的数据，仍然需要使用setXxx方法：
        stu2.setAge(21);
        System.out.println("姓名" + stu2.getName() + "年龄" + stu2.getAge()); // 姓名赵丽颖年龄21
    }
}

3. 实例：定义一个标准的类

  • 一个标准的类通常要满足一下四个组成部分：

    1. 所有的成员变量都要使用private关键字修饰。
    2. 为每一个成员变量编写一堆Getter/Setter方法。
    3. 编写一个无参数的构造方法。
    4. 编写一个全参数的构造方法。

  • 这样标注男的类也叫做Java Bean。

  • IntelliJ可以自动生成Getter/Setter方法：（快捷键：alt+insert）

在这里插入图片描述

在这里插入图片描述

  • 按住shift键，就都能选上了：

在这里插入图片描述

  • 自动生成构造方法：

在这里插入图片描述

  • 自动创建无参数的构造方法：选择点击Select None

在这里插入图片描述

  • 自动创建有参数的构造方法：

在这里插入图片描述

  • 练习：创建一个Student类：
package cn.itcast.day06.demo05;

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

    public Student() {
    }

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

    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;
    }
}
  • 使用Student类：
package cn.itcast.day06.demo05;

public class Demo01Student {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("迪丽热巴");
        stu1.setAge(23);
        System.out.println(stu1.getName() + stu1.getAge());
        System.out.println("===================");

        Student stu2 = new Student("古力娜扎", 24);
        System.out.println(stu2.getName() + stu2.getAge());
        stu2.setAge(25);
        System.out.println(stu2.getName() + stu2.getAge());
    }
}
  • 使用Student类：
package cn.itcast.day06.demo05;

public class Demo01Student {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.setName("迪丽热巴");
        stu1.setAge(23);
        System.out.println(stu1.getName() + stu1.getAge());
        System.out.println("===================");

        Student stu2 = new Student("古力娜扎", 24);
        System.out.println(stu2.getName() + stu2.getAge());
        stu2.setAge(25);
        System.out.println(stu2.getName() + stu2.getAge());
    }
}
亚呦u椰
关注
专栏目录
面向对象编程---类与对象
koala__的博客
04-15 317
1 面向对象编程简介 1.1 面向对象编程的三大特征 封装性：将客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或对象操作，对不可信的进行信息隐藏。简而言之就是，内部操作对外部而言不可见（保护性）。 继承性：可使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 多态性：一个类实例的相同方法在不同情形下有不同表现形式。多态机制使具有不同内部结构的内...
【类与对象、封装、构造方法】
丢失了名字的琥珀川
09-02 249
排序 时间复杂度 稳定程度 (基本有序)时间复杂度 插入 直接插入 O(n^2) 稳定 O(n) 交换 冒泡 O(n^2) 稳定 O(n) 交换 快速 O(nLog2n) 不稳定 选择 直接选择 O(n^2) 不稳定 选择 堆 O(Log2n) 不稳...
Java 封装和构造方法
C_U_N_Z的博客
02-28 568
1.private实现封装 eg:使用private封装属性： private String name; private int age; 此时使用了private对属性进行了封装，要访问私有属性，按照Java的设计原则必须提供一下俩种方法： setter方法：主要用于进行属性内容的设置与修改 getter方法：主要用于属性内容的取得 eg： class Person{ priva...
JAVA 封装、构造方法、以及标准类的制作
zhengsanmiing的博客
11-25 459
封装的概述： 是面向对象的三大特征之一（封装、继承、多态）。 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部，外界是无法直接操作的。 封装原则： 将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现隐藏信息的操作和访问成员变量private，提供对应的getX（）/setX()方法。c 封装的好处： 通过方法来控制成员变量的操作，提高了代码的安全性。 把代码用方法进行封装，提高了代码的复用性。 构造方法概述： 构造方法是一种特殊的..
封装和构造方法（Java语言）
qq_57563254的博客
11-12 1017
Java语言封装什么是封装private实现封装使用public使用privategetter和setter方法构造方法基本语法语法规则this关键字 封装 什么是封装 在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者。 封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了。这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度。 private实现封装 private/ public 这两个关键字表示 “访问权限控制”。 被 public 修饰的
Java面向对象与类(一):类与对象,封装和构造方法
qq_45416295的博客
04-29 431
目录1.面向对象2.类与对象3.对象内存图 1.面向对象 面向过程: 需要实现一个功能的时候,每一个具体的步骤都要分步完成,详细处理每个细节 面向对象:需要实现一个功能,不关心具体步骤,找一个具有这个功能的函数,由它来完成实现. import java.util.Arrays; ... public static void main(String[] args) { int[]...
day09-面向对象-封装&构造方法
12-12
本节主要讲解了面向对象的两个核心概念：封装和构造方法。 首先，我们来深入理解一下成员变量和局部变量的区别： 成员变量，也称为类变量，是在类定义中声明的变量。它们在整个类的范围内都是有效的，这意味着类的...
day07【类与对象、封装、构造方法】.pdf
11-02
类与对象、封装、构造方法 类和对象是面向对象编程的基础概念，它们之间的关系是面向对象编程的核心。类是对一类事物的描述，是抽象的；对象是一类事物的实例，是具体的。类是对象的模板，对象是类的实体。 面向...
06【类与对象、封装、构造方法】1
08-04
总的来说，面向对象思想和Java语言中的类与对象、封装、构造方法等概念，是编写高效、可维护的代码的关键。通过理解并熟练运用这些概念，开发者可以构建出更加符合实际需求、易于扩展和维护的软件系统。
课堂笔记07(包-构造方法-方法重载-封装-方法参数的传递
10-31
构造方法与类名相同，没有返回类型，且可以有不同参数列表，以便在创建对象时提供不同的初始化方式。Java允许我们定义多个构造方法，这就是所谓的构造方法重载。通过重载，我们可以根据需要提供不同的构造函数，以...
java学习笔记（三）封装和构造方法
weixin_30471561的博客
01-12 127
1.封装隐藏对象的属性和方法的实现细节，只公开对外接口。 类级别的封装：对成员变量私有化，提供set,get方法操作成员变量。方法级别的封装:将所完成的某种功能的一串逻辑代码封装成一个方法（私有），提供公共的入口来访问它。（尽量使方法的职责单一，间接的提高了方法的重用性。） OOP:Object Oriented Programming(面向对象的编程)面向对象的三大特性：封装，继承，多态. ...
java基础之封装及构造方法
qq_61593692的博客
03-15 502
java基础之封装
看了这篇文章，我也能说清Java中类的封装和构造方法的实现了！
qq_44723773的博客
11-15 577
一、如何实现类的封装 类的封装，是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内容信息，而是通过该类所提供的方法来实现对内部信息的操作访问。 具体的实现过程是，在定义一个类时，将类中的属性私有化，即使用privete关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公共方法，其中包括用于获取属性值的getXXX()方法和设置属性值的setXXX()方法。 1.1 实例代码 class Person { private Stri
java类的封装与构造方法
欢迎~
09-18 1985
class Person{ private String name; private int age; public Person(){ //构造方法(无返回值，为新定义的实例化对象的属性赋值，可重载) name = "未定义"; //或者 this.name = "未定义"；也可以，以下同 age = -1; } public Person(String n, int a){
基于Matlab极化天线和目标之间的信号传输建模 matlab代码.rar
11-16
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
移动通信网络中集中式无线电接入网的数据处理需求与性能指标分析
11-16
内容概要：本文提出了一种新的分析框架，用于评估集中式无线电接入网（RAN）的数据处理需求。作者定义了若干性能指标，如计算失效概率、复杂度、增益、多样性和复杂度率之间的权衡。该模型基于块瑞利衰落、距离相关路径损耗和部分功率控制假设下进行仿真验证，证明了集中计算资源的优势。 适用人群：通信工程领域的研究人员、5G技术开发人员和无线网络优化专家。 使用场景及目标：①理解集中式RAN架构对网络性能的影响；②评估集中化数据处理资源在提高吞吐量方面的效益；③量化集中式RAN系统的数据处理复杂度和可靠性。 其他说明：文章通过对多种场景和参数设置的仿真研究，展示了集中式RAN系统相对于传统分布式系统的优越性，为未来移动网络的设计提供了理论支持和技术依据。
444.exe44444
最新发布
11-16
444.exe44444
华为 ArkUI 框架的创新与生态探索.pdf
11-16
华为 ArkUI 框架的创新与生态探索.pdf
面向对象编程：类与对象、封装和构造方法解析
"day07【类与对象、封装、构造方法】的PDF教程主要讲解了面向对象编程的基础概念，包括类与对象、封装以及构造方法。教程通过对比面向过程和面向对象的思想来阐述面向对象的优势，并介绍了面向对象的三个核心特征：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值