心得感悟

今天的内容也大多都是概念文字，要消化和领悟还是要靠自己多多思考，还好在我多次百度+问老师后，我终于还是理解了。虽然我学习东西没有其他人那么快，多花点时间还是能赶得上的。复习完回过头再看今天的内容，又觉得简单了许多。在计算机这条学习路上，我的心真是起起落落落落落落落落落落落落起，但世上无难事，只怕有心人，还是加油吧！

1. 目的

• 一、加深数组和类的使用熟练度
• 二、了解类和对象
• 三、了解对象的内存表现
• 四、了解成员方法
• 五、通过知识点讲解和编程，领悟C语言和Java的区别

2. 内容简概

• ⼀、数组的两种定义⽅式
• ⼆、数组定义之后在内存中的表现形式
• 三、数组的基本使⽤
• 四、遍历数组的三种⽅式
• 五、使⽤数组实现猜数字
• 六、类和对象的概念
• 七、类的定义
• 八、对象的创建
• 九、创建对象的内存表现
• 十、成员⽅法的声明和访问
• 十一、匿名对象
• 十二、封装

3. 具体内容

• ⼀、数组的两种定义⽅式

① 静态：定义时直接赋值

int[] score = {1, 2, 3};
String[] names = {"jack", "merry"};

②动态：先定义，内容可以动态添加

float[] height = new float[5];
height[0] = 165.5f;
height[1] = 170f;

• ⼆、数组定义之后在内存中的表现形式

其实有一点俄罗斯套娃的感觉

• 三、数组的基本使⽤

Random r = new Random();
int[] count = new int[10];   
for (int i = 0;i < 10;i++){
    count[i] = r.nextInt(100);
}

• 四、遍历数组的三种⽅式

        //数组输出方式1
        for (int i = 0;i < count.length;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));

三种方式的数组输出效果

• 五、使⽤数组实现猜数字

1.代码示范

class GuessNumber{
    public static void main(String[] args){
        //保存原始数字
        int[] org = new int[4];
        //保存用户猜测数字
        int[] guess = new int[4];

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

            //判断是否重复
            boolean result = contains(org,temp);

            if (result){
                i--;
            }else{
               org[i] = temp;
            }
        }
        //排序
        Arrays.sort(org);
        System.out.println(Arrays.toString(org));

        //开始游戏
        Scanner scanner = new Scanner(System.in);
        while (true){
            int countA = 0;
            int countB = 0;

            System.out.print("请输入猜测数字：");

            for (int i = 0;i<4;i++){
                guess[i] = scanner.nextInt();
            }

            //判断用户输入
            //1.判断是否存在
            for (int i = 0;i<4;i++){
                boolean result = contains(guess,org[i]);
                if (result){
                    //数字存在
                    //判断位置是否相同
                    int index = indexOf(guess,org[i]);

                    if (index == i){
                        //数字位置都相同
                        countA++;
                    }else {
                        countB++;
                    }
                }
            }
            if (countA ==4){
                System.out.println("恭喜答对！");
                break;
                }else {
                System.out.println(countA+"A"+countB+"B");
            }
        }
    }

    public static int indexOf(int[] val,int obj){
        for (int i =0;i<val.length;i++){
            if (val[i] == obj){
                return i;
            }
        }
        return -1;
    }

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

2.程序运行效果

Java版猜数字游戏.gif

• 六、类和对象的概念

简单的说，类就是一个概念，是抽象的。而对象是具体的某一个事物。举个例子，我们说的“人类”就是一个类，它是我们规定的一个概念，而“王小明”就是一个对象，他是一个具体的事物。

一个类中可以有多个方法，方法外的变量有“类变量”和“成员变量”，方法中的变量有“局部变量”，“成员变量”一般定义在类的最上面。而方法操作对象，一个类中可以有多个对象。类其实就是封装，把方法对象打包起来。

• 七、类的定义

通常情况下，一个文件夹对应一个类，以下为定义类的格式：

修饰符  class  类名{
        这个类的一些属性：成员变量
        这个类的功能：方法
}

修饰符用来定义类、方法或者变量，通常放在语句的最前端。在此只讲解访问控制修饰符，类型及定义如下：

• 八、对象的创建

对象是根据类创建的。在Java中，使用关键字new来创建一个新的对象。创建对象需要以下三步：

1. 声明：声明一个对象，类名+对象名，如下：

public class Puppy{
    public static void main(String args[]){
          Puppy myPuppy;   //对象声明
    }
}

2. 实例化：使用关键字new来创建一个对象。
3. 初始化：使用new创建对象时，会调用构造方法初始化对象。

      myPuppy = new Puppy(); //创建并初始化对象

• 九、创建对象的内存表现

如图

• 十、成员⽅法的声明和访问

1. 方法的定义 public static final private
语法格式：
　　　　权限修饰符　返回值类型　方法名（参数类型　参数名） {
　　　　　　// 方法
　　　　　　// 返回值
　　　　}

public void test(){
        System.out.println("没有返回值，没有方法");
    }
    public void test2(){
        //在自己的类里面可以调用这个类里的所有资源
        //this.test();不建议这么写
        test();
    }

2. 方法的访问

//没有返回值 接收一个参数
    public void test3(String name){

    }
    //有一个参数 有一个返回值
    public int test4(String name){
        return 0;
    }
    //有多个参数 用逗号隔开
    public int test5(String name,int age){
        return 0;
    }
    //可变参数 相当于数组
    public int test6(int ... counts){
        int sum = 0;
        for (int i = 0;i < counts.length;i++){
          sum += counts[i];
        }
        return sum;
    }
}

• 十一、匿名对象

1. 定义：没有名字的对象，如：

class TestClass{
      new test().age = 10;  //匿名对象
      public int test(){
            int age;
      }
}

2.匿名对象的用法
①只使用对象一次
②作为参数传递

show(new Car());

• 十二、封装

1. 定义：把私有的东西包装、隐藏起来，不让外部使用
2. 优点：
①良好的封装能够减少耦合。
②类内部的结构可以自由修改。
③ 可以对成员变量进行更精确的控制。
④ 隐藏信息，实现细节。