描述一下概念：
1. 属性与方法
属性和方法都是类的成员，用于描述类的特征，每个类都可以有若干个属性、若干个方法。
public class Sample {
}
属性用于描述可以使用值进行量化的特征，通常属性的名称会使用名词，例如：
public class Person {
String from; // 默认为null
String name; // 默认为null
int height; // 默认为0
float weight; // 默认为0.0f
}
方法用于描述动作或者行为，通常方法的名称是动词，例如：
public class Person {
void eat() {
// 东西怎么吃的？
}
void run() {
// 怎么实现跑步的？
}
}
方法的参数：参数是当执行方法时所需要的条件。
public class Sample {
void sum(int x, int y) {
}
}
当方法声明了参数后，调用该方法时，必须提供匹配数据类型、匹配数量、匹配位置的参数值，例如：
public class Test {
public static void main(String[] a) {
Sample sample = new Sample();
// sample.sum(); // 错误
// sample.sum(1234); // 错误
// sample.sum("hello"); // 错误
sample.sum(10, 20); // 正确
}
}
每一个方法都可以有返回值，如果不需要返回值，则应该声明返回类型为void，如果需要，则声明为对应的类型，且在方法的最后，应该使用return语句返回对应类型的数据，例如：
public class Sample {
int sum(int x, int y) {
return x + y;
}
}
当调用有返回值的方法时，可以获取其返回值，也可以不获取，例如：
public class Test {
public static void main(String[] args) {
Sample sample = new Sample();
sample.sum(10, 15); // 仅调用，不获取值
int a = sample.sum(3, 7); // 调用，且获取值
}
}
对于声明为void返回值的方法，也可以使用return语句，但是，return关键字后不可以有任何值，例如：
public class Sample {
void test() {
return;
// System.out.println(); // 无法被执行的语句，错误
}
}
不管返回值是什么类型，return都应该是方法的最后一条有效语句。
为了便于开发，方法允许重载（Overload），即：在同一个类中允许存在若干个名称相同的方法，但是，这些方法的参数列表必须不同，例如：
public class Sample {
void run() {}
void run(int x) {}
void run(String str) {}
void run(String str1, String str2, int x) {}
void run(int x, String str2, String str1) {}
void run(String str1, int x, String str2) {}
}
参数列表的区别表现为：数量、数据类型、顺序
【测试题】
public class Test1 {
public static void add1(int i) {
i++;
}
public static void add2(int[] arr) {
arr[0]++;
}
public static void main(String[] args) {
int x = 10;
add1(x);
System.out.println("x=" + x); // 10
int[] array = { 9, 5, 2, 7 };
add2(array);
System.out.println("array[0]=" + array[0]); // 10
}
}
public class Test2 {
public static void main(String[] args) {
int x = 10;
int y;
y = x;
y = 15;
System.out.println("x=" + x); // 10
System.out.println("y=" + y); // 15
int[] arr1 = { 9, 5, 2, 7 };
int[] arr2;
arr2 = arr1;
arr2[0] = 15;
System.out.println("arr1[0]=" + arr1[0]); // 15
System.out.println("arr2[0]=" + arr2[0]); // 15
}
}
2. 构造方法
构造方法是一类特殊的方法，其特征是：
1) 构造方法不允许声明返回值类型，即连void都不可以
2) 构造方法的名称必须与类的名称完全相同
如果类中没有显式的声明构造方法，则编译器会自动的添加公有的、无参数的构造方法，例如以下2段代码是等效的：
public class Person {
}
public class Person {
public Person() {
super();
}
}
构造方法用于创建类的对象，例如：
public class Test {
public static void main(String[] args) {
Person p = new Person();
}
}
如果开发者显式的声明了构造方法，则编译器不会再自动添加构造方法。
构造方法可以用于创建对象时直接指定对象的某些属性值，例如没有构造方法时：
public class Person {
public String name;
public int age;
}
public class Test {
public static void main(String[] args) {
Person p = new Person();
p.name = "Jack";
p.age = 18;
}
}
如果指定了构造方法：
public class Person {
public String name;
public int age;
public Person(String personName, int personAge) {
name = personName;
age = personAge;
}
}
public class Test {
public static void main(String[] args) {
Person p = new Person("Jack", 18);
}
}
构造方法也可以重载，例如：
public class Person {
public String name;
public int age;
public Person() {
}
public Person(String personName, int personAge) {
name = personName;
age = personAge;
}
}
3. this、super关键字
this表示当前类的对象，super表示当前类的父类的对象。
public class Person extends Object {
public String name;
public Person() {
this("unknown"); // 调用自身的另一个构造方法
}
public Person(String name) {
super(); // 调用父类的构造方法
this.name = name;
}
public String toString() {
return null;
}
public void test1() {
super.toString();
}
public void test2() {
toString();
}
}
public class Test {
public static void main(String[] args) {
Person jack = new Person("Jack");
jack.name = "Jackson";
// Person.name = "???"; // 普通属性不可以这样调用
Person mike = new Person("Mike");
}
}
4. 内部类
内部类就是声明在其它类的内部的类，主要有：
1) 成员内部类：以类的成员的形式出现的内部类，例如：
public class Sample {
public void run() {
InnerClass ic = new InnerClass();
}
public class InnerClass {
System.out.println(x);
}
public int x;
}
成员内部类可以使用任何访问权限修饰符。
内部类可以访问外部类的任意成员，包括私有的。
在没有创建外部类的对象之前，不可以直接创建内部类的对象。
2) 局部内部类：定义在方法的内部的内部类。
public class Sample {
public z = 10;
public void run() {
int x = 10;
final int y = 10;
class InnerClass {
void test() {
// System.out.println(x); // 错误
System.out.println(y); // 正确
System.out.println(z); // 正确
}
}
InnerClass ic = new InnerClass();
}
}
局部内部类不可以使用任何访问权限修饰符。
使用局部内部类时，需要注意代码的先后顺序。
在局部内部类中，不可以直接访问局部变量，如果一定需要访问，可以使用final修饰该局部变量，或者将局部变量声明为全局变量(类的属性)。
3) 静态成员内部类：静态内部类是使用static修饰的成员内部类，例如：
public class Sample {
public static int x = 10;
public static class InnerClass {
public void run() {
System.out.println(x);
}
}
}
静态内部类不可以访问外部类中非静态的成员。
静态内部类可以直接创建对象，而不需要依赖于外部类的对象。
4) 匿名内部类：直接创建已知的类的子类对象，或者已知的接口的实现类对象，而创建时，并不体现子类/实现类的名称，即创建出来的对象的类名是未知的，例如：
public class Sample {
protected void onCreate() {
new OnClickListener() {
@Override
public void onClick(View v) {
}
};
}
}
Logcat日志级别
---------------------------------------
v -> verbose -> 观察 -> 黑色
d -> debug -> 调试 -> 绿色
i -> info -> 信息 -> 蓝色
w -> warn -> 警告 -> 橙色
e -> error -> 错误 -> 红色
在BaseAdapter中getView()方法的convertView重复使用
----------------------------------------
当ListView需要显示列表项时，会调用Adapter中的getView()方法。在第一次显示之后，如果滑动ListView，则某些列表项会滑出屏幕范围，而一些新的列表项会进入屏幕范围，此时，ListView会将滑出屏幕的列表项的View对象用于调用显示新列表项的getView()方法，表现为getView()方法的第2个参数convertView。
基于ListView这样的工作机制，可以保证convertView在第1次显示时均为null，但是，滑动屏幕之后，不为null，则convertView对象的数量是该ListView可以显示的列表项数量的最大值。
在编程时，应该对convertView是否为null进行判断，如果为null，则需要根据xml模板加载得到，如果不为null，则直接使用即可。convertView就是模板的View对象。