面向对象的梳理（2）面向对象的特征之封装

是你的杜哥哥呢

已于 2023-05-27 18:20:01 修改

阅读量111

点赞数 1

文章标签： java 开发语言

于 2023-05-27 18:09:35 首次发布

本文链接：https://blog.csdn.net/m0_62491536/article/details/130893226

版权

本文介绍了Java编程中的基础概念，包括如何通过构造方法初始化对象，理解方法的重载以及封装的重要性。构造方法简化了对象属性的赋值，方法的重载增强了代码的灵活性。封装则是保护对象的内部状态，通过setter/getter方法控制对外访问。文章提供了示例代码帮助理解这些概念。

摘要由CSDN通过智能技术生成

1.前言

（1）写一个对象实例，打好地基才能万丈高楼平地起。

1.前言

（1）写一个对象实例，打好地基才能万丈高楼平地起。

需求：要求主人到宠物店挑选宠物，这个宠物有姓名、年龄、种类三种属性，有两个动物种族猫和狗可供选择（注：种类是狗狗的种类或者猫猫的种类，和种族无关。）输出挑选的宠物的这三种属性。

以下是详细代码：

动物类:

public class Dog {
    int age;
    String name;
    String kind;
    public void show(){
        System.out.println("我的名字是："+name+",我的种类是"+kind+",我今年"+age+"岁啦。");
    }
}
class Cat{
    int age;
    String name;
    String kind;
    public void show(){
        System.out.println("我的名字是："+name+"我的种类是"+kind+"我今年"+age+"岁啦");
    }
}

Test类：

import java.util.Scanner;

public class TestDog {

    public static void main(String[] args) {
        String name;
        int age;
        String kind ="";
        Dog dog=new Dog();
        Cat cat=new Cat();
        Scanner sc=new Scanner(System.in);
        System.out.println("请给宠物起个名字:");
        name=sc.next();
        System.out.println("你要抱养几岁的宠物？");
        age=sc.nextInt();
        System.out.println("请输入要领养的宠物：1：狗，2：猫");
        int number=sc.nextInt();
        switch (number){
            case 1:
                System.out.println("请输入要领养的狗狗类型:1.二哈 2.藏獒");
                int select=sc.nextInt();
                if (select==1){
                   kind="二哈";
                } else if (select==2) {
                    kind="藏獒";
                }
                dog.name=name;
                dog.age=age;
                dog.kind=kind;
                dog.show();
                break;
            case 2:
                System.out.println("请输入要抱养的猫猫类型：1.加菲猫 2.傻猫");
                int option=sc.nextInt();
                if (option==1){
                    kind="加菲猫";
                } else if (option==2) {
                    kind="傻猫";
                }
                cat.age=age;
                cat.name=name;
                cat.kind=kind;
                cat.show();
                break;
        }
    }
}

（2）构造方法

①什么是构造方法

构造方法也是方法的一种，是一种特殊的方法。

②为什么要使用构造方法

之前我们给属性赋值都是对象名点属性名，现在可以通过构造方法赋值简化赋值方式。

③构造方法的语法

a.构造方法名必须要与定义它的类名一致。

b.修饰符后直接加构造方法名，无返回值甚至没有void，例：public Pet（）{ }。

c.构造方法中可以没有参数也可以有多个参数。

d.构造方法的调用是在创建一个对象时使用new进行操作的。

④构造方法的作用

初始化对象，可以在构造方法中对属性进行赋值。

如下所示：

public class Pet {
    int age;
    String name;
    public Pet(){
        this.age=3;
        this.name="小黑";
    }
}

⑤有参构造方法与无参构造方法的区别

无参的构造方法：

在之前虽然我们并没有写过构造方法，但是我们在new对象的时候其实已经在调用无参的构造方法了，因为系统会默认提供一个无参的构造方法，如：Pet pet=new Pet（）；这种方式赋值就只能用pet.属性名的方式赋值，因为方法里没有参数。

有参的构造方法：

在我们写有参的构造方法时要注意一点，如果我们只写了有参的构造方法，那么系统就不会默认提供一个无参的构造方法。在写完有参构造方法后再写 Pet pet=new Pet（）；就会出错，如果既想用有参的构造方法，又想用无参的构造方法，就需要把有参的构造方法和无参的构造方法都写一遍。

二者亦有相同点：即初始化对象。

（3）方法的重载

①什么是方法的重载（★）

a.方法名相同

b.参数列表不同（个数、顺序、类型）

c.与访问修饰符和返回值无关

如下所示：

 public void method(String name,int age){
        
    }
 protected String method(double score){
        return "";
    }

②为什么要使用方法的重载

方法的重载可以让我们在一个类中或者一个接口中定义多个同名的方法，这些方法可以有不同的参数列表或参数类型。这样做的好处在于：

a.提高代码的可读性和可维护性：通过重载方法名，使代码更加易读和易于理解，可以提高代码的可读性和可维护性。

b.增加程序的灵活性：通过不同的方法重载，可以为不同的场景提供合适的方法，增加程序的灵活性和可适应性。

c. 优化代码性能：由于方法可以通过参数列表的不同来实现不同的功能，通过合理的方法重载可以优化代码性能，避免编写冗长繁琐的代码。

③使用方法的重载时会出现的问题

a. 调用方法时出现二义性：如果存在多个同名的方法，编译器无法确定调用哪一个方法，从而导致编译错误。

b. 参数类型匹配问题：当方法的参数类型或数量不匹配时，编译器无法将方法调用与正确的重载方法匹配，并且可能会导致编译错误。

c. 重载方法的可读性降低：重载方法虽然可以提高代码的灵活性，但是也可能会使代码难以理解。特别是在方法的重载数量增加时，代码的可读性和维护难度都会增加。

d.局部变量没有初始化值。

总的来说，使用方法的重载时需要注意方法名、参数数量和类型的匹配，以及代码的可读性和维护性。同时，应该尽量避免过多的重载方法，以保证代码的简洁性和可读性。

2.面向对象的特征之封装。

这篇文章的前言有点多，下面进入我们的正文部分:

(1)什么是封装？

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过提供的方法来进行访问。

(2)为什么要使用封装？

封装是面向对象编程的重要概念之一，它可以帮助我们实现代码的可维护性和安全性。

首先，封装可以将一个对象的属性和方法隐藏起来，只提供需要的方法和属性的访问。这样可以避免外部直接访问和修改对象的内部状态，从而保证代码的安全性和稳定性。

其次，封装可以使代码更加易于维护和升级。由于封装隐藏了对象的内部状态，所以可以更灵活地修改对象的实现细节而不会影响到外部调用者的代码。这样可以有效降低代码的耦合度，提高代码的可维护性和可扩展性。

最后，封装还可以提高代码的重用性。将对象的行为和状态封装在一起，可以将其作为一个独立的组件对待，被其他模块或者系统复用。这样可以避免重复编写相似的代码，提高代码的复用率和开发效率。

(3)使用封装的方法：

a.修改属性的可见性，将属性私有化。

b.创建公有的setter/getter方法，用于属性的读和写。

c.在setter/getter方法中加入属性控制语句，对属性的合法性进行判断。

如下所示:

Myclass类：

public class MyClass {
    private String name;
    private int age;
    private double score;
    private String sex;
    private String school;

    public MyClass() {

    }

    public MyClass(String name, int age, double score, String sex, String school) {
        this.name = name;
        this.age = age;
        this.score = score;
        this.sex = sex;
        this.school = school;
    }

    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 double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    @Override
    public String toString() {
        return "MyClass{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", score=" + score +
                ", sex='" + sex + '\'' +
                ", school='" + school + '\'' +
                '}';
    }
}

TestMyClass类：

public class TestMyClass {
    public static void main(String[] args) {
        MyClass myClass=new MyClass();
        myClass.setAge(18);
        myClass.setName("王霸天");
        myClass.setSchool("世界第一疯人病院");
        myClass.setScore(66.0);
        myClass.setSex("男");
        System.out.println(myClass.toString());
    }
}

关于封装的知识点到此结束。