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

最新推荐文章于 2022-03-15 14:39:52 发布
最新推荐文章于 2022-03-15 14:39:52 发布
阅读量202 收藏 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椰
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day07【类与对象、封装、构造方法】.pdf
11-02
day07【类与对象、封装、构造方法】.pdf
封装和构造方法（Java语言）
qq_57563254的博客
11-12 936
Java语言封装什么是封装private实现封装使用public使用privategetter和setter方法构造方法基本语法语法规则this关键字 封装 什么是封装 在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者。 封装的本质就是让类的调用者不必太多的了解类的实现者是如何实现类的, 只要知道如何使用类就行了。这样就降低了类使用者的学习和使用成本, 从而降低了复杂程度。 private实现封装 private/ public 这两个关键字表示 “访问权限控制”。 被 public 修饰的
JAVA 封装、构造方法、以及标准类的制作
zhengsanmiing的博客
11-25 424
封装的概述： 是面向对象的三大特征之一（封装、继承、多态）。 是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部，外界是无法直接操作的。 封装原则： 将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现隐藏信息的操作和访问成员变量private，提供对应的getX（）/setX()方法。c 封装的好处： 通过方法来控制成员变量的操作，提高了代码的安全性。 把代码用方法进行封装，提高了代码的复用性。 构造方法概述： 构造方法是一种特殊的..
面向对象编程---类与对象
koala__的博客
04-15 263
1 面向对象编程简介 1.1 面向对象编程的三大特征 封装性：将客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或对象操作，对不可信的进行信息隐藏。简而言之就是，内部操作对外部而言不可见（保护性）。 继承性：可使用现有类的所有功能，并在无需重新编写原来的类的情况下对这些功能进行扩展。 多态性：一个类实例的相同方法在不同情形下有不同表现形式。多态机制使具有不同内部结构的内...
java学习笔记（三）封装和构造方法
weixin_30471561的博客
01-12 107
1.封装隐藏对象的属性和方法的实现细节，只公开对外接口。 类级别的封装：对成员变量私有化，提供set,get方法操作成员变量。方法级别的封装:将所完成的某种功能的一串逻辑代码封装成一个方法（私有），提供公共的入口来访问它。（尽量使方法的职责单一，间接的提高了方法的重用性。） OOP:Object Oriented Programming(面向对象的编程)面向对象的三大特性：封装，继承，多态. ...
java基础之封装及构造方法
qq_61593692的博客
03-15 473
java基础之封装
day06【类与对象、封装、构造方法】.pdf
02-20
day06【类与对象、封装、构造方法】.pdf
day09-面向对象-封装&构造方法
12-12
小白新人，基础java知识分享
06【类与对象、封装、构造方法】1
08-04
第1章 面向对象思想1.1 面向对象思想概述概述Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Ja
Java提升学习（二）：构造方法，类的继承，封装
12-21
类有一种特殊的成员方法叫做构造方法，构造方法与类同名，在创建对象时，会自动调用类的构造方法。 构造方法没有返回类型，更不能定义为void，不可加其他修饰符。 若没有被定义，则在编译的时候，会自动加上一个默认...
【类与对象、封装、构造方法】
丢失了名字的琥珀川
09-02 214
排序 时间复杂度 稳定程度 (基本有序)时间复杂度 插入 直接插入 O(n^2) 稳定 O(n) 交换 冒泡 O(n^2) 稳定 O(n) 交换 快速 O(nLog2n) 不稳定 选择 直接选择 O(n^2) 不稳定 选择 堆 O(Log2n) 不稳...
Java 封装和构造方法
C_U_N_Z的博客
02-28 521
1.private实现封装 eg:使用private封装属性： private String name; private int age; 此时使用了private对属性进行了封装，要访问私有属性，按照Java的设计原则必须提供一下俩种方法： setter方法：主要用于进行属性内容的设置与修改 getter方法：主要用于属性内容的取得 eg： class Person{ priva...
看了这篇文章，我也能说清Java中类的封装和构造方法的实现了！
qq_44723773的博客
11-15 376
一、如何实现类的封装 类的封装，是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内容信息，而是通过该类所提供的方法来实现对内部信息的操作访问。 具体的实现过程是，在定义一个类时，将类中的属性私有化，即使用privete关键字来修饰，私有属性只能在它所在类中被访问，如果外界想要访问私有属性，需要提供一些使用public修饰的公共方法，其中包括用于获取属性值的getXXX()方法和设置属性值的setXXX()方法。 1.1 实例代码 class Person { private Stri
java类的封装与构造方法
欢迎~
09-18 1905
class Person{ private String name; private int age; public Person(){ //构造方法(无返回值，为新定义的实例化对象的属性赋值，可重载) name = "未定义"; //或者 this.name = "未定义"；也可以，以下同 age = -1; } public Person(String n, int a){
Java面向对象与类(一):类与对象,封装和构造方法
qq_45416295的博客
04-29 328
目录1.面向对象2.类与对象3.对象内存图 1.面向对象 面向过程: 需要实现一个功能的时候,每一个具体的步骤都要分步完成,详细处理每个细节 面向对象:需要实现一个功能,不关心具体步骤,找一个具有这个功能的函数,由它来完成实现. import java.util.Arrays; ... public static void main(String[] args) { int[]...
node-v5.11.0-x86.msi
05-07
Node.js，简称Node，是一个开源且跨平台的JavaScript运行时环境，它允许在浏览器外运行JavaScript代码。Node.js于2009年由Ryan Dahl创立，旨在创建高性能的Web服务器和网络应用程序。它基于Google Chrome的V8 JavaScript引擎，可以在Windows、Linux、Unix、Mac OS X等操作系统上运行。 Node.js的特点之一是事件驱动和非阻塞I/O模型，这使得它非常适合处理大量并发连接，从而在构建实时应用程序如在线游戏、聊天应用以及实时通讯服务时表现卓越。此外，Node.js使用了模块化的架构，通过npm（Node package manager，Node包管理器）,社区成员可以共享和复用代码，极大地促进了Node.js生态系统的发展和扩张。 Node.js不仅用于服务器端开发。随着技术的发展，它也被用于构建工具链、开发桌面应用程序、物联网设备等。Node.js能够处理文件系统、操作数据库、处理网络请求等，因此，开发者可以用JavaScript编写全栈应用程序，这一点大大提高了开发效率和便捷性。 在实践中，许多大型企业和组织已经采用Node.js作为其Web应用程序的开发平台，如Netflix、PayPal和Walmart等。它们利用Node.js提高了应用性能，简化了开发流程，并且能更快地响应市场需求。
41532698775097Facebook Lite_405.0.0.8.113_apkcombo.com.armeabi-v7a.apk
05-07
41532698775097Facebook Lite_405.0.0.8.113_apkcombo.com.armeabi-v7a.apk
2024-2030中国RDF制粒机市场现状研究分析与发展前景预测报告.docx
05-07
2024-2030中国RDF制粒机市场现状研究分析与发展前景预测报告
财务困境-RLPM模型.xlsx
最新发布
05-07
详细介绍及样例数据：https://blog.csdn.net/li514006030/article/details/138549562
封装、类、继承、对象、多态、重写、重载、构造方法
11-14
封装：封装是面向对象编程的三大特性之一，指将数据和方法包装在类中，对外部世界隐藏内部实现细节，只暴露必要的接口给外部使用。...构造方法的名称必须与类名相同，没有返回值类型，可以有参数。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值