final和抽象类和接口

final关键字(掌握)

概念

是最终的意思，可以修饰类，方法，变量

特点

    A:它修饰的类，不能被继承
    B:它修饰的方法，不能被重写
    C:它修饰的变量，是一个常量

面试相关

    A:局部变量
        a:基本类型 值不能发生改变
        b:引用类型 地址值不能发生改变，但是对象的内容是可以改变的
    B:初始化时机
        a:只能初始化一次。
        b:常见的给值
            定义的时候。(推荐)
            构造方法中。

---

抽象类(掌握)

概念

   把多个共性的东西提取到一个类中，这是继承的做法
   但是呢，这多个共性的东西，在有些时候，方法声明一样，但是方法体
   也就是说，方法声明一样，但是每个具体的对象在具体实现的时候内容不一样
   所以，我们在定义这些共性的方法的时候，就不能给出具体的方法体
   而一个没有具体的方法体的方法是抽象的方法
   在一个类中如果有抽象方法，该类必须定义为抽象类

抽象类的特点

    A:抽象类和抽象方法必须用关键字abstract修饰
    B:抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类
    C:抽象类不能实例化
    D:抽象类的子类
        a:是一个抽象类。
        b:是一个具体类。这个类必须重写抽象类中的所有抽象方法。

抽象类的成员特点

    A:成员变量
        有变量，有常量
    B:构造方法
        有构造方法
    C:成员方法
        有抽象，有非抽象

抽象类的几个小问题

    A:抽象类有构造方法，不能实例化，那么构造方法有什么用?
        用于子类访问父类数据的初始化
    B:一个类如果没有抽象方法,却定义为了抽象类，有什么用?
        为了不让创建对象
    C:abstract不能和哪些关键字共存
        a:final 冲突
        b:private 冲突
        c:static 无意义

---

接口(掌握)

它们仅仅提供一些基本功能。

比如：猫钻火圈，狗跳高等功能，不是动物本身就具备的
是在后面的培养中训练出来的，这种额外的功能，java提供了接口表示。

接口的特点

    A:接口用关键字interface修饰
        interface 接口名 {}
    B:类实现接口用implements修饰
        class 类名 implements 接口名 {}
    C:接口不能实例化
    D:接口的实现类
        a:是一个抽象类。
        b:是一个具体类，这个类必须重写接口中的所有抽象方法

接口的成员特点

    A:成员变量
        只能是常量
        默认修饰符：public static final
    B:构造方法
        没有构造方法
    C:成员方法
        只能是抽象的
        默认修饰符：public abstract

类与类,类与接口,接口与接口

    A:类与类
        继承关系，只能单继承，可以多层继承
    B:类与接口
        实现关系，可以单实现，也可以多实现。
        还可以在继承一个类的同时，实现多个接口
    C:接口与接口
        继承关系，可以单继承，也可以多继承

抽象类和接口的区别

    A:成员区别
        抽象类：可以是变量，可以是常量
        接口：只能是常量
    B:关系区别:
        类与类：继承
        类与接口：实现
        接口与接口：继承
    C:设计理念不同
        抽象类：is a，抽象类中定义的是共性功能。
        接口：like a，接口中定义的是扩展功能。

数组(掌握)

定义

存储同一种数据类型的多个元素的容器。

特点

每一个元素都有编号，从0开始，最大编号是长度-1。

 编号的专业叫法：索引

定义格式

    A:数据类型[] 数组名;
    B:数据类型 数组名[];

    推荐是用A方式，B方法就忘了吧。
    但是要能看懂

数组的初始化

A:动态初始化

        只给长度，系统给出默认值

        举例：int[] arr = new int[3];

B:静态初始化

        给出值，系统决定长度

        举例：int[] arr = new int[]{1,2,3};
        简化版：int[] arr = {1,2,3};

Java的内存分配

    A:栈 存储局部变量
    B:堆 存储所有new出来的
    C:方法区(面向对象部分详细讲解)
    D:本地方法区(系统相关)
    E:寄存器(CPU使用)

注意

        a:局部变量 在方法定义中或者方法声明上定义的变量。
        b:栈内存和堆内存的区别
            栈：数据使用完毕，就消失。
            堆：每一个new出来的东西都有地址
                每一个变量都有默认值
                    byte,short,int,long 0
                    float,double 0.0
                    char '\u0000'
                    boolean false
                    引用类型 null
                数据使用完毕后，在垃圾回收器空闲的时候回收。

数组的常见操作

A:遍历

方式1：

public static void printArray(int[] arr) {
                    for(int x=0; x<arr.length; x++) {
                        System.out.println(arr[x]);
                    }
                }

方式2：

public static void printArray(int[] arr) {
                    System.out.print("[");
                    for(int x=0; x<arr.length; x++) {
                        if(x == arr.length-1) {
                            System.out.println(arr[x]+"]");
                        }else {
                            System.out.println(arr[x]+", ");
                        }
                    }
                }

B:最值

最大值：

public static int getMax(int[] arr) {
                    int max = arr[0];

                    for(int x=1; x<arr.length; x++) {
                        if(arr[x] > max) {
                            max = arr[x];
                        }
                    }

                    return max;
                }

最小值：

    public static int getMin(int[] arr) {
                    int min = arr[0];

                    for(int x=1; x<arr.length; x++) {
                        if(arr[x] < min) {
                            min = arr[x];
                        }
                    }

                    return min;
                }

C:逆序

方式1：

    public static void reverse(int[] arr) {
                    for(int x=0; x<arr.length/2; x++) {
                        int temp = arr[x];
                        arr[x] = arr[arr.length-1-x];
                        arr[arr.length-1-x] = temp;
                    }
                }

方式2：

public static void reverse(int[] arr) {
    for(int start=0,end=arr.length-1; start<=end; start++,end--) {
                        int temp = arr[start];
                        arr[start] = arr[end];
                        arr[end] = temp;
                    }
                }

D:查表

                public static String getString(String[] strArray,int index) {
                    return strArray[index];
                }

E:基本查找

方式1：

public static int getIndex(int[] arr,int value) {
                    for(int x=0; x<arr.length; x++) {
                        if(arr[x] == value) {
                            return x;
                        }
                    }

                    return -1;
                }

方式2：

public static int getIndex(int[] arr,int value) {
                    int index = -1;

                    for(int x=0; x<arr.length; x++) {
                        if(arr[x] == value) {
                            index = x;
                            break;
                        }
                    }

                    return index;
                }