常见的几个概念
1. 数组
【数组的基本概念】
1. 数组是一组相同类型的数据的集合。
2. 每个数组都有长度,这个长度是在初始化数组的时候就已经确定的。
3. 数组的长度是不可以被改变的
4. 数组的每个元素都有“下标”(index),可以用于引用数组的元素,下标是从0开始顺序编号的。
【数组的初始化】
- 静态的初始化:在创建数组时就确定数组的各个元素的值:
int[] arr = { 9, 5, 2, 7 };
- 动态的初始化:创建数组时,需要确定数组的长度,但是可以不确定数组的各元素的值。
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);
- instanceof关键字:用于判断对象是否归属某个类,例如:
dog instanceof Dog -> true
dog instanceof Object -> true
dog instanceof Animal -> true
- 动态绑定:当实现继承关系,且向上转型后,对象被视为父级的类别,理应执行父类的方法,但是,如果子类重写了,则执行子类重写后的方法。
名词解释为:声明期决定了调用父类的方法,但是,在执行过程中,判定结果为执行子类重写的方法,所以称之为动态绑定。