Day04_Java基础4

数组定义和访问

容器概述

案例分析
现在需要统计某公司员工的工资情况，例如计算平均工资、找到最高工资等。假设该公司有50名员工，用前面所学的知识，程序首先需要声明50个变量来分别记住每位员工的工资，然后在进行操作，这样做会显得很麻烦，而且错误率也会很高。因此我们可以使用容器进行操作。将所有的数据全部存储到一个容器中，统一操作。

容器概念
容器：是将多个数据存储到一起，每个数据称为该容器的元素。
生活中的容器：水杯，衣柜，教室

数组概念

数组概念：数组就是存储数据长度固定的容器，保证多个数据的数据类型要一致。

数组的定义

方式一

格式：

数组存储的数据类型[] 数组名字;

方式二

格式：

数组存储的数据类型 数组名字[];

数组的初始化

方式一数组动态初始化

什么是动态初始化
数组动态初始化就是只给定数组的长度，由系统给出默认初始化值
格式：

 数组存储的数据类型[] 数组名字 = new 数组存储的数据类型[长度];

数组定义格式详解：
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- [] : 表示数组。
- 数组名字：为定义的数组起个变量名，满足标识符规范，可以使用名字操作数组。
- new：关键字，创建数组使用的关键字。
- 数组存储的数据类型：创建的数组容器可以存储什么数据类型。
- [长度]：数组的长度，表示数组容器中可以存储多少个元素。
  注意：数组有定长特性，长度一旦指定，不可更改。
  和水杯道理相同，买了一个2升的水杯，总容量就是2升，不能多也不能少。
举例：

定义可以存储3个整数的数组容器，代码如下：
int[] arr = new int[3];

方式二数组静态初始化

什么是静态初始化
在创建数组时，直接确定数组元素
标准格式：

数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3...};

举例：

定义存储1，2，3，4，5整数的数组容器。
int[] arr = new int[]{1,2,3,4,5};

简化格式：

数据类型[] 数组名 = {元素1,元素2,元素3...};

举例：

定义存储1，2，3，4，5整数的数组容器
int[] arr = {1,2,3,4,5};

3 数组的访问

索引：每一个存储到数组的元素，都会自动的拥有一个编号，从0开始，这个自动编号称为数组索引(index)，可以通过数组的索引访问到数组中的元素。
格式：

数组名[索引]

> 数组的长度属性： 每个数组都具有长度，而且是固定的，Java中赋予了数组的一个属性，可以获取到数组的长度，语句为：数组名.length ，属性length的执行结果是数组的长度，int类型结果。由次可以推断出，数组的最大索引值为数组名.length-1。

public static void main(String[] args) {
    int[] arr = new int[]{1,2,3,4,5};
    //打印数组的属性，输出结果是5
    System.out.println(arr.length);
}

索引访问数组中的元素：
- 数组名[索引]=数值，为数组中的元素赋值
- 变量=数组名[索引]，获取出数组中的元素

public static void main(String[] args) {
    //定义存储int类型数组，赋值元素1，2，3，4，5
    int[] arr = {1,2,3,4,5};
    //为0索引元素赋值为6
    arr[0] = 6;
    //获取数组0索引上的元素
    int i = arr[0];
    System.out.println(i);
    //直接输出数组0索引元素
    System.out.println(arr[0]);
}

数组原理内存图

内存概述

内存是计算机中的重要原件，临时存储区域，作用是运行程序。我们编写的程序是存放在硬盘中的，在硬盘中的程序是不会运行的，必须放进内存中才能运行，运行完毕后会清空内存。

Java虚拟机要运行程序，必须要对内存进行空间的分配和管理。

JVM的内存划分

为了方便运算效率，就对空间进行了不同区域的划分，因为每一片区域都有特定的处理数据方式和内存管理方式。

区域名称	作用
寄存器	给CPU使用，和我们开发无关
本地方法栈	JVM在使用操作系统功能的时候使用，和我们开发无关
方法区	存储可运行的class文件
堆内存	存储对象或数组，new来创建的，都存储在堆内存
方法栈	方法运行时使用的内存，比如main方法运行，进入方法栈中执行

1. ArrayDemo01

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 14:23
 */
public class ArrayDemo01 {
    public static void main(String[] args) {
        //输出的是数组的地址值 一个十六进制的数 [I@1b6d3586
        int[] arr = new int[4];
        int[] arr2 = new int[3];
        System.out.println(arr);
        System.out.println(arr2);

    }
}

对应内存图

2.ArrayDemo02

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 14:23
 */
public class ArrayDemo02 {
    public static void main(String[] args) {
        //两个变量指向同一个数组

        //1.定义数组
        int[] arr = new int[3];
        // 2.对数组进行赋值操作
        for (int i = 0; i < arr.length; i++) {
            arr[i] = 6;
        }
        // 3.赋值
        System.out.println(arr[0]);
        System.out.println(arr[1]);
        System.out.println(arr[2]);
        //4.定义数组变量 arr2 将arr的地址赋值给arr2
        int[] arr2 = arr;
        // 5.修改arr2的第二个元素为8
        arr2[1] = 8;
        System.out.println(arr[1]);
    }
}

对应内存图

拓展
1.数组越界两种可能：数组下标越界超出范围；数组中没有空间（空数组）
例如： System.out.println(arr[3]);
2.数组的空指针异常
意味着arr将不会保存数组的地址了，也就是不允许在操作数组了
例如： arr = null; // java.lang.NullPointerException
System.out.println(arr[0]);

ArrayDemo03

求数组最大值

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 14:23
 */
public class ArrayDemo03 {
    public static void main(String[] args) {
        // 求数组中的最大值

        // 1.创建数组
        int[] arr = {5,15,2000,10000,100,4000};
        // 2.求arr中最大的值
        // 定义一个变量，存储数组中最大的值,假设arr中第一个元素是最大的
        int max = arr[0];
        // 遍历数组 取出每一个元素  让每一个元素和max进行比较
        for (int i = 0; i < arr.length; i++) {
            // 遍历元素和max进行比较 如果大于max就更新max的值
            if (arr[i] > max){
                max = arr[i]; //max始终记录最大值
            }
        }
        System.out.println("数组中最大的值是："+ max);
   }
}

ArrayDemo04

对数组进行反转

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 14:23
 */
public class ArrayDemo04 {
    public static void main(String[] args) {
        // 对数组进行反转
        int[] arr = {1,2,3,4,5};
        for (int i = 0; i < arr.length/2; i++) {
            int exchange =  arr[i];
            arr[i] = arr[(arr.length) - 1 - i];
            arr[(arr.length) - 1 - i] = exchange;

        }
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

        int[] arr1 = {1,2,3,4,5};
        /**
         * for (初始化条件1，初始化条件2；循环条件；步进运算1，步进运算2)
         * 定义一个min = 0 最小索引值，max = arr.length - 1 最大索引值
         */
        for (int min = 0, max = arr.length - 1; min <= max; min++,max--) {
            int temp = arr[min];
            arr[min] = arr[max];
            arr[max] = temp;

        }
        //重新遍历反转数组
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i]);
        }
   }
}

ArrayDemo05

数组作为方法的参数进行传递

使用数组作为方法的参数
 public  static void printArray(数据类型 变量值){
}

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 14:23
 */
public class ArrayDemo05 {
    public static void main(String[] args) {
        // 数组作为方法的参数进行传递
        int[] arr = {1,3,5,7,9};
        printArray(arr);
    }
    //之前我们看到的方法都是基本数据类型作为参数
    // 使用数组作为方法的参数
//    public  static void printArray(形参 实参){
//
//    }
   // public  static void printArray(数据类型 变量值){
//
//    }
    public  static void printArray(int[] arr){
       // 想要打印出数组  我们可以使用for循环遍历
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
   }
}

对应内存图

ArrayDemo06

数组作为方法的返回值进行传递

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 14:23
 */
public class ArrayDemo06 {
    public static void main(String[] args) {
        // 数组作为方法的返回值进行传递
        int[] arr = getArray();
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }

    public static int[] getArray()  {
        int[] arr = {1,2,3,4,5};
        // 返回数组的地址  返回给调用者
        return arr;
    }
}

ArrayDemo07

package com.neusoft;

import java.util.jar.JarOutputStream;

/**
 * @author Liu
 * @date 2020/4/26 14:23
 */
public class ArrayDemo07 {
    public static void main(String[] args) {
        // 基本数据类型  基本数据类型都在栈中
        int a = 1;
        int b = 2;
        System.out.println(a);
        System.out.println(b);
        change(a,b);
        System.out.println(a);
        System.out.println(b);

        //  引用数据类型 引用数据类型在堆中
        int[] arr = {1,3,5};
        System.out.println(arr[0]);
        change2(arr);
        System.out.println(arr[0]);
    }
    public static void change(int a , int b) {
        a =  a + b ;
        b = b + a;
    }
    public static void change2(int[] arr) {
        arr[0] = 200;

    }
}

对应内存图

面向对象编程

对象：泛指现实中一切的事物，每个事物都有自己的【属性】和【行为】
强调：通过调用对象的行为去实现功能，而不是自己去一步一步实现
- 举例：洗衣服
- 面向过程: 把衣服脱掉 -》盆 -》洗衣粉 -》加水 -》泡一下 -》搓搓搓 -》拧干 -》晒起来
- 面向对象：把衣服脱掉 -》打开全自动洗衣机 -》仍衣服 -》开关 -》晒起来
面向过程和面向对象的区别
- 面向过程：强调步骤
- 面向对象：强调对象对象就是洗衣机

面向对象特点：将复杂的事情简单化我们从执行者变成指挥者
面向对象包含三大基本特征：
- 封装、继承、多态

类和对象

类：可以看成一类事物的模板，在面向对象编程中，使用属性和行为来描述类
- 在现实生活中：
- 属性：该事物的状态信息
- 行为：该事物能干什么

对象：是一类事物的具体体现
对象是类的一个实例对象就必然具备该类事物的属性和行为
- 举例：猫类
- 属性： tom 5kg 2 black
- 行为：溜墙根走蹦跶喵喵叫
- 刘东东的一只猫这就是一个实例：也就是一个对象
类与对象的关系
- 类是对一类事物的描述抽象的
- 对象是一类事物的实例具体的
- 类是对象的模板对象是类的实体

类在Java中的定义

现实中的一类事物
- 属性：事物的状态信息
- 行为：能干哈

java和现实是一致的

成员变量：对应事物的属性，成员方法，对应事物的行为

成员变量：和之前一样，只不过位置变了，在类中，方法外

成员方法：只不过我们要将以前方法static去掉

public class 类名{
成员变量
成员方法
}

案例一

Student

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 18:57
 */
public class Student {
    // 成员变量
    String name;// 姓名
    int age;//年龄
    // 成员方法
    // 爱学习的方法
    public void study(){
        System.out.println("GOOD GOOD Study,Day Day Up");
    }
    // 吃饭 方法
    public void eat(){
        System.out.println("eat eat eat");
    }
}

Test01_Student

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 18:57
 */
public class Test01_Student {
  // 类的使用
    // Java中通过创建对象去使用类
    // 格式：
    // 类名  对象名 = new 类名（）
    // 返回值类型 具体的对象的名字 = new 类（）
    // 我们通过对象去访问类中的成员
    // 格式：
    // 对象名.成员变量
    // 对象名.成员方法（）；
  public static void main(String[] args) {
      // 调用学生类
      // 1.创建类 类名  对象名 = new 类名（）
      Student stu = new Student();
      // 2.打印这个对象
      System.out.println(stu); // 包名+地址：com.neusoft.Student@1b6d3586
      // 3.访问其中的成员变量
      System.out.println("姓名"+stu.name);
      System.out.println("年龄"+stu.age);

      // 4.给成员变量进行赋值
      stu.name = "寻悟空";
      stu.age = 23;

      //5.再次输出变量
      System.out.println("姓名"+stu.name);
      System.out.println("年龄"+stu.age);

      // 6.调用成员方法
      stu.study();
      stu.eat();
  }
}

类的使用:
Java中通过创建对象去使用类
格式：
类名对象名 = new 类名（）
返回值类型具体的对象的名字 = new 类（）
我们通过对象去访问类中的成员
格式：
对象名.成员变量
对象名.成员方法（）；

成员变量的默认值

	数据类型	默认值
基本类型	整型(byte,short,int,long)	0
	浮点数(float,double)	0.0
	字符(char)	'\u0000'
	布尔(boolean)	false
引用类型	数组，类，接口	null

案例二

Phone

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 19:14
 */
public class Phone {
    // 品牌 、 价格 、 颜色
    String pinpai;
    int price;
    String color;// 成员变量


    // 方法：给某人打电话
    public void Call(){
        int a = 45; //a 就是局部变量
        System.out.println("打电话");
    }
    // 发短信
    public void Send(){
        System.out.println("发短信");
    }
}

Test02_Phone

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 18:57
 */
public class Test02_Phone {
    public static void main(String[] args) {
        // 创建对象
        Phone phone = new Phone();
//        Phone p2 = new Phone();

        // 输出成员变量
//        System.out.println("品牌"+phone.pinpai);
//        System.out.println("价格"+phone.price);
//        System.out.println("颜色"+phone.color);

        // 赋值
        phone.pinpai = "iphone";
        phone.price = 5000;
        phone.color = "green";
        show(phone);

//        p2.pinpai = "iphone12";
//        p2.price = 5000;
//        p2.color = "red";


        // 再次输出
//        System.out.println("品牌"+phone.pinpai);
//        System.out.println("价格"+phone.price);
//        System.out.println("颜色"+phone.color);
//

//        // 调用打电话方法
//        phone.Call();
//
//        // 调用发短信方法
//        phone.Send();
    }
    // 对象作为参数进行传递
    public static void show(Phone p){
        System.out.println(p.pinpai + p.color + p.price);

    }
  }

对应内存图

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

1.在类中的位置不同
- 成员变量：类中，方法外
- 局部变量：方法中或者方法声明上（形式参数）
- 成员变量永远跟着类
- 局部变量永远跟着方法
2.作用范围不一样
- 成员变量：类中
- 局部变量：方法中
3.初始化值不同
- 成员变量：有默认值
- 局部变量：没有默认值，必须先定义，赋值，最后使用
4.在内存中的位置不同
- 成员变量：堆内存
- 局部变量：栈内存
5.生命周期不同
- 成员变量：随着对象的创建而存在，随着对象的消失而消失
- 局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

案例三

StudentInfo

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 20:41
 */
public class StudentInfo {
    private String name;
    private  int age;
    // 为成员方法提供公有的 get set 方法（访问 修改）
    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;
    }

    // this的含义
    // this代表所在类的当前对象的引用（地址值），即对象自己的引用
    // 诀窍：方法被那个对象调用 方法中的this就代表那个对象 即谁在调用，this就代表谁
}

扩展
this的含义
this代表所在类的当前对象的引用（地址值），即对象自己的引用
诀窍：方法被那个对象调用方法中的this就代表那个对象即谁在调用，this就代表谁

Test03_StudentInfo

package com.neusoft;

/**
 * @author Liu
 * @date 2020/4/26 20:42
 */
public class Test03_StudentInfo {
    public static void main(String[] args) {
        StudentInfo studentInfo = new StudentInfo();
        System.out.println(studentInfo.getName());
        studentInfo.setName("刘东东");
        System.out.println(studentInfo.getName());
    }
}

封装

封装实际上是将属性封装起来属性变为私有的，无法访问要提供公有的方法对其进行访问
- private 代表最小权限
- 可以修饰成员变量和成员方法
- 被private修饰的成员方法和成员变量，只有在本类才能访问

最后编辑于：2020.08.08 10:42:56

©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

Day04_Java基础4

Day04_Java基础4

数组定义和访问

容器概述

数组概念

数组的定义

方式一

方式二

数组的初始化

方式一数组动态初始化

方式二数组静态初始化

3 数组的访问

数组原理内存图

内存概述

JVM的内存划分

1. ArrayDemo01

2.ArrayDemo02

ArrayDemo03

ArrayDemo04

ArrayDemo05

ArrayDemo06

ArrayDemo07

面向对象编程

类和对象

类在Java中的定义

案例一

成员变量的默认值

案例二

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

案例三

封装

相关阅读更多精彩内容

友情链接更多精彩内容

Day04_Java基础4

数组定义和访问

容器概述

数组概念

数组的定义

方式一

方式二

数组的初始化

方式一 数组动态初始化

方式二 数组静态初始化

3 数组的访问

数组原理内存图

内存概述

JVM的内存划分

1. ArrayDemo01

2.ArrayDemo02

ArrayDemo03

ArrayDemo04

ArrayDemo05

ArrayDemo06

ArrayDemo07

面向对象编程

类和对象

类在Java中的定义

案例一

成员变量的默认值

案例二

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

案例三

封装

相关阅读更多精彩内容

友情链接更多精彩内容

方式一数组动态初始化

方式二数组静态初始化