java入门（类与对象）

面向对象

面向对象思想总结:
    1.面向过程:当要实现一个功能时,需要亲力亲为,处理每个细节
    2.面向对象:当要实现一个功能时,不关心具体的实现步骤,只关心结果,找一个具有该功能的类,帮我们做事
    3.面向对象的思想
        (1)面向对象是基于面向过程的编程思想
        (2)面向过程:强调的是每一个功能的步骤
        (3)面向对象:强调的是对象,然后由对象去调用功能
    4.特点
        (1)是一种更符合我们思考习惯的思想
        (2)可以将复杂的事情简单化
        (3)角色发生了转换,将我们从执行者变成了指挥者

面向对象思想的举例

package com.demo.面向对象思想的举例;
/*
* 需求：将数组{10，20，30}，遍历打印， [10, 20, 30]
* */
public class demo {
    public static void main(String[] args) {
        int[] arr = {10,20,30};
        test1(arr);
        System.out.println("======");
        test2(arr);
    }

//    面向过程
    public static void test1(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length -1) {
                System.out.println(arr[i] + "]");
            } else {
                System.out.print(arr[i] + ", ");
            }
        }
    }

//    面向对象
    public static void test2(int[] arr) {
        Arrays a = new Arrays();
        a.test1(arr);
    }
}

package com.demo.面向对象思想的举例;

public class Arrays {
    public void test1(int[] arr) {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++) {
            if (i == arr.length - 1) {
                System.out.println(arr[i] + "]");
            }else {
                System.out.print(arr[i] + ", ");
            }
        }
    }
}

类和对象的关系

1. 类是什么：类就是属性和行为的集合一种抽象的描述，是一个模板。
2. 对象是什么：就是一类事物的具体实例。
3. 类和对象的关系： 通过类可以创建对象

类的定义

程序语言就是用来描述生活中的事物

【类的定义格式】

public class 类名{
  //属性
  //行为
}

在Java中属性和行为有专门的称呼：

• 属性–>成员变量：类中方法外定义的变量

  方法中定义的变量为局部变量，方法外类中定义的变量就是成员变量

• 行为–>成员方法：把之前定义的方法，去掉static，就是成员方法

【举例】在Java中描述人类

public class People{
  //属性–>成员变量
  String name;
  String sex;
  int age;
  //行为–>成员方法
  
  public void eat(){
    System.out.println("吃饭");
  }
  
  public void study(){
     System.out.println("学习");
  }
}

对象的创建及其使用

类使用的三个步骤：

1. 导包：就为为了找到这个类
   • 如果使用的类和本类在同一个包下，可以不用导包
   • 如果这个类在java.lang包下，也可以不用导包。
2. 创建对象
3. 根据对象调用成员

/*
创建对象的格式:
类名 对象名 = new 类名();

如何使用对象[如何通过对象调用成员(成员方法,成员变量")]
格式:  对象名.成员     [点:就是调用访问的意思]

 */

public class DemoPeople {
    public static void main(String[] args) {
        Random rd = new Random();
        //创建一个People类的对象
        People p1 = new People(); //p1对象就是People类的具体实例
        // 访问成员
        //调用成员方法
        p1.eat();
        p1.study();

        //访问成员变量
        //赋值给成员变量
        p1.name = "张三";
        p1.age = 20;

        //获取成员变量的值
        System.out.println(p1.name);
        System.out.println(p1.age);

        System.out.println("====");
        People p2 = new People();
        p2.eat();
        p2.study();
        p2.name = "李四";
        p2.age = 21;
        System.out.println(p2.name+":"+p2.age);
    }
}

public class People {
    //属性[成员变量]
    String name;
    int age;
    //行为[成员方法]
    public void study() {
        System.out.println("学习Java");
    }

    public void eat() {
        System.out.println("吃饭");
    }
}

成员变量变量的默认值

创建对象后，成员变量的初始值。

成员变量的类型，也可以是任意类型。初始化值和数组一样

• 基本数据类型

  • 整数类型 0
  • 浮点数类型 0.0
  • 布尔类型 false
  • 字符类型 0对应的字符 '\u0000'

• 引用数据类型： null

  电脑类
  public class Computer {
      String color;
      int rom;
      double price;
      char foo;
      boolean sh;
  }
  
  测试
  public class Demo01 {
      public static void main(String[] args) {
          Computer c = new Computer();
          System.out.println(c.color); //String null
          System.out.println(c.rom); //int 0
          System.out.println(c.price); //double 0.0
          System.out.println(c.foo+0); //char 0对应的字符
          System.out.println(c.sh); //boolean false
      }
  }
  

  对象的内存分析

  内存：
      1.栈     运行方法
      2.堆     存放new出来的数据，数组、对象
      3.方法区  存储.class文件
      
  1、一个类要使用运行，必须先将.class文件加载到方法区
  2、对象创建后，和数组一样，也在堆中，也有一个地址赋值给对象名，通过对象名可以访问成员
  3、堆中的对象创建是根据方法区中类的模板创建的
  

两个对象使用同一个方法的内存图

两个变量指向同一个对象的特点

/*
两个变量指向同一个对象的特点
如果其中一个变量的属性值发生变化,另外一个变量对应的属性值,也会跟着变化.

因为这两个变量,就是同一个对象.

 */
public class Demo01 {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        Phone p2 = p1;
        System.out.println("p1 = " + p1); //Phone@58ceff1
        System.out.println("p2 = " + p2); //Phone@58ceff1
        //p1和p2表示的是同一个对象

        p1.brand = "小米";
        System.out.println(p2.brand); // 小米, p1和p2表示的是同一个对象
    }
}

使用对象类型作为方法的参数及返回值

/*
对象类型当作方法的参数时,调用方法,实参会赋值给形参,地址的传递.
对象类型当作方法的返回值类型时,执行return语句时,返回的就是对象的地址
 */
public class Demo01 {
    public static void main(String[] args) {
        Phone p1 = new Phone();
        p1.brand = "小米";
        showPhone(p1); // Phone p = p1   实参的地址赋值给形参

        Phone p2 = getPhone();
        System.out.println("p2.brand = " + p2.brand);//VIVO

    }
    //对象类型当作方法参数类型
    public static void showPhone(Phone p) { //调用方法,实参必须为Phone对象
        System.out.println(p.brand + "-" + p.color + "-" + p.price);
    }
    //对象类型当作方法返回值类型
    public static Phone getPhone() { //return返回的结果,必须是Phone
        Phone p = new Phone();
        p.brand = "VIVO";
        return p;
    }
}

成员变量和局部变量的区别

成员变量：类中方法外的变量

局部变量：方法中的变量