类 对象 封装

简介: 类 对象 封装


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

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

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

相关文章
|
7月前
|
C++
c++类&对象
c++类&对象
52 3
|
7月前
|
存储 Java 编译器
类、对象、方法
摘要: 本文介绍了面向对象编程的概念,以京东购买手机为例,展示了如何通过分类和参数选择商品,强调软件与现实生活的对应关系。柯南三步走揭示了京东如何通过搜索和筛选帮助用户找到所需商品,而这一切背后的编程思想即为面向对象编程。面向对象编程涉及抽象、自定义类型和实例化对象等步骤,其中自定义类型(如Java中的类)用于封装现实生活中的复杂数据。文章还讲解了如何定义类、实例化对象以及访问权限修饰符、构造方法、this关键字、方法的使用,强调了方法参数和返回值在不同数据类型上的处理差异。整个讨论旨在阐明Java中面向对象编程的基本原理和实践应用。
50 5
|
7月前
|
存储 C++
C++对象和类
C++对象和类
40 0
|
7月前
|
存储 C#
C#对象和类
C#对象和类
45 0
|
7月前
|
存储 Java 编译器
第 4 章 对象与类(下)
第 4 章 对象与类
140 0
|
7月前
|
存储 算法 Java
第 4 章 对象与类(上)
第 4 章 对象与类
83 0
|
编译器 C语言 C++
C++ 类 & 对象
【摘要】 C++ 类 & 对象C++ 在 C 语言的基础上增加了面向对象编程,C++ 支持面向对象程序设计。类是 C++ 的核心特性,通常被称为用户定义的类型。类用于指定对象的形式,它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。C++ 类定义定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,也就是...
|
Java
Java面向对象(1)--对象的创建使用类的实例化
Java面向对象(1)--对象的创建使用类的实例化
86 1
|
安全 Java 数据安全/隐私保护