AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

类 对象 封装

2023-10-25 71
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 类 对象 封装

                                坚信自己，人生往往柳暗花明。

                                                                                             ----DJ懒洋洋

一:类 对象

  类（class）和对象 (object)是两种以计算机为载体的计算机语言的合称。 对象是对客观事物的抽象，类是对对象的抽象。 类是一种抽象的数据类型。 它们的关系是，对象是类的实例，类是对象的模板。在java中，所有的一切皆可对象，即对象的属性和行为由类进行组织，类产生对象。

关系图如图所示:

 1):那么，java语言当中该如何创建类呢?

上图是对类的定义做个总结，接下来我们来看代码: 

//ClassName--->即类型，遵循大驼峰的命名方式
class ClassName{
    //fields---->字段:描述成员属性
    //method--->方法:描述成员行为
}
//以学生类为例
class Student{
   public String name;
   public int age;
   public  void eat(){
   System.out.printli("好好学习，天天向上")
}
}

2):如何实例化对象

 以学生为例，实例化对象，关键字:new,我们通过一张图来看一下。

代码实现:

class test1{
    public static void main(String[] args) {
        Student student =new Student();
        Student student1=new Student();
        System.out.println(student);
        System.out.println(student1);
    }
}

如何调用创建对象的方法呢?进行解应用，关键符号:.

student.study();

运行结果:

3):this关键字的使用

 this:代表当前对象进行使用。我们来看如下代码，看看会发生哪些错误:

注意： this(...)必须是构造方法中第一条语句

class TestDate{
    //成员属性
    public int day;
    public int month;
    public int year;
    //成员行为
    public void setDate(int day,int month,int year){
        //此时参数和成员变量的命名相同
        day=day;
        month=month;
        year=year;
    }
    public void printDate(){
        System.out.println("年:"+year+"月:"+month+"日:"+day);
    }
}
class test2{
    public static void main(String[] args) {
        TestDate date=new TestDate();
        date.setDate(10,10,2022);
        date.printDate();
    }
}
//从代码来看，是要将年月日进行打印。即打印的为2022年10月10日

代码运行如下:

结果并不如我们预期那样，会打印2022年10月10日，而是0年0月0日，在java当中，当我们创建类时，成员行为中，局部变量高于成员变量，即在setDate这个成员行为中，局部变量year,month,day是在给自己赋值，等到这个成员行为结束后，局部变量的值被释放掉，而成员变量自始至终都没有赋值，即还是0.

那么，我们加入this关键字，能不能解决这一问题呢? 

class TestDate{
    //成员属性
    public int day;
    public int month;
    public int year;
    //成员行为
    public void setDate(int day,int month,int year){
        //此时参数和成员变量的命名相同
         this.day=day;
         this.month=month;
         this.year=year;
    }
    public void printDate(){
        System.out.println("年:"+year+"月:"+month+"日:"+day);
    }
}
class test2{
    public static void main(String[] args) {
        TestDate date=new TestDate();
        date.setDate(10,10,2022);
        date.printDate();
    }
}

运行效果:

可见，this关键字可以解决这一问题，即通过this关键字可以告诉编译器当前是哪个对象在调用成员属性和成员行为。

this的特性:

4):构造方法

  作用:对对象的各个属性进行初始化。

//如何进行构造 权限修饰符 +类名 (参数列表){}
public class Animal {
    public String name;
    public int age;
    public Animal(){
        //空参构造
    }
    public  Animal(String name,int age){
        this.name=name;
        this.age=age;
    }
    public void print(){
        System.out.println("动物的姓名:"+this.name+"动物的年龄:"+this.age);
    }
}
class test{
    public static void main(String[] args) {
        Animal animal=new Animal();//空参构造的实例化
        Animal animal1=new Animal("小狗",18);
        animal.print();
        animal1.print();
    }
}

  可见，在空参构造时，所有的成员属性均被初始化，即String类型的引用变量赋值为null，int类型的为0,在实参构造中，我们对成员变量进行了赋值，此时，所对应的各个属性均有了我们想要赋的值。同时，空参构造和实参构造属于java里面的方法重载。

方法重载:

   1:方法名相同

   2:参数列表不同(参数类型不同，参数列表不同)

   3:返回值类型不做要求。

此外，空参构造是默认的，即不写也可以完成空参构造，但当写实参构造时，空参构造就不是默认的，需要我们进行手动添加。

5):默认初始化

  在java中，如果在main函数中，变量不进行赋值，会报错，但是，在类中，如果我们不对成员变量进行赋值，那么，会有默认对应的初始化值，如下图所示:

二:封装

1):封装的概念:

  在java当中，如果自己实现的内部细节不想被别人看见，我们就可以进行封装，即套壳屏蔽细节。将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

关键字:private,即私有化成员变量。在此之前，我们先了解访问权限修饰符。每个修饰符对应的使用权限。

在封装中，我们使用的是private关键字，即别人不能看见成员属性和成员行为的细节，即只能在同一包中的同一类进行使用。那么，如果，我们进行了封装，想要用，怎么办?这时候，我们可以用public访问权限修饰符，对其私有化的成员变量进行赋值和访问。

代码如下:

public class Person {
    private String name;
    private int age;
    private String id;
    public Person() {
    }
    public Person(String name, int age, String id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
    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 String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
}
class test3{
    public static void main(String[] args) {
       Person person=new Person();
       person.setName("李华");
       person.setAge(18);
       person.setId("1");
        System.out.println("姓名:"+person.getName()+" 年龄:"+person.getAge()+" 编号"+person.getId());
    }
}

运行结果:

2):static关键字

static关键字是java中较为重要的关键字，即可以修饰成员变量和成员方法。

static修饰成员变量:---->假设:我们创建了三个学生对象，而三个学生恰好在一个教室里，这时候我们就可以使用static关键字来减少代码的使用。

代码如下: 

public class Student {
    private String name;
    private int age;
    private int id;
    public static  String classRoom="301";
    public Student() {
    }
    public Student(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public Student setName(String name) {
        this.name = name;
        return this;
    }
    public int getAge() {
        return age;
    }
    public Student setAge(int age) {
        this.age = age;
        return this;
    }
    public int getId() {
        return id;
    }
    public Student setId(int id) {
        this.id = id;
        return this;
    }
    public static String getClassRoom() {
        return classRoom;
    }
    public static void setClassRoom(String classRoom) {
        Student.classRoom = classRoom;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", id=" + id +
                '}';
    }
}
class test4{
    public static void main(String[] args) {
        Student student=new Student("小李",18,1);
        System.out.println(student);
        Student student1=new Student("小华",19,2);
        System.out.println(student1);
        Student student2=new Student("小明",18,3);
        System.out.println(student2);
        //调用类里面的静态成员变量
        System.out.println(Student.classRoom);
    }
}

由上述代码可知，静态成员变量需要用类名.静态成员变量来使用。Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的，因此，成员方法也需要通过类名.成员方法来使用。

【静态方法特性】

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量

欢迎各位大佬前来批评指正。谢谢大家

文章标签：
Java
编译器
DJJ懒洋洋
目录
相关文章
白守苍间
|
5月前
|
C++
c++类&对象
c++类&对象
白守苍间
46 3
雾面
|
5月前
|
存储 Java 编译器
类、对象、方法
摘要： 本文介绍了面向对象编程的概念，以京东购买手机为例，展示了如何通过分类和参数选择商品，强调软件与现实生活的对应关系。柯南三步走揭示了京东如何通过搜索和筛选帮助用户找到所需商品，而这一切背后的编程思想即为面向对象编程。面向对象编程涉及抽象、自定义类型和实例化对象等步骤，其中自定义类型（如Java中的类）用于封装现实生活中的复杂数据。文章还讲解了如何定义类、实例化对象以及访问权限修饰符、构造方法、this关键字、方法的使用，强调了方法参数和返回值在不同数据类型上的处理差异。整个讨论旨在阐明Java中面向对象编程的基本原理和实践应用。
雾面
39 5
a15034260562-24955
|
5月前
深入类的方法
深入类的方法
a15034260562-24955
31 0
缪斯云
|
5月前
|
存储 C#
C#对象和类
C#对象和类
缪斯云
38 0
缪斯云
|
5月前
|
存储 C++
C++对象和类
C++对象和类
缪斯云
31 0
码农日常
|
5月前
|
存储 Java 编译器
第 4 章 对象与类（下）
第 4 章 对象与类
码农日常
127 0
码农日常
|
5月前
|
存储 算法 Java
第 4 章 对象与类（上）
第 4 章 对象与类
码农日常
76 0
游客clorgv6rwfov6
|
编译器 C语言 C++
C++ 类 & 对象
【摘要】 C++ 类 & 对象C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。C++ 类定义定义一个类，本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据，但它定义了类的名称意味着什么，也就是...
游客clorgv6rwfov6
79 0
灬爱码士灬
类和“对象“
类和“对象“
灬爱码士灬
49 0
懒羊羊.java
|
安全 Java 数据安全/隐私保护
深入理解封装与继承
体会OOP的特性
懒羊羊.java
116 0
深入理解封装与继承