类对象封装-阿里云开发者社区

类对象封装

2023-10-25 82

版权

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

简介： 类对象封装

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

----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. 不能在静态方法中访问任何非静态成员变量

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

类对象封装

一:类对象

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

2):如何实例化对象

3):this关键字的使用

this的特性:

4):构造方法

5):默认初始化

二:封装

1):封装的概念:

2):static关键字

热门文章

最新文章

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

类 对象 封装

一:类 对象

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

2):如何实例化对象

3):this关键字的使用

this的特性:

4):构造方法

5):默认初始化

二:封装

1):封装的概念:

2):static关键字

热门文章

最新文章

相关电子书

相关实验场景

类对象封装

一:类对象