类和对象

最新推荐文章于 2024-07-12 16:26:30 发布

乒乒乓

最新推荐文章于 2024-07-12 16:26:30 发布

阅读量71

点赞数

文章标签： java 类封装

本文链接：https://blog.csdn.net/weixin_41817394/article/details/109136934

版权

一、初步认识

C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。

JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

面向过程注重的是过程，在整个过程中所涉及的行为,就是功能。

面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将-个个功能实现连接起来。

面向过程: 1 把冰箱打开2.把大象放入3.冰箱关起来面向对象:打开冰箱，储存，关闭都是对冰箱的操作,是冰
箱的行为。冰箱就是一个对象，所以只要操作冰箱所具备的功能，都要定义在冰箱中。

二、类和类的实例化

类就是一类对象的统称。对象就是这一类具体化的一个实例。

类相当于一个模板，对象是由模板产生的样本。一个类，可以产生无数的对象。

声明一个类就是创建一个新的数据类型，而类在Java中属于引用类型，Java 使用关键字class来声明类。我们来
看以下简单的声明一个类。

public class Person {
    public String name;
    public int age;
    public String sex;
    
    public void eat() {

        System.out.println("干饭了！");
    }
    public void sleep() {
        System.out.println("睡觉了！");
    }

}

class为定义类的关键字，，{ }中为类的主体。

类中的元素称为：成员属性。类中的函数称为：成员方法。

注意事项：：

new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建对个实例

三、类的成员

1、字段/属性/成员变量

public class Person {
    public String name;   //字段
    public int age;
    public String sex;
}

使用.访问对象的字段。
"访问" 既包含读也包含写。
对于一个对象的字段如果没有显式设置初始值那么会被设置一个默认的初值。

默认规则是：

对于各种数字类型，默认值为0。
对于boolean类型，默认值是flase。
对于引用类型（String，Array，以及自制类）默认值是null。

null为空引用，表示不引用任何对象，如果对null进行.操作就会引发异常。

2、字段的初始化

*****字段就地初始化****

很多时候我们不希望字段使用默认值，而是需要我们显式设定初值，可以这样写：

public class Person {
    public String name="XiaoMing";
    public int age=18;
    public String sex="男";

    public void eat() {

        System.out.println("干饭了！");
    }
    public void sleep() {
        System.out.println("睡觉了！");
    }

    public static void main(String[] args) {
        Person person=new Person();
        System.out.println(person.name);//结果为：XiaoMing
        System.out.println(person.age);//结果为：18
        System.out.println(person.sex);//结果为：男
    }

}

3、方法，用于描述一个对象的行为。

public class Person {
    public String name="XiaoMing";
    public int age=18;
    public String sex="男";

    public void eat() {

        System.out.println("干饭了！");
    }
    public void sleep() {
        System.out.println("睡觉了！");
    }

    public static void main(String[] args) {
        Person person=new Person();
//        System.out.println(person.name);//结果为：XiaoMing
//        System.out.println(person.age);//结果为：18
//        System.out.println(person.sex);//结果为：男
        person.eat();//干饭了！
        person.sleep();//睡觉了！
    }

}

在方法中还有一种特殊的方法称为构造方法，在实例化对象的时候会自动调用到的方法，方法名字和类名相同，用于对象的初始化；

虽然前面可以就地初始化，但是实际上有些时候可能需要一些更复杂的初始化逻辑，所有使用构造方法吧。

4.static 关键字

修饰属性
修饰方法
代码块
修饰类

修饰属性

public class Person {
    public String name;
    public int age;
    public String sex;
    public static int count;
}

修饰过的属性，和类相关，和具体实例无关，换句话说，同一个类的不同实例共用同一个静态属性。

public class Person {
    public String name;
    public int age;
    public String sex;
    public static int count=0;

    public void eat() {

        System.out.println("干饭了！");
    }
    public void sleep() {
        System.out.println("睡觉了！");
    }

    public static void main(String[] args) {
        Person person=new Person();
        person.count++;
        System.out.println(person.count);
        Person person1=new Person();
        person1.count++;
        System.out.println(person1.count);
        Person.count++;
        System.out.println(Person.count);


    }

}

结果为 1，2，3。 count为所有类共享，且不属于对象。

被static所修饰的属性，在内存中是属于方法区的。

修饰方法

public class Person {
    public String name;
    public int age;
    public String sex;
    public static int count=0;

    public void eat() {

        System.out.println("干饭了！");
    }
    public void sleep() {
        System.out.println("睡觉了！");
    }
    public static void change() {
        count=50;
    }


    public static void main(String[] args) {
        Person.change();
    }

}

静态方法和实例无关，而是和类相关。

静态的方法不能用实例成员。也是因为静态方法不用调用实例所以优先执行。

四、封装

封装的本质就是让类的调用者不必太多的了解实现者，只要知道如何使用类就行了，这样就降低了类使用者的学习成本和使用成本，从而降低了复杂程度。

1.private实现封装

被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用
被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用

直接使用pubilc修饰的代码，致使使用者必须了解Person类内部的实现，才能使用这个类，学习成本比较高。

2.getter和setter方法

public class Person {
    private String name;
    private int age;
    private String sex;

    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 getSex() {
        return sex;
    }

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

    public static int count=0;


    public void eat() {

        System.out.println("干饭了！");
    }
    public void sleep() {
        System.out.println("睡觉了！");
    }
    public static void change() {
        count=50;
    }

此时如果需要获得或者修改这个private属性，就需要使用getter/setter方法。

getName 即为 getter 方法, 表示获取这个成员的值.
setName 即为 setter 方法, 表示设置这个成员的值

五、构造方法

new 执行过程

为对象分配内存空间
调用对象的构造方法

语法规则

1.方法名称必须与类名称相同
2.构造方法没有返回值类型声明
3.每一个类中一定至少存在一个构造方法（没有明确定义，则系统自动生成一个无参构造）

注意事项

如果类中没有提供任何的构造函数，那么编译器会默认生成一个不带有参数的构造函数 .
若类中定义了构造方法，则默认的无参构造将不再生成.
构造方法支持重载. 规则和普通方法的重载一致.

    public Person() {
        this.name="XiaoMing";
        this.age=18;
        this.sex="男";
    }
    public Person(String name,int age,String sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }

六、this关键字

this表示当前对象引用(注意不是当前对象). 可以借助 this 来访问对象的字段和方法。

    public Person() {
        //this调用构造函数
     this("LiNing",15,"男");//这个只能放在第一行
    }
    public Person(String name,int age,String sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }

我们会发现在构造函数的内部，我们可以使用this关键字，构造函数是用来构造对象的，对象还没有构造好，我们就使用了this，那this还代表当前对象吗？当然不是，this代表的是当前对象的引用。

七、认识代码块

字段的初始化方式有：
1. 就地初始化

2. 使用构造方法初始化

3. 使用代码块初始化

根据代码块定义的位置以及关键字，又可以分

普通代码块
构造块
静态块
同步代码块

    public Person() {
        //this调用构造函数
//     this("LiNing",15,"男");//这个只能放在第一行
    }
    public Person(String name,int age,String sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }

    {
        this.name="XiaoHong";
        this.age=18;
        this.sex="男";
    }

且构造块的执行优先于自己定义的无参构造函数可以往里面加入打印语句来测试。

静态代码块

使用static定义的代码块。一般用于初始化静态成员属性。

public class Person {
    public String name;
    private int age;
    private String sex;
    public static int count=0;


    public Person() {
        //this调用构造函数
//     this("LiNing",15,"男");//这个只能放在第一行
    }
    public Person(String name,int age,String sex) {
        this.name=name;
        this.age=age;
        this.sex=sex;
    }

    {
        this.name="XiaoHong";
        this.age=18;
        this.sex="男";
    }
    static {
        count=100;
    }
}

静态代码块不管生成多少个对象，其只会执行一次，且是最先执行的。

静态代码块执行完毕后，实例代码块（构造块）执行，再然后是构造函数执行。

当对静态块和静态的初始化来说，它两定义的量是根据，执行先后去赋值的，，

    static {
        count=100;
    }
    public static int count=0;




    public static int count=0;
    static {
        count=100;
    }

比方说上面这两点。

八、匿名对象

匿名只是表示没有名字的对象。

没有引用的对象称为匿名对象.
匿名对象只能在创建对象时使用.
如果一个对象只是用一次, 后面不需要用了, 可以考虑使用匿名对象.

new Person("LiNing",15,"男").sleep();

九、总结

一个类可以产生无数的对象，类就是模板，对象就是具体的实例。
类中定义的属性，大概分为几类：类属性，对象属性。其中被static所修饰的数据属性称为类属性, static修饰的方法称为类方法，特点是不依赖于对象，我们只需要通过类名就可以调用其属性或者方法。
静态代码块优先实例代码块执行，实例代码块优先构造函数执行。
this关键字代表的是当前对象的引用。并不是当前对象。

乒乒乓

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
类和对象

一、初步认识C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。JAVA是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。面向过程注重的是过程，在整个过程中所涉及的行为,就是功能。面向对象注重的是对象，也就是参与过程所涉及到的主体。是通过逻辑将-个个功能实现连接起来。面向过程: 1 把冰箱打开2.把大象放入3.冰箱关起来面向对象:打开冰箱，储存，关闭都是对冰箱的操作,是冰箱的行为。冰箱就是一个对象，所以只要操作冰箱
复制链接

扫一扫