一、学习目的

  通过今天的学习来掌握数组的定义方式和基本使用，感受与C语言数组中的异同，以及初步认识类与对象的概念，如何创建一个对象，类里面如何定义变量和方法和理解创建对象的内存表现。

二、数组的定义相关

1. 数组的两种定义方式（静态和动态）

//引用类型：除char short int float long double byte以外都是引用类型
        //数组一但被定义  大小就确定了 无法更改
        //静态
        int[] score = {1,2,3};
        String[] names = {"jack","marry"};

        //动态 内容动态添加
        float[] height = new float[5];
        height[0] = 180.0f;
        height[1] = 170f;

2. 数组定义之后在内存中的表现形式

表现形式

3. 数组的基本使用

        Random r = new Random();
        int num = r.nextInt(100);

        //尽量不要扩大变量的作用域
        int[] count = new int[10];
        for (int i = 0;i <10;i++){
            count[i] = r.nextInt(100);
        }

4. 遍历数组的3种方式

• for循环，关注元素是第几个

• foreach快速循环，不关注元素是第几个

• Arrays.toString(数组名),主要用于测试

         //数组的遍历
        //数组输出方式1  关注第几个
        for (int i = 0;i < 10;i++){
            System.out.print(count[i]+" ");
        }
        System.out.print("\n");


        //数组输出方式2  快速循环 不关注第几个
        for (int temp:count
             ) {
            System.out.print(temp+" ");
        }
        System.out.print("\n");

        //数组输出方式3  用来测试
        System.out.println(Arrays.toString(count));
        System.out.print("\n");

5. 猜数游戏（Java实现）

主程序代码：

class GuessNumber{
    public static void main(String[] args){
        //定义一个数组
        int[] originalArray = new int[4];
        //保存用户输入的猜测数字
        int[] guessArray = new int[4];

        //产生4个随机数
        Random random = new Random();
        for (int i = 0;i < 4;i++){
            //产生1个随机数
            int temp = random.nextInt(10);


            //判断是否存在
            boolean result = contains(originalArray,temp);
            if (result){
                //确保i对应的位置能够得到一个不重复的数字
                i--;
            }else{
                originalArray[i] = temp;
            }
        }

        //排序
        Arrays.sort(originalArray);

        System.out.println(Arrays.toString(originalArray));

        //定义一个Scanner对象
        Scanner scanner = new Scanner(System.in);
        //开始游戏
        while (true){
            int countA = 0;
            int countB = 0;

            System.out.print("请输入猜测的数字：");
            for (int i = 0;i < 4;i++){
                guessArray[i] = scanner.nextInt();
            }

            //判断用户输入
            //1.判断是否存在        2.位置是否相同
            for (int i = 0;i <4;i++){
                boolean result = contains(guessArray,originalArray[i]);
                if (result){
                    //数字存在
                    //判断位置是否相同
                    int index = indexOf(guessArray,originalArray[i]);
                    if (index == i){
                        //数字位置都相同
                        countA++;
                    }else{
                        countB++;
                    }
                }
            }
            if (countA == 4){
                System.out.println("Congratulations!!");
                break;
            }else{
                System.out.println(countA+"A"+countB+"B");
            }
        }


    }

在一个数组里面查找某个值的索引值：

/**
     * 在一个数组里面查找某个值的索引值
     * @param var 数组
     * @param obj  查找的对象
     * @return  索引值
     */
    public static int indexOf(int[] var,int obj){
        for (int i = 0;i < var.length;i++){
            if (var[i] == obj){
                return i;
            }
        }
        return  -1;
    }

自己写一个方法判断一个数组是否包含某个值:

 //自己写一个方法判断一个数组是否包含某个值
    public static boolean contains(int[] var,int obj){
        for (int i = 0;i < var.length;i++){
            if (var[i] == obj){
                //重复了
                return true;
            }
        }
        return false;
    }
}

三、类的使用

Java  OOP:object oriented programming面向对象编程

1. 类和对象的概念

类：java里面除了8大基本数据类型之外 都是对象,是抽象的，不实际存在的，用来描述同一类事物(具有共同的属性 或者方法)

一般来说，类是由数据成员和函数成员封装而成

对象：具体的 实际存在的 某一个类的实例化，且对象都是new出来的，可以完成具体的事情；同一个类可以有多个对象

2. 类的定义

 定义一个类  通常情况下一个文件对应一个类
 修饰符：public static final
 修饰符 class 类名{
          这个类的一些属性：成员变量
          这个类的功能：方法

 }



class Person{
    //成员变量  通常定义在类的最上方
    //default:
    public String name;
    public int age;
    public float score;
    private String password;
    public char choice;

    //方法的定义 public static final private
    public void test(){
        System.out.println("没有返回值 没有参数的返回值");
    }
}

3.对象的创建

• 对象一旦创建 属性变量有初始值

char ' '    int long short byte 0
float double 0.0
boolean false
引用数据类型：对象类型的变量 = null

 /*
        创建Person类的一个对象
        使用.访问成员变量
       
         */
        Person xw = new Person();
        Person zs = new Person();

        /*
        同一个类可以创建多个对象
        每个对象的内存空间都是独立的（对象之间没有任何关系）
        xw和zs除了都是同一个类创建的之外  没有任何关系
        对xw属性的操作 不会影响zs
         */
        //给这个对象对应的属性赋值
        //方法区->堆->栈
        xw.name = "小王";
        xw.age = 20;
        xw.score = 86.5f;

        System.out.println(xw.name);
        System.out.println(xw.age);
        System.out.println(xw.score);

4. 创建的对象的内存表现

image.png

5. 成员方法的声明和访问以及使用

方法的使用:
调用谁（那个对象）的方法
在类里面可以直接调用自己的方法
在外部必须通过对象来调用

//方法的定义 public static final private
    public void test(){
        System.out.println("没有返回值 没有参数的返回值");
    }
    public void test2(){
        //在自己的类里面可以调用这个类里面的所有资源
        //this.test();
        test();
    }
    //没有返回值 接受一个参数
    public void test3(String name){


    }
    //有返回值 接受一个参数
    public int test4(String name){
        return 0;
    }

    //有多个参数  每个参数用逗号隔开
    public int test5(String name){
        return 0;
    }




    //可变参数   相当于  数组
    public int test6(int ... counts){
        int sum = 0;
        for (int i = 0;i < counts.length;i++){
            sum += counts[i];
        }
        return sum;
    }
//调用test6
       Person lisi = new Person();
        lisi.test();
        //匿名对象 ->作为一个参数传递
        int result = lisi.test6(new int[]{1, 2, 3, 4, 5});
        System.out.println(result);

6. Java语言三大特点

封装：
把私有的东西封装起来 不让外部使用
需要给外部使用 就暴露出来
访问权限：public private protected
public:公共的 内部可以用，外部也可以用
private:私有的 只能自己使用 外部无法访问 子类无法继承
protected:受保护的 外部（同一个包里面）可以访问

继承:
是指一个对象直接使用另一个对象的属性和方法

多态:
一个对外接口，多个内在实现方法

四、心得体会

  通过这次的学习，对Java类与对象的概念有了更深层次的理解，也从内存管理的方式上了解其储存方式，总而言之，收获满满，但仍需努力！