实训经验分享day11

一、课前分享/*------------------------------------------------------*/

早：
继承：一个类只能继承一个类
调用方法先从子类查找，找不到再去父类中
this指向子类，super指向父类
方法重写
public,private,protected

中：
字符集

晚：
海里元素堆积->复制分子不断复制->出错->硅藻->堆叠->白垩纪->甲硅藻->可控炸药
诺贝尔奖起源
人工智能的要点：
    创造生命(创造智慧)：1.不停地复制（无意识） 2.出错

(PS:晚上的分享真的成功吸引了我的兴趣，上台来分享的是一个看起来比较腼腆的男生，说话声音小小的，然后像我一样上了台不知道说些什么好，但是他的表现真的很不错，从他开始说起就一直没有卡壳，从物种起源讲到炸药起源再讲到诺贝尔奖为什么没有数学，再从中提取出了自己对人工智能的理解：制造人工智能就是在创造智慧，而人类智慧的起源或能给我们启迪，比如他说的两个条件：1.无意识的自我复制，2.出错；        真的让人很有启发，而且关键点在于他的话轻柔但又有感染力，我全程都在竖起耳朵听，应该很认真地准备过，真厉害)

二、上课内容/*------------------------------------------------------*/

上午：
java中的var变量必须是局部变量，声明的同时必须赋值，因为假如你只声明，后续赋值就不知道var是什么类型的变量了。
数组的动态初始化就是创建时不赋值
int[] a = new int[数组长度]
数组的静态初始化就是创建的时候赋值
int[] a = new int[]{初始数据}
或 int[] a = {初始数据}
数组在创建时有初始值，初始值根据数据类型

数组的遍历有两种方式：
    普通for:
    增强for:
普通for的特点是可以随机存取和赋值
增强for循环的特点是简单方便，缺点是只能从头到尾遍历且不能赋值。
(原因：增强for循环的原理是用一个变量i来接收数组中的每一个元素，本质上是值的传递)。

下午：
下午进入了面向对象的学习，学习到了对象是new出来的，有new才有对象。类是对象的抽象，表示一类事务；对象是类的特殊，表示具体的某个个例。面向对象的主要目的是将生活用对象来表示，用以解决复杂的问题，最后还是要通过面向过程来解决问题。然后类里可以定义属性和行为，属性即成员变量，行为即成员方法。

三、代码练习/*------------------------------------------------------*/

package youjixian01a;
/*
    数组练习题
 */
//A:遍历int类型的数组 依次输出每个数组元素
//B:遍历字符数组
//C:最值:获取数组中的最大值和最小值
//D:逆序:倒叙输出数组元素


public class test19 {
    public static void main(String[] args) {

        int[] a = new int[]{1, 2, 3, 4, 0, 5, 9, 8, 7, 6, 0};
        char[] c = new char[]{'A', 'B', 'C', 'D', 'E'};
        //A:遍历int类型的数组 依次输出每个数组元素
        itr(a);
        //B:遍历字符数组
        itr(c);
        //C:最值:获取数组中的最大值和最小值
        getMaxMin(a);

        //D:逆序:倒叙输出数组元素
        converse(a);

        //1.将一个存放了大写字母的数组转换成存放小写字母的数组返回
        upper(c);

        int index = getIndex(a, 8);
        System.out.println(index);

        delZero(a);

    }

    private static int[] itr(int[] a) {
        //  普通for
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
        //  增强for
        for (int i : a) {
            System.out.print(i + " ");
        }
        System.out.println();
        return a;
    }

    private static char[] itr(char[] c) {
        //  普通for
        for (int i = 0; i < c.length; i++) {
            System.out.print(c[i] + " ");
        }
        System.out.println();
        //  增强for
        for (char i : c) {
            System.out.print(i + " ");
        }
        System.out.println();
        return c;
    }

    private static void getMaxMin(int[] a) {
        //  普通for
        int max = a[0];
        int min = a[0];
        for (int i = 0; i < a.length; i++) {
            if (a[i] > max)
                max = a[i];
            if (a[i] < min)
                min = a[i];
        }
        System.out.println("普通for max:" + max);
        System.out.println("普通for min:" + min);
        //  增强for
        max = a[0];
        min = a[0];
        for (int i : a) {
            if (i > max)
                max = i;
            if (i < min)
                min = i;
        }
        System.out.println("增强for max:" + max);
        System.out.println("增强for min:" + min);
    }

    private static void converse(int[] a) {
        //  普通for
        System.out.println("普通for正序");
        for (int i = 0; i < a.length; i++) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
        System.out.println("普通for逆序");
        for (int i = a.length - 1; i >= 0; i--) {
            System.out.print(a[i] + " ");
        }
        System.out.println();
        //  增强for
        System.out.println("增强for循环是不可以控制循环的方向的。 也就是说，不可以倒序输出。");
    }

    private static void lower(char[] c) {
        for (int i = 0; i < c.length; i++) {
            c[i] -= 32;
            System.out.print(c[i] + " ");
        }
        System.out.println();
    }

    private static void upper(char[] c) {
        for (int i = 0; i < c.length; i++) {
            c[i] += 32;
            System.out.print(c[i] + " ");
        }
        System.out.println();
    }

    /*2.数组元素查找(查找指定元素第一次在数组中出现的索引)
     * 若存在:返回这个元素的下标
     * 若不存在:返回-1
     */
    public static int getIndex(int[] a, int tar) {
        for (int i = 0; i < a.length; i++) {
            if (tar == a[i])
                return i;
        }
        return -1;
    }

    /*
     * 3.将一个整型数组中的0去掉后但会一个新数组.
     * 	例如: int[] arr={1,26,0,8,10,50,8,0,7,35,0,4,3,20,0,17};
     *  要求:将以上数组中的0去掉,将不为0的值存入一个新数组,生成新的数组作为返回值.
     *  	int newArr={1,26,8,10,50,8,7,35,4,3,20,17};
     */
    public static int[] delZero(int[] a) {
        int count = 0;
        for (int i = 0; i < a.length; i++) {
            if (a[i] != 0)
                count++;
        }
        int[] b = new int[count];
        int j = 0;
        for (int i = 0; i < a.length; i++) {
            if (a[i] != 0)
                b[j++] = a[i];
        }
        for (int i : b) System.out.print(i + " ");
        return b;
    }

}