Java基础四

数组原理内存图

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

栈的特点：先进后出

JVM的内存划分：

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

1. 输出数组地址

        int[] arr = new int[4];
        int[] arr2 = new int[3];
        System.out.println(arr);            
        //输出的是数组的地址值 ：[I@1b6d3586
        System.out.println(arr2);           
        //[I@4554617c

ArrayDemo01

2.两个变量指向同一个数组

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

两个变量指向同一个数组

3.数组异常及遍历

（1）数组越界

1.数组下标超出范围 
2.数组中没有空间
 System.out.println(arr[3]);   //ArrayIndexOutOfBoundsException

（2）数组的空指针异常

意味着arr 将不会保存数组的地址了，也就是不允许再操作数组了
        arr = null;         //NullPointerException
        System.out.println(arr[0]);

(3) 数组遍历

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

4. 求数组中的最大值

public class ArrayDemo03 {
    public static void main(String[] args) {
        //创建一个数组
        int[] arr = {5, 15, 2000, 10000, 100, 4000};
        //求 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);
    }
}

5. 对数组进行反转

方法一

public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        int[] arr2 = new int[5];
        for (int i = 0; i < arr.length; i++) {
            arr2[i] = arr[arr.length-i-1];
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr2[i] + "\t");
        }
}

方法二

public static void main(String[] args) {
        int[] arr = new int[]{1,2,3,4,5};
        for (int i = 0; i < arr.length/2; i++) {
            int temp = arr[i];
            arr[i] = arr[arr.length-i-1];
            arr[arr.length-i-1] = temp;
        }
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
}

方法三

public static void main(String[] args) {
     /**
         * for (初始化条件1,初始化条件2; 循环条件; 步进运算1,步进运算2)
         * 定义 min = 0 最小索引值， max = arr.length-1 最大索引值
         */
        int[] arr = new int[]{1,2,3,4,5};
        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 < arr.length; i++) {
            System.out.print(arr[i]);
        }
    }

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

public class ArrayDemo05 {
    public static void main(String[] args) {
        sayHello("韩梅梅");
        int[] arr = {1, 3, 5, 7, 9};
        printArray(arr);
    }
    public static void sayHello(String name){
        System.out.println("Hello" + name);
    }

    //之前我们看到的方法都是基本数据类型作为参数的
    //使用数组作为方法的参数
//    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]);
        }
    }
}

对应JVM内存图

数组作为方法的参数传递

7.数组作为方法的返回值

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]);
        }
    }
    //void 无返回值
    public static int[] getArray(){
        int[] arr = {1, 2, 3, 4, 5};
        //返回数组的地址，返回给调用者
        return arr;
    }
}

案例

public class ArrayDemo07 {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(a);//1
        System.out.println(b);//2
        change(a, b);
        System.out.println(a);//1
        System.out.println(b);//2
        //change(a,b)没有返回，a,b不变
        int[] arr = {1, 3, 5};
        System.out.println(arr[0]);//1
        change2(arr);
        System.out.println(arr[0]);//200
    }
    public static void change(int a ,int b){
        a = a + b;
        b = b + a;
//        System.out.println(a);
//        System.out.println(b);

    }
    public static void change2(int arr[]){
        arr[0] = 200;
    }
}

ArrayDemo07

面向对象编程

对象：泛指现实中一切的事物，每个事物都有自己的【属性】和【行为】
强调：通过调用对象的行为去实现功能，而不是自己去一步一步实现

举例：洗衣服：
1.面向过程：把衣服脱掉-->盆-->加水-->泡-->洗。。。（强调步骤）
2.面向对象：把衣服脱掉-->打开全自动洗衣机-->放衣服-->开关-->晾衣服（强调对象）

面向对象特点：将复杂的事情简单化，我们从执行者变成了指挥者(完成一个项目花钱雇人完成而不是自己做)

面向对象包含三大基本特征：封装，继承，多态

类和对象

类 : 可以看成一类事物的模板，在面向对象编程中，使用属性和行为来描述类

在现实中:

属性：该事物的状态信息

行为：该事物能干什么

对象：是一类事物的具体体现

对象是类的换一个实例，对象就必然具备该类事物的属性和行为

类和对象的关系

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

对象是一类事物的实例具体的

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

类在java中的定义 : 现实中的一类事物

java和现实是一致的

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

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

成员方法：只不过我们要将以前方法static去掉（static是面向过程的）

public class 类名{
    // 成员变量
    // 成员方法
    //类名使用大驼峰方式
}

类的使用

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

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

成员变量的默认值

成员变量默认值

案例

一.student类

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("学习饿了就得吃饭");
    }
}

//测试类
public class Test01_Student {
    //类的使用
    //Java中通过创建对象去使用类
    //格式：
    //类名 对象名 = new 类名（）
    //返回值类型   具体的对象名字 = new 类();
    //我们通过对象去访问类中的成员
    //对象名.成员变量
    //对象名.成员方法()；
    public static void main(String[] args) {
        //调用 学生类
        //1、创建类：类名 对象名 = new 类名（）
        Student s = new Student();
        //2、打印这个对象
        System.out.println(s);  //返回包名+16进制地址
        //3、访问其中的成员扁蕾
        System.out.println("姓名" + s.name);
        System.out.println("年龄" + s.age);
        //4、给成员变量进行赋值
        s.name = "悟空";
        s.age = 500;
        //5、再次输出变量
        System.out.println("姓名" + s.name);
        System.out.println("年龄" + s.age);
        System.out.println("------------------------");
        //6、调用成员方法
        s.study();
        s.eat();
    }
}

二. Phone类

public class Phone {
//    成员变量
    String brand;   //品牌
    int  price;     //价格
    String color;   //颜色
    //成员方法
    //给name打电话
    public void Called(String  name){
        System.out.println("给"+name+"打电话");
    }
    //发短信
    public void SendMessage(){
        System.out.println("发短信");
    }
}

//测试类
public class Test02_Phone {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();
        //输出成员变量
        System.out.println("品牌："+ p.brand);
        System.out.println("价格："+ p.price);
        System.out.println("颜色："+ p.color);
        System.out.println("---------------------");
        //赋值
        p.brand = "华为";
        p.color = "green";
        p.price = 6666;
        //再次输出
        System.out.println("品牌："+ p.brand);
        System.out.println("价格："+ p.price);
        System.out.println("颜色："+ p.color);
        System.out.println("---------------------");
        //调用方法
        p.Called("石浩博");
        p.SendMessage();
        show(p);        //调用show方法
    }
//    对象作为参数进行传递
    public static void show(Phone p){
        System.out.println(p.brand +"  "+ p.price+"     "+ p.color);
    }
}

Phone类对应内存图

面向对象的三大特征

1.封装

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

案例:通过方法访问或改变成员变量

public class StudentInfo {
    private String name;
    private int age;

    //为成员方法提供共有的set, get方法（访问，修改）
    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就代表谁

public class Test03_StudentInfo {
    public static void main(String[] args) {
        StudentInfo studentInfo = new StudentInfo();
        System.out.println(studentInfo.getName());
        //调用方法
        studentInfo.setName("石浩博");
        studentInfo.setAge(21);
        //输出
        System.out.println(studentInfo.getName());
        System.out.println(studentInfo.getAge());
    }
}