携手创作，共同成长！这是我参与「掘金日新计划 · 8 月更文挑战」的第9天 类和对象（上）

小魏爱吃鱿鱼虾
46 阅读4分钟

​

好久不见啊，最近由于某些事情断更了，今天开始我们继续哈。

 

今天为大家带来类和对象的其中一部分内容

Contents

I 面向对象

 🚀1.面向对象与面向过程定义与区分

🚀2.类的定义

🚀3.类产生对象（对象的实例化）

🐱‍🏍a.分配内存

🐱‍🏍b.分配合适的构造方法

🐱‍🚀4.this引用

🐱‍🚀5.对成员变量的赋值

II面向对象的思想

✨1.封装的定义

✨2.包的定义

​编辑

🎇面向对象和面向过程

我们在接触C语言开始其实一直在学习的就是面向过程，在Java和C++中我们接触的是面向对象

面向对象的语言简称OOP

用生活中的例子来理解：

洗衣服的时候：

人将衣服放到盆里，倒水，倒洗衣液，揉搓，二次清洗，晾衣服这样的一系列过程称为面向过程

也就是说人亲自干这些事情

将衣服倒进洗衣机后，加入洗衣液，人就不用管了，剩下的交给洗衣机就好，人不用知道洗衣机是咋洗衣服的，这就叫做面向对象，也就是多个对象之间的交互。

✨类

我们怎样定义一个类

首先，类名要用大驼峰

在一个类里面，有字段和方法，字段也叫成员变量或属性，方法又叫做成员行为，下面来看一段代码

class   Rabbit{
    //定义成员变量
    public     String  name;
    public     String  gender;
    public     String  color;
    public     String  weight;
    public     String  age;



    //定义成员方法
    public void   swag(){
        System.out.println(name+"摇尾巴");

    }
    public void  eat(){
        System.out.println(name+"吃青草");
    }
}

就像这段代码里面，这就是一个类

有了类，就要通过类产生对象，这一过程又叫做对象的实例化，做法是通过new关键字来创建对象，继续用以上代码来看

public class TestDemo {
    public static void main(String[] args) {
        Rabbit rabbit1=new Rabbit();
        Rabbit rabbit2=new Rabbit();
        Rabbit rabbit3=new Rabbit();


        //对成员变量赋值
        rabbit1.name="小白";
        rabbit1.gender="雄性";
        rabbit1.color="白色";
        rabbit1.age="2岁";
        rabbit2.name="小白";
        rabbit2.gender="雄性";
        rabbit2.color="白色";
        rabbit2.age="2岁";
        rabbit3.name="小白";
        rabbit3.gender="雄性";
        rabbit3.color="白色";
        rabbit3.age="2岁";
        


    }

}

通过以上代码段我可以发现一个问题，通过new可以实例化多个对象

public class TestDemo {
    public static void main(String[] args) {
        Rabbit rabbit=new Rabbit();
       /* Rabbit rabbit2=new Rabbit();
        Rabbit rabbit3=new Rabbit();
        rabbit1.gender;*/
        System.out.println(rabbit.name);
        System.out.println(rabbit.age);
        System.out.println(rabbit.color);

我们可以发现，在未进行特别注意赋值时，成员变量有自己的默认值，其中我们要注意引用类型的默认值​编辑

​编辑

public class TestDemo {
    public static void main(String[] args) {
        Rabbit rabbit=new Rabbit();
       /* Rabbit rabbit2=new Rabbit();
        Rabbit rabbit3=new Rabbit();
        rabbit1.gender;*/
        System.out.println(rabbit.name);
        System.out.println(rabbit.age);
        System.out.println(rabbit.color);
        System.out.println(rabbit.flag);
        System.out.println("===============");





        //对成员变量赋值
        rabbit.name="小白";
        rabbit.gender="雄性";
        rabbit.color="白色";
        rabbit.show();
        rabbit.eat();
        rabbit.swag();

​编辑

 调用了成员方法，看上面的代码

在后期学习的时候建议一个Java文件，一个类

🎉现在让我们来看一看构造方法，为哈要看呢，因为在new一个对象时，一定会使用构造，通过构造，才能实例化对象

现在上代码

class Dog{
    public int age;
    public String name;
    public  String  color;

    public void bark(){
        System.out.println(name+"叫");}
        public void swag(){
            System.out.println(name+"摇尾巴");}
            public void show(){
                System.out.println("姓名"+name+"年龄"+age+"颜色"+color);
            }
    public  Dog(){
        System.out.println("不带参数的构造方法");
    }

    public Dog(int age, String name) {
        this.age = age;
        this.name = name;
        System.out.println("调用带两个参数的构造方法");
    }
    public Dog(String name, String color) {
        this.name = name;
        this.color = color;
        System.out.println("调用带两个参数的构造方法");
    }

    public Dog(int age, String name, String color) {
        this.age = age;
        this.name = name;
        this.color = color;
        System.out.println("调用带3个参数的构造方法");
    }
}





public class TestDemo {
    public static void main(String[] args) {
        Dog  dog=new Dog();
        dog.name="豆豆";
        dog.age=2;
        dog.color="灰色";
        dog.show();
        dog.bark();
        dog.swag();

    }
}

如上述代码，看一眼

class Date {
    public int year;
    public int month;
    public int day;

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        Date date = new Date();
        date.printDate();
    }
}

这段代码没有任何构造方法，编译器会自动生成不带参数的构造方法，如果自己写了，编译器就不会提供了

class Date {
    public int year;
    public int month;
    public int day;
    public  Date(){
        this.year=2022;
        this.month=6;
        this.day=12;
        this.printDate();
        System.out.println("不带参数的构造方法");
    }

    public Date(int year, int month, int day) {
        this.year = 2022;
        this.month = 3;
        this.day = 15;
        System.out.println("带三个参数的构造方法");
    }

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        Date date1 = new Date();
        date1.printDate();
        Date date2 = new Date(1998,5,8);
        date2.printDate();

    }
}


class Date {
    public int year;
    public int month;
    public int day;
    public  Date(){
        /*this.year=2022;
        this.month=6;
        this.day=12;
        this.printDate();
        System.out.println("不带参数的构造方法");*/
        this(1998,5,8);//代表调用另一个带有三个参数的成员方法
    }

    public Date(int year, int month, int day) {
        this.year = 2022;
        this.month = 3;
        this.day = 15;
        System.out.println("带三个参数的构造方法");
    }

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        Date date1 = new Date();
        date1.printDate();
        Date date2 = new Date(1998,5,8);
        date2.printDate();

    }
}

this引用所需要注意的点：

1.this引用代表当前对象的引用

2.this引用必须放在成员方法里面

3.this引用在代表调用另一个构造方法时，必须放在成员方法的第一行

4.this引用不能形成环的调用

🎈封装

封装代表面向对象的三大重要思想之一

啥叫封装呢，通俗一点解释也就是说一部手机，只漏出接口，实际内部的实现并不让用户发现

在Java语言中，也就是说，写一个公开的接口，让用户使用，不让用户知道这个具体是咋实现的

下面上代码

 class Date {
    public int year;
    private int month;
    public int day;
    public  Date(){
        /*this.year=2022;
        this.month=6;
        this.day=12;
        this.printDate();
        System.out.println("不带参数的构造方法");*/
        this(1998,5,8);//代表调用另一个带有三个参数的成员方法
    }

    public Date(int year, int month, int day) {
        this.year = 2022;
        this.month = 3;
        this.day = 15;
        System.out.println("带三个参数的构造方法");
    }

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        Date date1 = new Date();
        date1.printDate();
        Date date2 = new Date(1998,5,6);
        date2.printDate();

    }
}

在将month加上private以后，打印结果如下​编辑

不能打印出1998 5.18，因为private只能在当前类中使用，而default只能在同一个包中使用

代码实现封装，提供接口实现month的使用

 public class Date {
    public int year;
    private int month;
    public int day;
    public  Date(){
        /*this.year=2022;
        this.month=6;
        this.day=12;
        this.printDate();
        System.out.println("不带参数的构造方法");*/
        this(1998,5,8);//代表调用另一个带有三个参数的成员方法
    }
    public  void  setMonth(int month){
        this.month=month;
    }
    public int getMonth(){
        return month;
    }


    public Date(int year, int month, int day) {
        this.year =year;
        this.month =month;
        this.day =day;
        System.out.println("带三个参数的构造方法");
    }

    public void printDate() {
        System.out.println(year + "-" + month + "-" + day);
    }

    public static void main(String[] args) {
        Date   date=new  Date();
        date.setMonth(5);
        System.out.println("获取当前的月份"+date.getMonth());
        date.printDate();

    }

    /*public static void main1(String[] args) {
        Date date1 = new Date();
        date1.printDate();
        Date date2 = new Date(1998,5,6);
        date2.printDate();

    }*/
}

如果所有成员变量都带了private，那就点击generate，点击constructer，点击getter  and   setter;

package com.bit.www;//声明当前文件是在哪个包底下

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: WHY
 * Date: 2022-06-13
 * Time: 9:45
 */
public class TestDemo {

}

这就是包的概念

今天的讲解到此结束，我们下期再见！

​

今天的分享就到这里，我们下期再见！🐹🐹🐹

avatar
文章
阅读
粉丝