数组、内存、内部类、封装、static关键字、多态

常见的几个概念

1. 数组

【数组的基本概念】
1. 数组是一组相同类型的数据的集合。
2. 每个数组都有长度，这个长度是在初始化数组的时候就已经确定的。
3. 数组的长度是不可以被改变的
4. 数组的每个元素都有“下标”(index)，可以用于引用数组的元素，下标是从0开始顺序编号的。

【数组的初始化】

1. 静态的初始化：在创建数组时就确定数组的各个元素的值：

int[] arr = { 9, 5, 2, 7 };

1. 动态的初始化：创建数组时，需要确定数组的长度，但是可以不确定数组的各元素的值。

int[] arr = new int[8];
int[] arr; new int[8];
int[] arr; arr = new int[] { 9, 5, 2, 7 };

2. 内存

【什么是内存】

内存即内部存储器，与外部存储器是不同的硬件，内部存储器通常有： RAM、ROM、Cache。
RAM(Random Access Memory)：PC机的内存条
ROM(Read Only Memory)：固件
Cache：高速缓存，内置在CPU里

在描述手机的存储设备时，“运行内存”即RAM，相当于PC机的“内存条”，而“存储内存”相当于PC 机的“硬盘”。

【内存的特性】

可读可写，断电后数据消失。

【内存的作用】

内存(RAM)用于存储正在执行的程序与数据。
内存是CPU可以直接交换数据的唯一硬件。
内存是CPU与其他所有外部设备交换数据的桥梁。

3. 内部类的种类和各种内部类的语法特征

把某个类定义在其他类的内部，则称之为内部类。

内部类可以访问外部类的所有成员（静态内部类除外），无论这些成员是使用哪种访问权限修饰符进行修饰的。

1. 成员内部类
在类（外部类）的内部，且与外部类的成员是“同一级别”的。

public class OutterClass {
    private int i;
    private void run() {
        int x;
    }
    private void test() {
        int y;
    }
    public class InnerClass{}
 }

成员内部类可以使用任何访问权限修饰符，成员内部类不可以在外部类的外部直接创建对象。

2. 局部内部类
局部内部类的“定位”类似于局部变量，即声明在方法内部的类，则称之为局部内部类。

public class MainActivity extends Activity {
    public int a;
    public void onCreate(final int i) {
        final int x = 100;
        class InnerClass {
            public void test() {
                System.out.println(x);
                System.out.println(i);
                System.out.println(a);
            }
        }
        InnerClass ic = new InnerClass();
    }
}

局部内部类不可以使用任何访问权限修饰符。
局部内部类的定义、对象的创建，必须符合方法中代码的执行逻辑。
局部内部类不可以直接访问局部变量（方法的参数等效于局部变量），如果一定需要访问，则需要使用final对局部变量进行修饰，使之成为常量，或者，将局部变量提升为成员变量。

3. 静态（成员）内部类
使用static修饰的成员内部类，称之为静态内部类

public class OuterClass {
    public int x = 5;
    public static int y = 100;
    public static class InnerClass {
        public void run() {
            // System.out.println(x); // 错误
            System.out.println(y); // 正确
        }
    }
}

静态成员内部类可以在任何位置（包括外部类的外部）直接创建对象。

4. 匿名内部类
直接创建已知的类的子类的对象（或者已知的接口的实现类的对象），则该对象的类型就是匿名内部类，顾名思义，该类型并没有名称。

public class OuterClass {
    public void run() {
        new OnClickListener() {
            public void onClick() {}
        };
    }
}

4. 封装

封装是“装了再封”的过程。

public class Student {
    public String name;
    private int age;
    public String from;
    public void setAge(int age) {
        if (age >= 12 && age <= 50) {
            this.age = age;
        }
    }
    public int getAge() {
        return this.age;
    }
}

public class Test {
    public static void main(String[] args) {
        Student stu1 = new Student();
        stu1.name = "Jack";
        stu1.setAge(18);
        // stu.age = 1800; // 不合理
        stu1.from = "Beijing";
        System.out.println(stu1.getAge());
        Student stu2 = new Student();
        set2.setAge(70); // 无效
    }
}

5. static关键字

static -> 静态的
被static修饰的成员将最优先加载到内存。

public class Student {
    public static int i = 100;
    public String name;
    public static void main(String[] args) {
        i = 999; // 正确的
        // name = "Jack"; // 错误的
        Student stu = new Student();
        stu.name = "Jack"; // 正确的
    }
}

6. 多态

多态指的是编译期（声明变量时）和运行期（创建对象后）表现为不同的形态（数据类型）。
多态是综合了继承、重写、向上转型、动态绑定等机制的综合应用方式。
多态在代码中的表现可以简单的理解为：当需要父类的对象时，可以使用子类的对象来表示，且，调用方法时，会优先执行子类重写的方法。

Animal a = new Dog();

【相关专业名词】
1. 向上转型：声明时使用父级的类型，但是创建出的对象是子级的类型，例如：Animal a = new Dog();
对象被向上转型以后，只能调用转型后（父级类别/声明时的类别）的类别的属性、方法，而不能再调用自身特有的属性和方法。
2. 向下转型：将父类对象强制转换为子类的对象，当然，前提是该父类的对象原本就是由子类创建出来的，例如：

Animal a = new Dog();
Dog d = (Dog) a;

或者

TextView tvTitle = (TextView) findViewById(R.id.tv_title);

1. instanceof关键字：用于判断对象是否归属某个类，例如：

dog instanceof Dog -> true
dog instanceof Object -> true
dog instanceof Animal -> true

1. 动态绑定：当实现继承关系，且向上转型后，对象被视为父级的类别，理应执行父类的方法，但是，如果子类重写了，则执行子类重写后的方法。
   名词解释为：声明期决定了调用父类的方法，但是，在执行过程中，判定结果为执行子类重写的方法，所以称之为动态绑定。