初识Java对象 - 润新知

初识Java对象
                                        初始Java对象

本文的概述顺序

1什么是面向对象编程（面向对象编程与面向过程编程的区别）

2类和对象的的关系

3类的定义

4对象的创建

5对象使用的一些细节

       5.1对象在内存中的产生及分布

5.2两个对象使用同一个方法的内存分布情况

        5.3两个应用指向同一个对象

    5.4使用对象作为参数

      5.5使用对象作为返回值

6类的封装性（介绍private 关键字与this关键字）

7构造方法

8标准代码--JavaBean

                       1什么是面向对象编程（面向对象编程与面向过程编程的区别）

生活中举例

1面向对象编程：当你要实现一个功能的时候，不关心具体步骤，而是找一个已经具备该功能的人来帮我做

2面向过程编程：当你要实现一个功能的时候，每一个环节都亲历亲为，详细处理每一个细节

就拿我们生活中最为常见的点外卖举例

面向过程编程：我-》打车-》去店里-》下单-》等待-》取单-》打车回家

面向外卖编程：我-》点外卖

即红色的部分都由外卖小哥这一个对象来解决，不需要我参与，这就是面向对象编程的好处

java代码举例（以输出数组内容举例）
```
 1 public class Test {
 2     public static void main(String[] args) {
 3         int[] arr={1,2,3,4,5} ;
 4         //面向过程
 5         System.out.println("面向过程编程");
 6         System.out.print('[');
 7         for (int i = 0; i < arr.length; i++) {
 8            if(i!=0){
 9                System.out.print(","+arr[i]);
10            }
11            else{
12                System.out.print(arr[i]);
13            }
14         }
15         System.out.println("]");
16         //面向过程
17         System.out.println("====================");
18         System.out.println("面向对象编程");
19         System.out.println(Arrays.toString(arr));
20 
21     }
22 }
```
结果可见，两者的输出结果是相同的。但是使用面向对象编程大大的方便了我们编写代码

面向对象编程思想的好处：将复杂的事情简单化，把我们从执行者变成了指挥者

面向对象有四大基本特征：抽象，封装，多态，继承，我后面会撰写文章概述，在本章中我会先介绍封装

2类和对象的的关系

什么是类？

类：是一组相关属性和行为的集合。可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该

类事物。

现实中，描述一类事物：

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

什么是对象？

对象：是一类事物的具体体现。对象是类的一个实例，必然具备该类事物的属性和行为。

我们拿最近刷爆抖音的爱心鸡蛋早餐来举例子（单身狗自己烤），这个烤鸡蛋的模板就是一个类，而使用这个烤鸡蛋爱心

模具烤出来的一个个心型的爱心鸡蛋就是一个个对象

由此我们可以总结出对象与类的对应关系

类是对一类事务的描述，是抽象的

对象是具体的实例，是具体的（即一个个心型烤鸡蛋）

类是对象的模板，对象的类的实例

3类的定义

比如定义一个鸡蛋类

首先我们来复习一下前面提到的属性和行为

属性：就是该事物的状态信息。

行为：就是该事物能够做什么。

这个类的属性就是 size,weight 方法就是：cook() eat();
```
 1 public class egg {
 2     int size;//大小
 3     int weight;//重量
 4     //烤鸡蛋方法
 5     public void cook(){
 6         System.out.println("烤鸡蛋啦！！！");
 7     }
 8     //吃鸡蛋方法
 9     public  void  eat(){
10         System.out.println("吃鸡蛋啦！！！");
11     }
12 
13 }
```
4对象的创建

创建对象的格式

类名对象名=new 类名（）；
```
egg eggone = new egg();
```
对象方法与属性的调用

对象名.属性值

对象名.方法名
```
public class Main {
    public static void main(String[] args) {
        egg eggone = new egg();
        eggone.size=100;
        eggone.weight=100;
        eggone.cook();
        eggone.eat();

    }
}
```
5对象使用的一些细节

仍然以之前的egg对象来举例
```
public class egg {
    int size;//大小
    int weight;//重量
    //烤鸡蛋方法
    public void cook(){
        System.out.println("烤鸡蛋啦！！！");
    }
    //吃鸡蛋方法
    public  void  eat(){
        System.out.println("吃鸡蛋啦！！！");
    }

}
```
```
ublic class Main {
    public static void main(String[] args) {
        egg eggone = new egg();
        eggone.size=100;
        eggone.weight=100;
        eggone.cook();
        eggone.eat();

    }
}
```
5.1对象在内存中的产生及分布

需要注意的点

堆中new对象中的方法存储的是地址值，通过地址值去找方法，有效的节省了空间
接下来将语句的执行步骤及出栈入栈的相关知识

对象要调用方法首先要通过图中黑色的线找到该对象在堆中的位置，再通过堆中存储的地址值找到方法区中存储的

方法，然后将该方法入栈执行

图中的1，2，3表示栈中的方法的出栈顺序，即在栈顶的方法先出栈（学过数据结构的同学理解起来应该会很简单）

5.2两个对象使用同一个方法的内存分布情况



        5.3两个引用指向同一个对象

     两个引用指向同一个对象与数组的情况基本相似，这里不做赘述，需要的可以去看完数组的那篇文章

    链接点击链接跳转

    5.4使用对象作为参数
```
package cn.itcast;

public class Main {
    public static void main(String[] args) {
        egg eggone = new egg();
        eggone.size=100;
        eggone.weight=100;
        print(eggone);
    }
    public  static void print(egg eggone){
        System.out.println("鸡蛋大小是："+eggone.size);
        System.out.println("鸡蛋的重量是："+eggone.weight);
    }

}
```
结果

5.5使用对象作为返回值
```
public class Main {
    public static void main(String[] args) {
        egg eggone=createegg();
        System.out.println("鸡蛋的大小："+eggone.size);
        System.out.println("鸡蛋的重量："+eggone.weight);
    }
    public  static egg createegg(){
        egg eggone=new egg();
        eggone.size=100;
        eggone.weight=100;
        return eggone;
    }

}
```
结果

6类的封装性（介绍private 关键字与this关键字）

什么是类的封装性？

就是把该隐藏的隐藏起来，把该暴露的暴露出来。

封装的优越性
1. 封装可以隐藏实现的细节
2. 让使用者只能通过实现写好的访问方法来访问这些字段，这样一来我们只需要在这些方法中增加逻辑控制，限制对数据的不合理访问、
3. 方便数据检查，有利于于保护对象信息的完整性
4. 便于修改，提高代码的可维护性
private关键字的介绍

1. private是一个权限修饰符，是java中的最小权限修饰符

2. 可以修饰成员方法与成变量

3. 被private修饰的成员方法与变量只可以在本类中被访问

使用private方法修饰的变量需要添加该变量的set和get方法

下面用一段代码来演示，在代码中我们加入了对age参数的限制，这也是使用封装的一大原因所在
```
package cn.itcast;
class Main2{
    public static void main(String[] args) {
        Person person = new Person();
        Person person1 = new Person();
        person.setAge(100);
        person.setName("zhangsan");
        System.out.println(person.getName());
        System.out.println(person.getAge());
        person1.setName("lisi");
        person1.setAge(-10);
        System.out.println(person1.getName());
        System.out.println(person1.getAge());
    }
        }

class Person {
    private  int age;
    private String name;

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age<0){
            System.out.println("年龄不合法");
        }
        else{
            this.age = age;
        }

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```
this关键字介绍

为什么使用this关键字？为了解决方法的重名问题，如图标红色的变量名，当传入的变量名与成员变量冲突时使用
```
 1 class Person {
 2     private  int age;
 3     private String name;
 4 
 5     public int getAge() {
 6         return age;
 7     }
 8     public void setAge(int age) {
 9         if (age<0){
10             System.out.println("年龄不合法");
11         }
12         else{
13             this.age = age;
14         }
15 
16     }
17 
18     public String getName() {
19         return name;
20     }
21 
22     public void setName(String name) {
23         this.name = name;
24     }
25 }
```
this的含义

表示当前所在类的当前对象的引用，即调用该方法的对象

this使用格式

this.变量名

7构造方法

当一个对象被创建时调用构造方法初始化该对象

这里肯定有读者就会问我之前创建的类也没有写啥构造方法啊！！

这是因为java给我们默认提供了一个无参数的构造方法但是一旦你自己自定义了一个构造方法，java

提供的默认无参构造方法就会失效

构造方法的定义格式

修饰符构造方法名(参数列表){

// 方法体

}

下面我们用一段代码来带领大家开启构造方法
```
package cn.itcast;
class Main2{
    public static void main(String[] args) {
        Person person = new Person(18, "姚明");
        System.out.println("名字："+person.getName());
        System.out.println("年龄："+person.getAge());
    }
        }

class Person {
    private  int age;
    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age<0){
            System.out.println("年龄不合法");
        }
        else{
            this.age = age;
        }

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```
结果

由结果可见我们在初始化的时候已经给了该对象的属性赋值了，这就是构造方法的好处，构造方法中的参数由自己自行决定

注意事项

当你自己定义了构造方法之后，系统默认的构造方法自动失效，如果此时你还要使用无参构造，可以自行定义无参的构造

8JavaBean

什么是JavaBean?

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无

参数的构造方法，提供用来操作成员变量的 set 和 get 方法。

下面我来写一段标准的符合JavaBean规范的代码
```
class Person {
    private  int age;
    private String name;
    public Person() {
    }
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age<0){
            System.out.println("年龄不合法");
        }
        else{
            this.age = age;
        }

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}
```
以上就是我觉得有关java对象的一些基本的知识点，如果由错误还请大家批评指正

转载请标明链接

博客：https://www.cnblogs.com/pjhaymy
相关阅读:
热爱工作发财机会大增（这里不是选择软件还是硬件的问题，是自己的性格和追求的问题）——当你的老板不如你懂行的时候，还赚的盆满钵满的时候，你就可以考虑独立了 good
TaintDroid：智能手机监控实时隐私信息流跟踪系统（三）
Delphi读取文件属性
 创业者该如何看待腾讯的“跟进”？
IBM总裁郭士纳总结的四类人
 迅雷程浩：企业外包服务，下一个大的风口？(2B业务一定要懂销售和营销的人，这点和2C 不一样）
dddd
android:minSdkVersion 之我见
 dddd
请人不怕啦
原文地址：https://www.cnblogs.com/pjhaymy/p/13251599.html